@camstack/ui-library 1.2.256 → 1.2.258

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

@@ -1,45 +1,72 @@
-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.
- */
+* groupTopLevelAndAccessories — pure splitter for the DeviceList
+* row pipeline.
+*
+* Classification:
+*   - Top-level rows: standalone devices (`parentDeviceId === null`)
+*     plus adopted devices whose parent is a hub or NVR (e.g. cameras
+*     under a `Home hub`). Adopted devices keep their parent badge but
+*     render as primary rows + paginate.
+*   - Accessories: devices whose parent is a CAMERA (or any non-
+*     hub/nvr type). Render nested under the parent's chevron.
+*
+* Why parent-type and not the device's own `role`: the wire response
+* from `deviceManager.listAll` ships `role: null` even for siren /
+* floodlight / pir-sensor children — `device.role` is currently only
+* populated on the in-memory `IDevice` instance and is dropped during
+* `toDeviceInfo()` projection. Using parent-type gives the same answer
+* without depending on a field that's empty in practice. As a defensive
+* fallback we ALSO treat any row with a non-null `role` as an accessory
+* so a future wire fix doesn't accidentally re-flatten the table.
+*
+*   - Orphan accessories (parentDeviceId references a device not in
+*     the input list) fall through to topLevel — better to show them
+*     once with a stale parent badge than hide them entirely.
+*
+* Pure: no side effects, no React; testable as a unit.
+*/
+import type { 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[]>;
+	readonly topLevel: readonly DeviceItemDevice[];
+	readonly accessoriesByParent: ReadonlyMap<number, readonly DeviceItemDevice[]>;
 }
 /** Options for `groupTopLevelAndAccessories`. */
 export interface GroupDevicesOptions {
-    /** Include devices carrying an operator `display.hidden` override. Default
-     *  false — hidden devices are omitted from BOTH top-level and accessory
-     *  lists. NOTE: distinct from the HA `accessories` cap `hiddenChildIds`
-     *  mechanism (container-scoped, provider-persisted) — this is the device-level
-     *  `display.hidden` flag. A future "show hidden" toggle flips this one prop. */
-    readonly includeHidden?: boolean;
+	/** Include devices carrying an operator `display.hidden` override. Default
+	*  false — hidden devices are omitted from BOTH top-level and accessory
+	*  lists. NOTE: distinct from the HA `accessories` cap `hiddenChildIds`
+	*  mechanism (container-scoped, provider-persisted) — this is the device-level
+	*  `display.hidden` flag. A future "show hidden" toggle flips this one prop. */
+	readonly includeHidden?: boolean;
 }
 /**
- * Re-order top-level rows so an ADOPTED device sits immediately after its
- * parent row (a camera adopted by a `Home hub` is a primary row by design,
- * but a primary row whose family is scattered across the table reads as a
- * bug — the operator saw a standalone camera WEDGED between a hub and its
- * two children). Pure and stable: parents/standalone keep their incoming
- * relative order, siblings keep theirs, and a child whose parent is not a
- * top-level row keeps its own position (emitted in the leftover pass —
- * never dropped).
- */
+* Re-order top-level rows so an ADOPTED device sits immediately after its
+* parent row (a camera adopted by a `Home hub` is a primary row by design,
+* but a primary row whose family is scattered across the table reads as a
+* bug — the operator saw a standalone camera WEDGED between a hub and its
+* two children). Pure and stable: parents/standalone keep their incoming
+* relative order, siblings keep theirs, and a child whose parent is not a
+* top-level row keeps its own position (emitted in the leftover pass —
+* never dropped).
+*/
 export declare function orderAdoptedAfterParent(rows: readonly DeviceItemDevice[]): readonly DeviceItemDevice[];
 export declare function groupTopLevelAndAccessories(devices: readonly DeviceItemDevice[], options?: GroupDevicesOptions): GroupedDevices;

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

@@ -1,7 +1,18 @@
-import { ReactNode } from 'react';
-import { DeviceItemDevice } from '../device-item/helpers';
+/**
+* `<HardwareCell>` — the inner content of the device-table `manufacturer`
+* column's `<td>`. Renders the compact `manufacturer · model` label and, on
+* hover/focus, a tooltip listing the FULL device-metadata identity blob
+* (every string-coercible, non-empty key/value pair).
+*
+* Reuses the shared `<Tooltip>` primitive (`primitives/tooltip`). The default
+* tooltip is single-line (`whitespace-nowrap`); we override that so the
+* key/value list wraps and left-aligns. When there's no usable metadata the
+* cell shows an em-dash and no tooltip wraps it (nothing to reveal).
+*/
+import type { ReactNode } from "react";
+import type { DeviceItemDevice } from "../device-item/helpers";
 interface HardwareCellProps {
-    readonly device: DeviceItemDevice;
+	readonly device: DeviceItemDevice;
 }
 export declare function HardwareCell({ device }: HardwareCellProps): ReactNode;
 export {};

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

@@ -1,26 +1,44 @@
-import { DeviceItemDevice } from '../device-item/helpers';
+/**
+* Pure helpers for the device-table `manufacturer` column.
+*
+* A device's hardware/identity blob lives in `DeviceItemDevice.metadata`
+* (mirror of `DeviceInfo.metadata`) — a driver-populated, free-form
+* `Record<string, unknown>`. Keys are NOT a fixed enum; values are arbitrary.
+* These helpers coerce that untrusted blob into safe display strings:
+*
+*   - `metadataString` — read ONE key as a trimmed non-empty string, else null.
+*   - `hardwareLabel` — the compact cell text (`manufacturer · model`).
+*   - `metadataEntries` — the full key/value list for the tooltip (only
+*      string-coercible, non-empty values; stable insertion order).
+*   - `compareHardware` — comparator on `manufacturer` then `model`.
+*
+* The `unknown` → string boundary is handled with a `typeof === 'string'`
+* guard plus a numeric/boolean coercion fallback; objects/arrays/null are
+* skipped (never `String([object Object])`).
+*/
+import type { 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]`. */
+*  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). */
+*  `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;
+	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. */
+*  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`. */
+*  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. */
+*  "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;

package/dist/composites/device-list/icon-action.d.ts

@@ -1,17 +1,29 @@
-import { ComponentType, ReactNode } from 'react';
+/**
+* IconAction — icon-only action button for condensed table action cells.
+*
+* Absorbed from the (now-retired in Phase 5) `device-table/cells.tsx` so the
+* unified `device-list/` table owns its own condensation helpers and does not
+* depend on the skeleton directory.
+*
+* The `label` is accessible via `aria-label` and `title` but is NOT rendered as
+* visible text, keeping the button compact at narrow widths. A `danger` flag
+* applies the `text-danger` token (and matching hover) for destructive actions
+* such as Delete, which keep their red treatment even when condensed to an icon.
+*/
+import type { ComponentType, ReactNode } from "react";
 export interface IconActionProps {
-    /** Lucide icon component (or any component accepting `className?: string`). */
-    readonly icon: ComponentType<{
-        className?: string;
-    }>;
-    /** Human-readable label — exposed via aria-label + title, NOT as visible text. */
-    readonly label: string;
-    /** Click handler. */
-    readonly onClick: () => void;
-    /**
-     * When true, applies a red/destructive accent to the button. Use for Delete
-     * and other irreversible actions — Delete keeps red even icon-only.
-     */
-    readonly danger?: boolean;
+	/** Lucide icon component (or any component accepting `className?: string`). */
+	readonly icon: ComponentType<{
+		className?: string;
+	}>;
+	/** Human-readable label — exposed via aria-label + title, NOT as visible text. */
+	readonly label: string;
+	/** Click handler. */
+	readonly onClick: () => void;
+	/**
+	* When true, applies a red/destructive accent to the button. Use for Delete
+	* and other irreversible actions — Delete keeps red even icon-only.
+	*/
+	readonly danger?: boolean;
 }
-export declare function IconAction({ icon: Icon, label, onClick, danger, }: IconActionProps): ReactNode;
+export declare function IconAction({ icon: Icon, label, onClick, danger }: IconActionProps): ReactNode;

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

@@ -1,27 +1,50 @@
-import { ReactNode } from 'react';
-import { DeviceListDeviceProps } from './device-mode';
-import { DeviceListGenericProps } from './generic-mode';
-export { countableDevices } from './group';
-export { resolveDeviceIntegration, deviceIntegrationResolver } from './device-integration';
-export type { DeviceIntegrationLink, DeviceIntegrationRef, DeviceIntegrationResolution, DeviceIntegrationResolver, } from './device-integration';
-export { fuzzyMatch, normalizeForSearch } from './fuzzy-match';
-export { DEVICE_COLUMNS, columnsForContext, COLUMN_PRIORITY, COLUMN_BREAKPOINT_CLASS, } from './columns';
-export type { DeviceColumnId, TableContext } from './columns';
-export { nextSort, sortRows } from './sort';
-export type { DeviceSort, SortDirection, SortableColumnId } from './sort';
-export { hardwareLabel, metadataEntries, metadataString } from './hardware';
-export { IconAction, type IconActionProps } from './icon-action';
-export type { DeviceListAddonOption, DeviceListDeviceProps, DeviceListBatchActions, DeviceListIntegrationIconResolver, DeviceListIntegrationOption, } from './device-mode';
-export type { DeviceListColumn, DeviceListGenericProps, GenericPageSizeSelector, } from './generic-mode';
-export { PageSizeSelect, pageSizeLabel, type PageSizeSelectProps } from './page-size-select';
 /**
- * Default registry-device list, or a generic render-prop list (`mode:'generic'`).
- * Existing call sites pass no `mode` and resolve to the device variant unchanged.
- */
+* <DeviceList> — paginated, filterable, view-toggleable device list.
+*
+* Composes:
+*   - useDeviceListUrlState (URL+LS hybrid)
+*   - groupTopLevelAndAccessories (top-level vs accessory split)
+*   - <Pagination>, <FilterChips>, <DeviceListEmptyState>
+*   - <DeviceItem view={view}> per row
+*
+* Realtime: per-page useEventInvalidation calls remain authoritative for
+* Phase 2. Lifting the sync into ui-library would require a context bridge
+* that's out of scope.
+*
+* Search: debounced 300 ms before pushing to URL state. A search NARROWS the
+* rows and never opens a parent — the chevron is the only thing that does,
+* and what it opened survives the search (`DeviceModeList.openParents`).
+*
+* This module is the dispatcher + public barrel. The two render paths live
+* in focused sibling files:
+*   - device-mode.tsx  → the default registry-device list (table/cards)
+*   - generic-mode.tsx → the generic render-prop list (`mode:'generic'`)
+*   - table-layout.tsx / cards-layout.tsx → device-mode row layouts
+*/
+import { type ReactNode } from "react";
+import { type DeviceListDeviceProps } from "./device-mode";
+import { type DeviceListGenericProps } from "./generic-mode";
+export { countableDevices } from "./group";
+export { resolveDeviceIntegration, deviceIntegrationResolver } from "./device-integration";
+export type { DeviceIntegrationLink, DeviceIntegrationRef, DeviceIntegrationResolution, DeviceIntegrationResolver } from "./device-integration";
+export { fuzzyMatch, normalizeForSearch } from "./fuzzy-match";
+export { DEVICE_COLUMNS, columnsForContext, COLUMN_PRIORITY, COLUMN_BREAKPOINT_CLASS } from "./columns";
+export type { DeviceColumnId, TableContext } from "./columns";
+export { nextSort, sortRows } from "./sort";
+export type { DeviceSort, SortDirection, SortableColumnId } from "./sort";
+export { hardwareLabel, metadataEntries, metadataString } from "./hardware";
+export { IconAction, type IconActionProps } from "./icon-action";
+export type { DeviceListAddonOption, DeviceListDeviceProps, DeviceListBatchActions, DeviceListIntegrationIconResolver, DeviceListIntegrationOption } from "./device-mode";
+export type { DeviceListColumn, DeviceListGenericProps, GenericPageSizeSelector } from "./generic-mode";
+export { PageSizeSelect, pageSizeLabel, type PageSizeSelectProps } from "./page-size-select";
+/**
+* Default registry-device list, or a generic render-prop list (`mode:'generic'`).
+* Existing call sites pass no `mode` and resolve to the device variant unchanged.
+*/
 export type DeviceListProps<T = unknown> = DeviceListDeviceProps | DeviceListGenericProps<T>;
 /**
- * Dispatcher: default registry-device list, or a generic render-prop list when
- * `mode:'generic'`. The two paths are separate component instances so their
- * hooks never interleave (a given call site's mode is stable).
- */
+* Dispatcher: default registry-device list, or a generic render-prop list when
+* `mode:'generic'`. The two paths are separate component instances so their
+* hooks never interleave (a given call site's mode is stable).
+*/
 export declare function DeviceList<T = unknown>(props: DeviceListProps<T>): ReactNode;

package/dist/composites/device-list/multi-select.d.ts

@@ -1,22 +1,22 @@
-import { ReactNode } from 'react';
-import { LucideIcon } from 'lucide-react';
+import { type ReactNode } from "react";
+import { type LucideIcon } from "lucide-react";
 export interface MultiSelectOption {
-    readonly id: string;
-    readonly label: string;
-    readonly icon?: LucideIcon;
+	readonly id: string;
+	readonly label: string;
+	readonly icon?: LucideIcon;
 }
 export interface MultiSelectDropdownProps {
-    /** Trigger label, e.g. "Type". A count badge is appended when items are selected. */
-    readonly label: string;
-    readonly options: readonly MultiSelectOption[];
-    readonly selected: readonly string[];
-    readonly onChange: (selected: readonly string[]) => void;
+	/** Trigger label, e.g. "Type". A count badge is appended when items are selected. */
+	readonly label: string;
+	readonly options: readonly MultiSelectOption[];
+	readonly selected: readonly string[];
+	readonly onChange: (selected: readonly string[]) => void;
 }
 /**
- * Compact multi-select dropdown — a single chip-sized trigger ("Label · N")
- * that opens a checklist. Self-contained (outside-click / Escape dismiss), so
- * it stays compressed regardless of how many options exist or how little
- * horizontal room the container has. Shared by the device list's generic-mode
- * type filter and any other multi-select needs.
- */
-export declare function MultiSelectDropdown({ label, options, selected, onChange, }: MultiSelectDropdownProps): ReactNode;
+* Compact multi-select dropdown — a single chip-sized trigger ("Label · N")
+* that opens a checklist. Self-contained (outside-click / Escape dismiss), so
+* it stays compressed regardless of how many options exist or how little
+* horizontal room the container has. Shared by the device list's generic-mode
+* type filter and any other multi-select needs.
+*/
+export declare function MultiSelectDropdown({ label, options, selected, onChange }: MultiSelectDropdownProps): ReactNode;

package/dist/composites/device-list/page-size-select.d.ts

@@ -1,10 +1,16 @@
-import { ReactNode } from 'react';
+/**
+* <PageSizeSelect> — the "Per page" control under a paginated list.
+*
+* One control for both list modes (the device table and the generic table),
+* so the two never drift in look or wording. `PAGE_SIZE_ALL` renders as "All".
+*/
+import { type ReactNode } from "react";
 export interface PageSizeSelectProps {
-    readonly value: number;
-    readonly options: readonly number[];
-    readonly onChange: (size: number) => void;
-    /** Accessible name — names what is being paged ("Devices per page"). */
-    readonly ariaLabel: string;
+	readonly value: number;
+	readonly options: readonly number[];
+	readonly onChange: (size: number) => void;
+	/** Accessible name — names what is being paged ("Devices per page"). */
+	readonly ariaLabel: string;
 }
 export declare function pageSizeLabel(size: number): string;
-export declare function PageSizeSelect({ value, options, onChange, ariaLabel, }: PageSizeSelectProps): ReactNode;
+export declare function PageSizeSelect({ value, options, onChange, ariaLabel }: PageSizeSelectProps): ReactNode;

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

@@ -1,18 +1,25 @@
-import { ReactNode } from 'react';
+/**
+* <Pagination> — numbered-pages-with-ellipsis control.
+*
+* Layout:  Showing 51–100 of 312 devices       [<] 1 … 3 4 [5] 6 7 … 28 [>]
+*
+* Returns `null` when totalItems <= pageSize (single page — no nav).
+*/
+import { type ReactNode } from "react";
 export interface PaginationProps {
-    readonly currentPage: number;
-    readonly totalItems: number;
-    readonly pageSize: number;
-    readonly onPageChange: (page: number) => void;
-    /** Singular noun for the showing-info label. Default `'devices'`. */
-    readonly itemNoun?: string;
+	readonly currentPage: number;
+	readonly totalItems: number;
+	readonly pageSize: number;
+	readonly onPageChange: (page: number) => void;
+	/** Singular noun for the showing-info label. Default `'devices'`. */
+	readonly itemNoun?: string;
 }
 export type PageButton = {
-    readonly kind: 'page';
-    readonly n: number;
+	readonly kind: "page";
+	readonly n: number;
 } | {
-    readonly kind: 'ellipsis';
-    readonly side: 'left' | 'right';
+	readonly kind: "ellipsis";
+	readonly side: "left" | "right";
 };
 export declare function computePageButtons(currentPage: number, totalPages: number): readonly PageButton[];
-export declare function Pagination({ currentPage, totalItems, pageSize, onPageChange, itemNoun, }: PaginationProps): ReactNode;
+export declare function Pagination({ currentPage, totalItems, pageSize, onPageChange, itemNoun }: PaginationProps): ReactNode;

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

@@ -1,22 +1,35 @@
-import { DeviceItemDevice } from '../device-item/helpers';
+/**
+* Device-table column sorting (top-level rows only).
+*
+* Only `name`, `type`, and `manufacturer` are sortable. Sorting reorders the
+* TOP-LEVEL device rows; accessory children stay grouped under their parent
+* (they're looked up per-parent-id from `accessoriesByParent`, not part of this
+* list), so sorting parents never lifts a child to the top level.
+*
+* `sortRows` is pure: it returns a NEW array and never mutates the input. A
+* `null` sort = current order, returned as a fresh shallow copy. The sort is
+* stable (Array.prototype.sort is stable in every supported runtime) so equal
+* keys keep their incoming relative order.
+*/
+import type { DeviceItemDevice } from "../device-item/helpers";
 /** Columns that expose a clickable sort header. */
-export type SortableColumnId = 'name' | 'type' | 'manufacturer';
-export type SortDirection = 'asc' | 'desc';
+export type SortableColumnId = "name" | "type" | "manufacturer";
+export type SortDirection = "asc" | "desc";
 export interface DeviceSort {
-    readonly columnId: SortableColumnId;
-    readonly dir: SortDirection;
+	readonly columnId: SortableColumnId;
+	readonly dir: SortDirection;
 }
 /**
- * Toggle a column's sort on header click: none → asc → desc → none.
- * Clicking a DIFFERENT column starts it fresh at `asc`.
- *
- * The rule itself lives in `composites/table-sort.ts` and is shared with
- * `DataTable` — this function only re-labels the result with the device
- * list's own `columnId` vocabulary.
- */
+* Toggle a column's sort on header click: none → asc → desc → none.
+* Clicking a DIFFERENT column starts it fresh at `asc`.
+*
+* The rule itself lives in `composites/table-sort.ts` and is shared with
+* `DataTable` — this function only re-labels the result with the device
+* list's own `columnId` vocabulary.
+*/
 export declare function nextSort(current: DeviceSort | null, columnId: SortableColumnId): DeviceSort | null;
 /**
- * Return a NEW array of the top-level rows in sorted order. `null` ⇒ a fresh
- * copy in the original order. Stable + immutable; the input is never mutated.
- */
+* Return a NEW array of the top-level rows in sorted order. `null` ⇒ a fresh
+* copy in the original order. Stable + immutable; the input is never mutated.
+*/
 export declare function sortRows(rows: readonly DeviceItemDevice[], sort: DeviceSort | null): readonly DeviceItemDevice[];

package/dist/composites/device-list/sortable-header.d.ts

@@ -1,10 +1,23 @@
-import { ReactNode } from 'react';
-import { DeviceSort, SortableColumnId } from './sort';
+/**
+* The device table's sortable column header.
+*
+* The rendering — label + chevron indicator + hover placeholder — lives in
+* `composites/sort-header-button.tsx` and is shared with `DataTable`. This
+* file is the device-list adapter: it maps `DeviceSort` (which keys columns by
+* `columnId`) onto the shared control's `active`/`dir` pair. It exists so the
+* device list keeps its own column vocabulary without a second copy of the
+* button.
+*
+* The owning `<th>` carries `aria-sort` (WAI-ARIA scopes it to `<th>`/`<td>`);
+* non-sortable columns keep plain static text and never mount this.
+*/
+import type { ReactNode } from "react";
+import type { DeviceSort, SortableColumnId } from "./sort";
 interface SortableHeaderButtonProps {
-    readonly columnId: SortableColumnId;
-    readonly label: string;
-    readonly sort: DeviceSort | null;
-    readonly onSort: (columnId: SortableColumnId) => void;
+	readonly columnId: SortableColumnId;
+	readonly label: string;
+	readonly sort: DeviceSort | null;
+	readonly onSort: (columnId: SortableColumnId) => void;
 }
-export declare function SortableHeaderButton({ columnId, label, sort, onSort, }: SortableHeaderButtonProps): ReactNode;
+export declare function SortableHeaderButton({ columnId, label, sort, onSort }: SortableHeaderButtonProps): ReactNode;
 export {};

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

@@ -1,50 +1,50 @@
-import { ReactNode } from 'react';
-import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
-import { DeviceItemDevice, DeviceItemParent } from '../device-item/helpers';
-import { DeviceColumnId } from './columns';
-import { DeviceSort, SortableColumnId } from './sort';
+import { type ReactNode } from "react";
+import type { UseDeviceProxyTrpc } from "../../hooks/use-device-proxy";
+import type { DeviceItemDevice, DeviceItemParent } from "../device-item/helpers";
+import { type DeviceColumnId } from "./columns";
+import type { DeviceSort, SortableColumnId } from "./sort";
 /**
- * The row-layout contract. It used to live in `cards-layout.tsx` and be
- * EXTENDED here, because two layouts shared it. The cards layout is gone — the
- * device list is a table, always — so the contract lives with its only
- * implementation rather than in a file that exists to be inherited from.
- */
+* The row-layout contract. It used to live in `cards-layout.tsx` and be
+* EXTENDED here, because two layouts shared it. The cards layout is gone — the
+* device list is a table, always — so the contract lives with its only
+* implementation rather than in a file that exists to be inherited from.
+*/
 interface DeviceRowsProps {
-    readonly rows: readonly DeviceItemDevice[];
-    readonly accessoriesByParent: ReadonlyMap<number, readonly DeviceItemDevice[]>;
-    readonly trpc: UseDeviceProxyTrpc;
-    /** The badge beside a row's name — already bound to the row's resolved
-     *  integration by the device-mode wrapper. */
-    readonly resolveIntegrationIcon: ((device: DeviceItemDevice) => 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;
+	readonly rows: readonly DeviceItemDevice[];
+	readonly accessoriesByParent: ReadonlyMap<number, readonly DeviceItemDevice[]>;
+	readonly trpc: UseDeviceProxyTrpc;
+	/** The badge beside a row's name — already bound to the row's resolved
+	*  integration by the device-mode wrapper. */
+	readonly resolveIntegrationIcon: ((device: DeviceItemDevice) => 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;
 }
 interface TableLayoutProps extends DeviceRowsProps {
-    /** Built-in confirmed delete (table feature). Null ⇒ no trash. Only
-     *  top-level rows carry it (accessory sub-rows are excluded — same gate
-     *  as `renderRowAction`). */
-    readonly onDeleteDevice: ((device: DeviceItemDevice) => void) | null;
-    /** Parent rows the OPERATOR opened. Only the chevron writes it — a search
-     *  never does (it narrows the rows; it does not open them). */
-    readonly expandedParents: ReadonlySet<number>;
-    readonly onToggleExpand: (parentId: number) => void;
-    /** Full unfiltered device list — used to resolve parent.type for the
-     *  adopted-row indent. We can't rely on `resolveParent` returning the
-     *  parent's type (callers historically only project id+name). */
-    readonly devices: readonly DeviceItemDevice[];
-    /** Context-selected columns to render (header + cells). `name` always on. */
-    readonly visibleColumns: readonly DeviceColumnId[];
-    /** Active sort (top-level rows), or `null` for the default incoming order.
-     *  Owned by the device-mode wrapper so the sort applies before pagination. */
-    readonly sort: DeviceSort | null;
-    /** Header-click handler — toggles the column's sort (asc→desc→none). */
-    readonly onSort: (columnId: SortableColumnId) => void;
+	/** Built-in confirmed delete (table feature). Null ⇒ no trash. Only
+	*  top-level rows carry it (accessory sub-rows are excluded — same gate
+	*  as `renderRowAction`). */
+	readonly onDeleteDevice: ((device: DeviceItemDevice) => void) | null;
+	/** Parent rows the OPERATOR opened. Only the chevron writes it — a search
+	*  never does (it narrows the rows; it does not open them). */
+	readonly expandedParents: ReadonlySet<number>;
+	readonly onToggleExpand: (parentId: number) => void;
+	/** Full unfiltered device list — used to resolve parent.type for the
+	*  adopted-row indent. We can't rely on `resolveParent` returning the
+	*  parent's type (callers historically only project id+name). */
+	readonly devices: readonly DeviceItemDevice[];
+	/** Context-selected columns to render (header + cells). `name` always on. */
+	readonly visibleColumns: readonly DeviceColumnId[];
+	/** Active sort (top-level rows), or `null` for the default incoming order.
+	*  Owned by the device-mode wrapper so the sort applies before pagination. */
+	readonly sort: DeviceSort | null;
+	/** Header-click handler — toggles the column's sort (asc→desc→none). */
+	readonly onSort: (columnId: SortableColumnId) => void;
 }
-export declare function TableLayout({ rows, accessoriesByParent, expandedParents, onToggleExpand, devices, visibleColumns, trpc, resolveIntegrationIcon, resolveParent, onNavigate, renderRowAction, onDeleteDevice, selectable, rowClickSelects, activeSelected, onToggleSelection, sort, onSort, }: TableLayoutProps): ReactNode;
+export declare function TableLayout({ rows, accessoriesByParent, expandedParents, onToggleExpand, devices, visibleColumns, trpc, resolveIntegrationIcon, resolveParent, onNavigate, renderRowAction, onDeleteDevice, selectable, rowClickSelects, activeSelected, onToggleSelection, sort, onSort }: TableLayoutProps): ReactNode;
 export {};