@camstack/ui-library 0.1.57 → 0.2.0

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

@@ -1,5 +1,6 @@
 import { ReactNode } from 'react';
 import { LucideIcon } from 'lucide-react';
+import { SourceInfo, ChildLayout } from '@camstack/types';
 import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
 /**
  * Mirror of the canonical `DeviceInfo` wire shape (see
@@ -26,6 +27,40 @@ export interface DeviceItemDevice {
     readonly features?: readonly string[];
     /** True for ICameraDevice instances — gates snapshot popover. */
     readonly isCamera?: boolean;
+    /** Upstream-system identity (dispatch key + system tag + optional uniqueId).
+     *  Flows from `DeviceInfo.sourceInfo` via structural cast / parse;
+     *  optional so rows from providers that pre-date SourceInfo still work.
+     *  Does NOT carry rendering hints (unit, precision) — those live in the
+     *  cap STATUS SLICE for generic numeric-sensor, or are canonical constants
+     *  in ROLE_DESCRIPTOR for typed sensor roles. */
+    readonly sourceInfo?: SourceInfo;
+    /** Soft-link to another device id. For a CONTAINER device this is the
+     *  LEGACY picker-chosen primary child (numeric id); the row/hero resolve the
+     *  primary child via `resolveContainerPrimary(children, linkDeviceId)`.
+     *  Nullable: an explicit null means "no override → priority default".
+     *  Mirrors `DeviceInfo.linkDeviceId` so the wire row passes through. */
+    readonly linkDeviceId?: number | null;
+    /** Durable primary-child override for a CONTAINER device, keyed on the
+     *  chosen child's re-sync/rename-stable `entityId`. Preferred over the
+     *  numeric `linkDeviceId` in `resolveContainerPrimary` (survives a re-sync
+     *  that reallocates the child's numeric id). Mirrors
+     *  `DeviceInfo.primaryChildEntityId`. */
+    readonly primaryChildEntityId?: string | null;
+    /** Container-level layout hint: assigns specific accessory children to named
+     *  accordion sections (with optional intra-section order). Each entry's
+     *  `childKey` is the child's re-sync-stable accessory `stableIdSuffix`; a child
+     *  matches when `child.stableId === ${this.stableId}-${childKey}`. Mirrors
+     *  `DeviceInfo.childLayout` so the wire row passes through. Absent ⇒ no layout
+     *  declared (all children render in the plain list). Consumed by
+     *  `groupChildrenByLayout` for the device-detail list + the table row
+     *  expansion. */
+    readonly childLayout?: ChildLayout;
+    /** Hardware + identity blob (manufacturer / model / firmware / sn / uid /
+     *  mac / …). Driver-populated; keys are free-form and values arbitrary, so
+     *  consumers MUST treat them defensively (string-coerce for display, skip
+     *  non-string/empty). Mirrors `DeviceInfo.metadata` so the wire row passes
+     *  through unchanged. Absent/null ⇒ no identity info advertised. */
+    readonly metadata?: Readonly<Record<string, unknown>> | null;
 }
 export interface DeviceItemParent {
     readonly id: number;
@@ -105,6 +140,47 @@ export interface DeviceItemProps {
      * so every existing call site renders unchanged.
      */
     readonly renderRowAction?: (device: DeviceItemDevice) => ReactNode;
+    /**
+     * Built-in confirmed delete (TABLE feature). When provided, the merged
+     * previewActions cell renders a red trash button that opens the shared
+     * centered confirm dialog and calls `onDelete(device)` only on confirm.
+     * Cap/feature-agnostic — delete is generic. Context gating is "consumer
+     * passes the handler or not": omitted ⇒ no trash, zero layout change.
+     * No effect on `view='card'` (card delete is a deliberate follow-up).
+     */
+    readonly onDelete?: (device: DeviceItemDevice) => void;
+    /**
+     * When provided, renders a leading checkbox for row selection.
+     * Only passed to top-level rows (accessory sub-rows omit it).
+     * Omitted ⇒ no checkbox, zero layout change for existing callers.
+     */
+    readonly selection?: {
+        readonly selected: boolean;
+        readonly onToggle: () => void;
+    };
+    /**
+     * When `true` (and `selection` is provided), a click anywhere on the
+     * row's primary body toggles selection instead of navigating — the
+     * batch-mode interaction (spec §6). The row also gains an accessible
+     * pressed affordance (`role="button"` + `aria-pressed`). When omitted
+     * or `false`, the row navigates on click as usual; the leading
+     * checkbox remains the only selection surface. The checkbox always
+     * toggles regardless of this flag (and never bubbles to navigate).
+     */
+    readonly rowClickSelects?: boolean;
+    /**
+     * Table-view column gates (context-configured). Default `true` so every
+     * existing call site renders all cells. When `false`, the corresponding
+     * `<td>` is omitted entirely (the matching `<th>` is gated in the parent
+     * `TableLayout`, so header + cells stay in lock-step). No effect on
+     * `view='card'`.
+     */
+    readonly showTypeCell?: boolean;
+    /** Render the Hardware (manufacturer/model) `<td>` (context-gated). Default
+     *  `true` so existing call sites render it; the parent `TableLayout` gates the
+     *  matching `<th>` so header + cell stay in lock-step. No effect on `'card'`. */
+    readonly showManufacturerCell?: boolean;
+    readonly showFeaturesCell?: boolean;
 }
 export interface VariantDefaults {
     readonly showIntegrationIcon: boolean;
@@ -117,8 +193,6 @@ export interface VariantDefaults {
     readonly showChildrenAccordion: boolean;
 }
 export declare function resolveFlags(props: DeviceItemProps): VariantDefaults;
-export declare const ROLE_ICONS: Readonly<Record<string, LucideIcon>>;
-export declare const TYPE_ICONS: Readonly<Record<string, LucideIcon>>;
 export declare function deviceLeadIcon(device: DeviceItemDevice): LucideIcon;
 /**
  * Icon for each `DeviceFeature` advertised on a device row. Used by
@@ -153,4 +227,36 @@ export declare const FEATURE_TO_CAP_NAME: Readonly<Record<string, string>>;
 export declare function maySupportSwitch(device: DeviceItemDevice): boolean;
 export declare function isAccessoryChild(device: DeviceItemDevice): boolean;
 export declare function hasMotionTriggerFeature(device: DeviceItemDevice): boolean;
+/**
+ * Effective online state for a device row's status dot.
+ *
+ * A CONTAINER device renders AS its PRIMARY child (same row control via
+ * `ContainerPrimaryInline`, same hero via `ContainerPrimaryHero`). Its
+ * reachability dot should therefore follow that primary child's `online`,
+ * NOT "any child online" — so the dot and the control gate agree (the
+ * control is bound to the same primary child via `resolveContainerPrimary`).
+ *
+ * Resolution reuses the SAME `resolveContainerPrimary(children, linkDeviceId)`
+ * helper the row control uses, then reads the resolved child row's `online`.
+ * Degrades gracefully: a non-container, a container with no children, or a
+ * container with no resolvable primary child falls back to `device.online`
+ * (never crashes, never forces offline).
+ */
+export declare function effectiveOnline(device: DeviceItemDevice, containerChildren: readonly DeviceItemDevice[] | undefined): boolean;
+/**
+ * The type a CONTAINER should DISPLAY as (and be FILTERED by): its primary
+ * child's type, since a container renders as that child (a vacuum container
+ * should read + filter as `vacuum`, not the structural `container`). Mirrors
+ * {@link effectiveOnline} — same primary-child resolution. Non-containers, and
+ * containers with no resolvable primary child, fall back to `device.type`.
+ */
+export declare function effectiveType(device: DeviceItemDevice, containerChildren: readonly DeviceItemDevice[] | undefined): string;
+/**
+ * The device whose lead ICON a row should display: a Container shows its
+ * primary CHILD's icon (the child's type + role drive the glyph, e.g. a vacuum
+ * rather than the generic container box). Mirrors {@link effectiveType}, but
+ * returns the resolved device so {@link deviceLeadIcon} also picks up the
+ * child's role. Falls back to the device itself for non-containers / no primary.
+ */
+export declare function effectiveIconDevice(device: DeviceItemDevice, containerChildren: readonly DeviceItemDevice[] | undefined): DeviceItemDevice;
 export declare function shortStableId(stableId: string): string;

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

@@ -2,4 +2,8 @@ import { ReactNode } from 'react';
 import { DeviceItemProps } from './helpers';
 export type { DeviceItemDevice, DeviceItemParent, DeviceItemKind, DeviceItemVariant, DeviceItemView, DeviceItemProps, } from './helpers';
 export { deriveDeviceKind } from './helpers';
+export { ChildSectionAccordion } from './child-section-accordion';
+export { ContainerChildrenProvider, useContainerChildren } from './container-children-context';
+export { groupChildrenByLayout } from './child-layout';
+export type { GroupedChildren, ChildLayoutSection } from './child-layout';
 export declare function DeviceItem(props: DeviceItemProps): ReactNode;

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

@@ -6,7 +6,7 @@ export interface DeviceItemPreviewProps {
     readonly device: DeviceItemDevice;
     readonly status: 'online' | 'offline' | 'disabled';
     /**
-     * Render gate for the snapshot eye icon (typically
+     * Render gate for the snapshot thumbnail (typically
      * `flags.showSnapshot && isCamera` from the orchestrator). Even when
      * `false`, the component still renders the status-pills row when
      * `showStatusPills` is on.
@@ -14,8 +14,8 @@ export interface DeviceItemPreviewProps {
     readonly enabled: boolean;
     /**
      * When true, render the battery / charging / sleeping pills next to
-     * the snapshot eye. Driven by table view (where the Preview cell is
-     * the natural home for status indicators); off in card view to keep
+     * the snapshot thumbnail. Driven by table view (where the Preview cell
+     * is the natural home for status indicators); off in card view to keep
      * the row narrow.
      */
     readonly showStatusPills?: boolean;

package/dist/composites/device-item/reboot-quick-action.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
+export interface RebootQuickActionProps {
+    readonly trpc: UseDeviceProxyTrpc;
+    readonly deviceId: number;
+    /** Device display name — woven into the confirm-modal body. */
+    readonly deviceName: string;
+}
+export declare function RebootQuickAction({ trpc, deviceId, deviceName, }: RebootQuickActionProps): ReactNode;

package/dist/composites/device-item/status-dot.d.ts

@@ -1,5 +1,8 @@
 import { ReactNode } from 'react';
 export interface StatusDotProps {
     readonly status: 'online' | 'offline' | 'disabled';
+    /** Ms epoch of the last online→offline transition. Only used to enrich
+     *  the tooltip when `status === 'offline'`. */
+    readonly lastChangedAt?: number | null;
 }
-export declare function StatusDot({ status }: StatusDotProps): ReactNode;
+export declare function StatusDot({ status, lastChangedAt }: StatusDotProps): ReactNode;

package/dist/composites/device-list/batch-actions-bar.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+export interface DeviceBatchActionsBarProps {
+    readonly selectedIds: ReadonlySet<number>;
+    readonly onClear: () => void;
+    readonly remove: (input: {
+        deviceId: number;
+    }) => void;
+    readonly disable: (input: {
+        deviceId: number;
+    }) => void;
+    readonly enable: (input: {
+        deviceId: number;
+    }) => void;
+}
+export declare function DeviceBatchActionsBar(props: DeviceBatchActionsBarProps): ReactNode;

package/dist/composites/device-list/batch-toolbar.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+export interface DeviceBatchToolbarProps {
+    readonly selectedIds: ReadonlySet<number>;
+    readonly onClear: () => void;
+    readonly remove: (input: {
+        deviceId: number;
+    }) => void;
+    readonly disable: (input: {
+        deviceId: number;
+    }) => void;
+    readonly enable: (input: {
+        deviceId: number;
+    }) => void;
+}
+export declare function DeviceBatchToolbar({ selectedIds, onClear, remove, disable, enable, }: DeviceBatchToolbarProps): ReactNode;

package/dist/composites/device-list/cards-layout.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
+import { DeviceItemDevice, DeviceItemParent } from '../device-item/helpers';
+export interface CardsLayoutProps {
+    readonly rows: readonly DeviceItemDevice[];
+    readonly accessoriesByParent: ReadonlyMap<number, readonly DeviceItemDevice[]>;
+    readonly trpc: UseDeviceProxyTrpc;
+    readonly resolveIntegrationIcon: ((addonId: string) => ReactNode | null) | null;
+    readonly resolveParent: ((parentId: number) => DeviceItemParent | null) | null;
+    readonly onNavigate: ((deviceId: number) => void) | null;
+    readonly renderRowAction: ((device: DeviceItemDevice) => ReactNode) | null;
+    readonly selectable: boolean;
+    /** Batch mode active — a row click toggles selection instead of navigating. */
+    readonly rowClickSelects: boolean;
+    readonly activeSelected: ReadonlySet<number>;
+    readonly onToggleSelection: (id: number) => void;
+}
+export declare function CardsLayout({ rows, accessoriesByParent, trpc, resolveIntegrationIcon, resolveParent, onNavigate, renderRowAction, selectable, rowClickSelects, activeSelected, onToggleSelection, }: CardsLayoutProps): ReactNode;

package/dist/composites/device-list/columns.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Device-mode column model: a fixed catalog, a per-context subset matrix,
+ * a responsive priority, and a priority-derived breakpoint mapping. Each
+ * consumer declares its `TableContext`; the table renders only the columns
+ * that context enables, in catalog order, hiding the optional ones as the
+ * viewport narrows.
+ *
+ * The catalog is intentionally device-mode only. Generic-mode (integration
+ * rows) keeps its own `DeviceListColumn[]` defs — reconciled in a later phase.
+ *
+ * ── Responsive convention (single source of truth) ────────────────────────
+ *   LOWER priority number = MORE important = hidden at a NARROWER width (kept
+ *   longest). So as the viewport shrinks the HIGHEST-priority-number column
+ *   drops first.
+ *
+ *     name           (0) — never hidden; sticky left, always visible
+ *     previewActions (1) — never hidden; carries the live control + status dot
+ *     icon           (2) — integration badge; rendered INSIDE the name cell,
+ *                          not a standalone column, so it has no breakpoint
+ *     features       (3) — optional; hidden below `md` (kept longer)
+ *     type           (4) — optional; hidden below `lg`
+ *     manufacturer   (5) — optional; hidden below `xl` (drops FIRST,
+ *                          wide-screen-only hardware/identity column)
+ *
+ *   `COLUMN_BREAKPOINT_CLASS` derives ONE Tailwind visibility class per id and
+ *   is the single source used by BOTH the `<th>` and the `<td>`, so a hidden
+ *   column folds header + cell in lock-step. The drop order is therefore:
+ *   `manufacturer` first (below `xl`), then `type` (below `lg`), then
+ *   `features` (below `md`) — matching the priority numbers above.
+ */
+/** Fixed device-mode column catalog, in render order. `name` is always first.
+ *  `manufacturer` sits after `type` — a wide-screen-only hardware/identity
+ *  column (manufacturer · model, full metadata in a tooltip). */
+export declare const DEVICE_COLUMNS: readonly ["name", "icon", "type", "manufacturer", "features", "previewActions"];
+export type DeviceColumnId = (typeof DEVICE_COLUMNS)[number];
+/**
+ * The places a device table is rendered; each declares its column subset.
+ *
+ * Device-detail CHILDREN are deliberately NOT a table context: they render as
+ * a stack of `<DeviceItem variant="minimal">` cards (see `ChildrenList`), not
+ * through this table, so no `device-children` context exists.
+ */
+export type TableContext = 'devices' | 'integration-detail';
+export declare function columnsForContext(ctx: TableContext): readonly DeviceColumnId[];
+/**
+ * Lower number = higher priority (kept longest as width shrinks). `name` = 0
+ * (sticky, never dropped); `previewActions` = 1 (always visible). The optional
+ * columns drop in REVERSE priority order as width shrinks — highest number
+ * (`type`) hides first, then `features`. `icon` is a name-cell badge, not a
+ * standalone column. See `COLUMN_BREAKPOINT_CLASS` for the derived classes.
+ */
+export declare const COLUMN_PRIORITY: Record<DeviceColumnId, number>;
+/**
+ * Priority-derived Tailwind visibility class per column. Used by BOTH the
+ * `<th>` and the `<td>` (single source → header + cell stay in lock-step).
+ *
+ *   - `name` / `previewActions`: empty string — never hidden (always visible).
+ *   - `icon`: empty string — rendered inside the name cell, no standalone cell.
+ *   - `features`: `hidden md:table-cell` — visible from `md` up (kept longer).
+ *   - `type`: `hidden lg:table-cell` — visible only from `lg` up.
+ *   - `manufacturer`: `hidden xl:table-cell` — visible only from `xl` up (drops
+ *     first).
+ *
+ * Drop order as the viewport narrows therefore follows the priority numbers:
+ * `manufacturer` (5) disappears below `xl`, then `type` (4) below `lg`, then
+ * `features` (3) below `md`.
+ */
+export declare const COLUMN_BREAKPOINT_CLASS: Record<DeviceColumnId, string>;

package/dist/composites/device-list/device-mode.d.ts

@@ -0,0 +1,115 @@
+import { ReactNode } from 'react';
+import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
+import { DeviceItemDevice, DeviceItemParent } from '../device-item/helpers';
+import { DeviceListView } from './url-state';
+import { TableContext } from './columns';
+import { MultiSelectOption } from './multi-select';
+export interface DeviceListAddonOption {
+    readonly id: string;
+    readonly name: string;
+    readonly icon?: ReactNode;
+}
+export interface DeviceListDeviceProps {
+    /** Discriminant — omit (or 'devices') for the default registry-device list. */
+    readonly mode?: 'devices';
+    /**
+     * Where this table is rendered — selects the visible column subset (table
+     * view only). Defaults to `'devices'` (all columns) so every existing
+     * call site renders unchanged.
+     */
+    readonly context?: TableContext;
+    readonly devices: readonly DeviceItemDevice[];
+    readonly trpc: UseDeviceProxyTrpc;
+    readonly defaultView?: DeviceListView;
+    /**
+     * Integration filter options + an optional TYPE-filter override.
+     *
+     * The type filter defaults to the EXHAUSTIVE device-type set
+     * (`allDeviceTypeFilterOptions`), so a newly added `DeviceType` appears
+     * automatically on every general list and nothing is ever missing. A
+     * surface that lists only a known subset (e.g. the export panel restricts
+     * to an exporter's supported kinds) may pass `typeOptions` to narrow the
+     * dropdown to that subset — built from the same shared meta so labels +
+     * icons stay identical.
+     */
+    readonly filters?: {
+        readonly addons?: readonly DeviceListAddonOption[];
+        readonly typeOptions?: readonly MultiSelectOption[];
+    };
+    /** Pre-applied addon filter — hides the addon-chip group. */
+    readonly forceAddon?: string;
+    readonly resolveIntegrationIcon?: (addonId: string) => ReactNode | null;
+    readonly resolveParent?: (parentId: number) => DeviceItemParent | null;
+    readonly onNavigate?: (deviceId: number) => void;
+    readonly pageSize?: {
+        readonly cards: number;
+        readonly table: number;
+    };
+    readonly urlScope?: 'root' | 'nested';
+    /** LocalStorage key prefix. Default 'devices' for root scope, 'integrations:nested' for nested. */
+    readonly lsKey?: string;
+    /**
+     * Optional trailing per-row control rendered beside each row's
+     * built-in actions (both card + table views, top-level rows only —
+     * accessory sub-rows are excluded). Threaded straight through to
+     * `<DeviceItem renderRowAction>`. Omitted ⇒ every current call site
+     * (Devices, IntegrationDetail, Integrations nested) renders unchanged.
+     * Used by `<DeviceExportPanel>` to surface a per-device Expose toggle.
+     */
+    readonly renderRowAction?: (device: DeviceItemDevice) => ReactNode;
+    /**
+     * Built-in confirmed per-row DELETE — a first-class TABLE feature. When
+     * provided, every top-level table row renders a red trash button in the
+     * merged actions cell; clicking it opens the shared centered confirm
+     * dialog ("Delete device?") and calls `onDeleteDevice(device)` only on
+     * confirm. Accessory sub-rows are excluded (same gate as `renderRowAction`).
+     * Context gating is "consumer passes the handler or not" — omit it (default)
+     * and no trash renders, so existing call sites are unchanged. Cap-agnostic:
+     * delete is generic and never branches on the device's capabilities. The
+     * confirm is built in, so consumers must NOT add their own. Table-only for
+     * now (card delete is a follow-up).
+     */
+    readonly onDeleteDevice?: (device: DeviceItemDevice) => void;
+    /**
+     * When `true`, renders a leading checkbox on each top-level row
+     * (accessory sub-rows are excluded — same gate as `renderRowAction`).
+     * Selection state may be controlled via `selectedIds`; when omitted
+     * the list maintains internal state.
+     */
+    readonly selectable?: boolean;
+    /**
+     * Controlled set of selected device ids. Provide together with
+     * `onSelectionChange` for a fully controlled selection surface.
+     * Omit to let `<DeviceList>` manage internal state.
+     */
+    readonly selectedIds?: ReadonlySet<number>;
+    /**
+     * Called on every toggle with the NEW full selection set.
+     * Invoked for both controlled and uncontrolled usage.
+     */
+    readonly onSelectionChange?: (ids: ReadonlySet<number>) => void;
+    /**
+     * Opt into self-managed BATCH MODE. When provided, the list renders an
+     * "Select" activation button; batch mode is OFF by default (no
+     * checkboxes, no bulk toolbar). Activating it reveals the leading
+     * row checkboxes plus a responsive bulk-actions bar wired to these
+     * callbacks (full toolbar at `sm+`, a compact menu at L1). Selection
+     * state is managed internally for the duration of the activated
+     * session and cleared on exit. Mutually independent from the
+     * lower-level `selectable`/`selectedIds` controlled API.
+     */
+    readonly batchActions?: DeviceListBatchActions;
+}
+/** Self-managed batch-mode bulk-action callbacks (see `batchActions`). */
+export interface DeviceListBatchActions {
+    readonly remove: (input: {
+        deviceId: number;
+    }) => void;
+    readonly disable: (input: {
+        deviceId: number;
+    }) => void;
+    readonly enable: (input: {
+        deviceId: number;
+    }) => void;
+}
+export declare function DeviceModeList(props: DeviceListDeviceProps): ReactNode;

package/dist/composites/device-list/filter-chips.d.ts

@@ -1,16 +1,25 @@
 import { ReactNode } from 'react';
 import { DeviceListView } from './url-state';
+import { MultiSelectOption } from './multi-select';
 export interface FilterChipsAddonOption {
     readonly id: string;
     readonly name: string;
     readonly icon?: ReactNode;
 }
 export interface FilterChipsProps {
-    readonly view: DeviceListView;
-    readonly onViewChange: (view: DeviceListView) => void;
-    readonly types?: readonly string[];
-    readonly currentType: string | null;
-    readonly onTypeChange: (type: string | null) => void;
+    readonly view?: DeviceListView;
+    readonly onViewChange?: (view: DeviceListView) => void;
+    /** Hide the cards/table view toggle (generic lists have a single view). */
+    readonly hideView?: boolean;
+    /**
+     * Ready-made options for the shared multi-select type filter. Built once by
+     * the caller from the exhaustive device-type meta (`allDeviceTypeFilterOptions`)
+     * so the option set is complete + identical everywhere. Omit to hide the
+     * type filter entirely.
+     */
+    readonly typeOptions?: readonly MultiSelectOption[];
+    readonly selectedTypes: readonly string[];
+    readonly onTypesChange: (types: readonly string[]) => void;
     readonly addons?: readonly FilterChipsAddonOption[];
     /** Currently-selected integration ids (multi-select). */
     readonly selectedAddons: readonly string[];
@@ -18,4 +27,4 @@ export interface FilterChipsProps {
     /** When true, the addon group is hidden (used by Integrations expand-row inner DeviceList). */
     readonly hideAddons?: boolean;
 }
-export declare function FilterChips({ view, onViewChange, types, currentType, onTypeChange, addons, selectedAddons, onAddonsChange, hideAddons, }: FilterChipsProps): ReactNode;
+export declare function FilterChips({ view, onViewChange, hideView, typeOptions, selectedTypes, onTypesChange, addons, selectedAddons, onAddonsChange, hideAddons, }: FilterChipsProps): ReactNode;

package/dist/composites/device-list/fuzzy-match.d.ts

@@ -0,0 +1,27 @@
+/**
+ * fuzzy-match — case and separator-insensitive text search helper.
+ *
+ * Normalization rule: lowercase + strip all runs of hyphens, underscores and
+ * whitespace entirely.  This makes `Tapparella cucina` and `tapparella-cucina`
+ * both normalize to `tapparellacucina`, so a substring match succeeds in
+ * either direction.
+ */
+/**
+ * Strips hyphens, underscores and whitespace runs from `s` and lowercases it.
+ *
+ * @example
+ * normalizeForSearch('Tapparella cucina') // 'tapparellacucina'
+ * normalizeForSearch('tapparella-cucina') // 'tapparellacucina'
+ * normalizeForSearch('tapparella_cucina') // 'tapparellacucina'
+ */
+export declare function normalizeForSearch(s: string): string;
+/**
+ * Returns `true` when the normalized form of `target` contains the normalized
+ * form of `query`.  An empty query always matches.
+ *
+ * @example
+ * fuzzyMatch('Tapparella cucina', 'tapparella-cucina') // true
+ * fuzzyMatch('tapparella cucina', 'Tapparella-Cucina') // true
+ * fuzzyMatch('xyz', 'tapparella-cucina')               // false
+ */
+export declare function fuzzyMatch(query: string, target: string): boolean;

package/dist/composites/device-list/generic-mode.d.ts

@@ -0,0 +1,81 @@
+import { ReactNode } from 'react';
+import { LucideIcon } from 'lucide-react';
+import { MultiSelectOption } from './multi-select';
+/**
+ * Generic-mode props — a paginated, searchable, render-prop list that reuses
+ * the same chrome (search box + <Pagination>) as the device list but over an
+ * arbitrary item type. Used by the HA adoption modal for discovered-device
+ * candidates; selection + per-row controls live in the caller's `renderItem`.
+ */
+/** One column of the generic-mode TABLE rendering. */
+export interface DeviceListColumn<T> {
+    readonly key: string;
+    readonly header: ReactNode;
+    readonly cell: (item: T) => ReactNode;
+    /** Extra classes on the `<th>` (width, responsive hiding, alignment). */
+    readonly headerClassName?: string;
+    /** Extra classes on the `<td>`. */
+    readonly cellClassName?: string;
+}
+export interface DeviceListGenericProps<T> {
+    readonly mode: 'generic';
+    readonly items: readonly T[];
+    readonly getKey: (item: T) => string;
+    readonly getSearchText: (item: T) => string;
+    /**
+     * Row body. Provide EITHER `columns` (renders a table matching the device
+     * list's table styling) OR `renderItem` (a free-form row list). `columns`
+     * wins when both are set.
+     */
+    readonly renderItem?: (item: T) => ReactNode;
+    /** Table columns — when set, the list renders as a bordered table. */
+    readonly columns?: readonly DeviceListColumn<T>[];
+    /** Full-width expansion row rendered under an item when `isExpanded` is true. */
+    readonly renderExpanded?: (item: T) => ReactNode;
+    readonly isExpanded?: (item: T) => boolean;
+    /** Per-row class (table `<tr>` or list wrapper) — e.g. selected/adopted state. */
+    readonly rowClassName?: (item: T) => string;
+    /** Click handler for a whole table row — when set, the `<tr>` becomes a
+     *  clickable button (cursor + keyboard) that navigates/opens the item.
+     *  Per-cell interactive controls must `stopPropagation` to avoid double-firing. */
+    readonly onRowClick?: (item: T) => void;
+    /**
+     * Optional type-filter projection. When provided, the list renders a compact
+     * MULTI-SELECT dropdown over the DISTINCT values present in `items` and keeps
+     * items matching ANY selected value (empty selection = no filter). Return
+     * `null` for items that carry no type. Omit to hide the filter entirely.
+     */
+    readonly getFilterType?: (item: T) => string | null;
+    /**
+     * Enrich a raw filter value into a display `{ label, icon }` for the
+     * multi-select (e.g. via the device-type meta map). Defaults to the raw
+     * value as label, no icon. Ignored when `filterOptions` is supplied.
+     */
+    readonly mapFilterOption?: (value: string) => {
+        readonly label: string;
+        readonly icon?: LucideIcon;
+    };
+    /**
+     * Ready-made, COMPLETE option set for the type filter. When supplied, it
+     * overrides the present-values-only set the list would otherwise derive from
+     * `items` — so e.g. the adoption modal shows every `DeviceType` (via
+     * `allDeviceTypeFilterOptions`), not just the types of the current
+     * candidates. `getFilterType` still selects each item's value for matching.
+     */
+    readonly filterOptions?: readonly MultiSelectOption[];
+    /** Label for the type multi-select trigger. Default 'Type'. */
+    readonly filterLabel?: string;
+    readonly isLoading?: boolean;
+    readonly searchPlaceholder?: string;
+    readonly emptyLabel?: string;
+    readonly pageSize?: number;
+    /** Optional control rendered next to the search box (e.g. a Refresh button). */
+    readonly toolbar?: ReactNode;
+}
+/**
+ * Generic render-prop list: search + pagination chrome shared with the device
+ * list, over an arbitrary item type. Local (non-URL) state — intended for
+ * modal/ephemeral surfaces. Selection + per-row controls are the caller's, via
+ * `renderItem`.
+ */
+export declare function GenericModeList<T>(props: DeviceListGenericProps<T>): ReactNode;

package/dist/composites/device-list/group.d.ts

@@ -1,4 +1,23 @@
 import { DeviceItemDevice } from '../device-item/helpers';
+/**
+ * countableDevices — the subset of `devices` that should be counted in
+ * the device-list footer "Showing N of **M** devices".
+ *
+ * A device is countable when:
+ *   - it has no parent (`parentDeviceId === null`), OR
+ *   - its parent's type is a hub-like owner (`hub` / `nvr`) — an NVR's
+ *     cameras and a hub's children are real, individually-operable devices.
+ *
+ * Excluded:
+ *   - devices whose parent has type `container` — a Container is a grouping
+ *     shell for entity-children (e.g. a HA device's entities); the children
+ *     are represented by the parent row and must NOT inflate the total.
+ *   - orphan devices (parent id present but not in the input list) are
+ *     treated as countable — better to over-count by one than hide them.
+ *
+ * Pure: builds a `Map<id, device>` once and then filters in a single pass.
+ */
+export declare function countableDevices(devices: readonly DeviceItemDevice[]): readonly DeviceItemDevice[];
 export interface GroupedDevices {
     readonly topLevel: readonly DeviceItemDevice[];
     readonly accessoriesByParent: ReadonlyMap<number, readonly DeviceItemDevice[]>;

package/dist/composites/device-list/hardware-cell.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+import { DeviceItemDevice } from '../device-item/helpers';
+interface HardwareCellProps {
+    readonly device: DeviceItemDevice;
+}
+export declare function HardwareCell({ device }: HardwareCellProps): ReactNode;
+export {};

package/dist/composites/device-list/hardware.d.ts

@@ -0,0 +1,26 @@
+import { DeviceItemDevice } from '../device-item/helpers';
+/** Coerce a single metadata value to a trimmed, non-empty display string.
+ *  Strings pass through (trimmed); finite numbers + booleans coerce; every
+ *  other shape (object, array, null, undefined, NaN) yields `null` so callers
+ *  skip it rather than render a useless `[object Object]`. */
+export declare function metadataValueString(value: unknown): string | null;
+/** Read one metadata key as a safe display string (null when absent/empty). */
+export declare function metadataString(metadata: Readonly<Record<string, unknown>> | null | undefined, key: string): string | null;
+/** Compact cell text: `manufacturer · model`, or whichever is present, or
+ *  `null` when neither is a usable string (caller renders the empty state). */
+export declare function hardwareLabel(device: DeviceItemDevice): string | null;
+/** A single key/value pair for the metadata tooltip dump. */
+export interface MetadataEntry {
+    readonly key: string;
+    readonly value: string;
+}
+/** All string-coercible, non-empty metadata entries in insertion order — the
+ *  full identity blob for the tooltip. Empty array when there's nothing to show. */
+export declare function metadataEntries(metadata: Readonly<Record<string, unknown>> | null | undefined): readonly MetadataEntry[];
+/** True when the device advertises a non-empty `manufacturer`. Drives the
+ *  direction-independent "missing sorts last" rule in `sortRows`. */
+export declare function hasManufacturer(device: DeviceItemDevice): boolean;
+/** Ascending, case-insensitive comparator on `manufacturer` then `model`. The
+ *  "missing manufacturer sorts last" rule is applied direction-independently by
+ *  the caller (`sortRows`); this comparator only orders the values themselves. */
+export declare function compareHardware(a: DeviceItemDevice, b: DeviceItemDevice): number;