@camstack/ui-library 1.2.256 → 1.2.258

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

@@ -1,133 +1,133 @@
-import { ReactNode } from 'react';
-import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
-import { DeviceItemDevice, DeviceItemParent } from '../device-item/helpers';
-import { TableContext } from './columns';
-import { MultiSelectOption } from './multi-select';
-import { DeviceIntegrationResolution, DeviceIntegrationResolver } from './device-integration';
+import { type ReactNode } from "react";
+import type { UseDeviceProxyTrpc } from "../../hooks/use-device-proxy";
+import type { DeviceItemDevice, DeviceItemParent } from "../device-item/helpers";
+import { type TableContext } from "./columns";
+import type { MultiSelectOption } from "./multi-select";
+import type { DeviceIntegrationResolution, DeviceIntegrationResolver } from "./device-integration";
 /** One chip of the integration filter. `id` is the INTEGRATION id
- *  (`IntegrationWithState.id`), matched against `integrationOf(device)` —
- *  never a device's `addonId` (a composed device is served by `composer` but
- *  belongs to the "Blocks" integration, D659). */
+*  (`IntegrationWithState.id`), matched against `integrationOf(device)` —
+*  never a device's `addonId` (a composed device is served by `composer` but
+*  belongs to the "Blocks" integration, D659). */
 export interface DeviceListIntegrationOption {
-    readonly id: string;
-    readonly name: string;
-    readonly icon?: ReactNode;
+	readonly id: string;
+	readonly name: string;
+	readonly icon?: ReactNode;
 }
 /** Kept as a source-compatible name for callers compiled against the old
- * addon-keyed filter API. The values are integration ids now. */
+* addon-keyed filter API. The values are integration ids now. */
 export type DeviceListAddonOption = DeviceListIntegrationOption;
 export type DeviceListIntegrationIconResolver = (device: DeviceItemDevice, integration: DeviceIntegrationResolution) => ReactNode | null;
 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;
-    /**
-     * 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?: {
-        /** Integration chips — ids are integration ids. Requires `integrationOf`. */
-        readonly integrations?: readonly DeviceListIntegrationOption[];
-        readonly typeOptions?: readonly MultiSelectOption[];
-    };
-    /**
-     * Which integration a row belongs to — build it with
-     * `deviceIntegrationResolver(integrations)`, the one rule the whole UI
-     * answers that question with. Drives the integration filter
-     * (`filters.integrations`, `forceIntegrationId`) and is handed to
-     * `resolveIntegrationIcon`. Omitted ⇒ every row is `unknown`, so an
-     * integration filter matches nothing.
-     */
-    readonly integrationOf?: DeviceIntegrationResolver;
-    /** Pre-applied integration filter (an integration id) — hides the chip group. */
-    readonly forceIntegrationId?: string;
-    /** The badge beside a row's name, given the row and its resolved integration. */
-    readonly resolveIntegrationIcon?: DeviceListIntegrationIconResolver;
-    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;
+	/** 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;
+	/**
+	* 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?: {
+		/** Integration chips — ids are integration ids. Requires `integrationOf`. */
+		readonly integrations?: readonly DeviceListIntegrationOption[];
+		readonly typeOptions?: readonly MultiSelectOption[];
+	};
+	/**
+	* Which integration a row belongs to — build it with
+	* `deviceIntegrationResolver(integrations)`, the one rule the whole UI
+	* answers that question with. Drives the integration filter
+	* (`filters.integrations`, `forceIntegrationId`) and is handed to
+	* `resolveIntegrationIcon`. Omitted ⇒ every row is `unknown`, so an
+	* integration filter matches nothing.
+	*/
+	readonly integrationOf?: DeviceIntegrationResolver;
+	/** Pre-applied integration filter (an integration id) — hides the chip group. */
+	readonly forceIntegrationId?: string;
+	/** The badge beside a row's name, given the row and its resolved integration. */
+	readonly resolveIntegrationIcon?: DeviceListIntegrationIconResolver;
+	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;
+	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/empty-state.d.ts

@@ -1,6 +1,17 @@
-import { ReactNode } from 'react';
+/**
+* <DeviceListEmptyState> — shown when the filtered device list is empty.
+*
+* Two variants:
+*   - `nofilter` — list is empty AND no filters applied. Operator
+*     hasn't added any devices yet (or the addon hasn't discovered any).
+*   - `filtered` — filters are applied but match nothing. Offer a
+*     reset link to clear filters.
+*   - `pending` — an integration filter could not judge the rows yet (the
+*     integrations query has not answered). Not an absence (D315).
+*/
+import { type ReactNode } from "react";
 export interface EmptyStateProps {
-    readonly variant: 'nofilter' | 'filtered' | 'pending';
-    readonly onClearFilters?: () => void;
+	readonly variant: "nofilter" | "filtered" | "pending";
+	readonly onClearFilters?: () => void;
 }
 export declare function DeviceListEmptyState({ variant, onClearFilters }: EmptyStateProps): ReactNode;

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

@@ -1,33 +1,46 @@
-import { ReactNode } from 'react';
-import { MultiSelectOption } from './multi-select';
+/**
+* <FilterChips> — top-row filter UI for DeviceList.
+*
+* Layout: [Type chips] [Integration multi-select] [Clear filters]
+* (search input lives separately; this component only handles the
+* chip-style selectors + the integration dropdown).
+*
+* Type is radio-like (clicking the active chip clears it). Integration
+* is a compact MULTI-select dropdown — previously every integration
+* spilled into the row as inline chips and only one could be active;
+* now a single "Integration" button opens a checkbox menu so several
+* integrations can be filtered at once without flooding the toolbar.
+*/
+import { type ReactNode } from "react";
+import type { MultiSelectOption } from "./multi-select";
 export interface FilterChipsAddonOption {
-    readonly id: string;
-    readonly name: string;
-    readonly icon?: ReactNode;
+	readonly id: string;
+	readonly name: string;
+	readonly icon?: ReactNode;
 }
 export interface FilterChipsProps {
-    /**
-     * 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[];
-    readonly onAddonsChange: (addons: readonly string[]) => void;
-    /** When true, the addon group is hidden (used by Integrations expand-row inner DeviceList). */
-    readonly hideAddons?: boolean;
-    /**
-     * Free-text search, read ONLY to decide whether any filter is set. The input
-     * itself lives outside this component; a Clear that ignored it would leave
-     * the list filtered after the operator was told it had been cleared.
-     */
-    readonly query?: string;
-    /** Clear every filter at once. Omit to hide the affordance entirely. */
-    readonly onClearFilters?: () => void;
+	/**
+	* 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[];
+	readonly onAddonsChange: (addons: readonly string[]) => void;
+	/** When true, the addon group is hidden (used by Integrations expand-row inner DeviceList). */
+	readonly hideAddons?: boolean;
+	/**
+	* Free-text search, read ONLY to decide whether any filter is set. The input
+	* itself lives outside this component; a Clear that ignored it would leave
+	* the list filtered after the operator was told it had been cleared.
+	*/
+	readonly query?: string;
+	/** Clear every filter at once. Omit to hide the affordance entirely. */
+	readonly onClearFilters?: () => void;
 }
-export declare function FilterChips({ typeOptions, selectedTypes, onTypesChange, addons, selectedAddons, onAddonsChange, hideAddons, query, onClearFilters, }: FilterChipsProps): ReactNode;
+export declare function FilterChips({ typeOptions, selectedTypes, onTypesChange, addons, selectedAddons, onAddonsChange, hideAddons, query, onClearFilters }: FilterChipsProps): ReactNode;

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

@@ -1,27 +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.
- */
+* 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'
- */
+* 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
- */
+* 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

@@ -1,98 +1,98 @@
-import { ReactNode } from 'react';
-import { LucideIcon } from 'lucide-react';
-import { MultiSelectOption } from './multi-select';
+import { type ReactNode } from "react";
+import { type LucideIcon } from "lucide-react";
+import { type 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`.
- */
+* 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;
+	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 GenericPageSizeSelector {
-    readonly options: readonly number[];
-    readonly defaultSize: number;
-    readonly storageKey: string | null;
+	readonly options: readonly number[];
+	readonly defaultSize: number;
+	readonly storageKey: string | null;
 }
 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;
-    /**
-     * Initial type-filter selection. Empty (default) = no filter. Used once at
-     * mount — later changes to this prop are ignored (local state owns it).
-     */
-    readonly initialTypeFilters?: readonly string[];
-    readonly isLoading?: boolean;
-    readonly searchPlaceholder?: string;
-    readonly emptyLabel?: string;
-    /** Fixed rows per page when there is no `pageSizeSelector`. Default 100. */
-    readonly pageSize?: number;
-    /**
-     * Let the viewer pick the page size: a "Per page" control under the table,
-     * remembered per viewer under `storageKey` (null = not remembered). Options
-     * may include `PAGE_SIZE_ALL`. When set, `pageSize` is ignored.
-     */
-    readonly pageSizeSelector?: GenericPageSizeSelector;
-    /** Optional control rendered next to the search box (e.g. a Refresh button). */
-    readonly toolbar?: ReactNode;
+	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;
+	/**
+	* Initial type-filter selection. Empty (default) = no filter. Used once at
+	* mount — later changes to this prop are ignored (local state owns it).
+	*/
+	readonly initialTypeFilters?: readonly string[];
+	readonly isLoading?: boolean;
+	readonly searchPlaceholder?: string;
+	readonly emptyLabel?: string;
+	/** Fixed rows per page when there is no `pageSizeSelector`. Default 100. */
+	readonly pageSize?: number;
+	/**
+	* Let the viewer pick the page size: a "Per page" control under the table,
+	* remembered per viewer under `storageKey` (null = not remembered). Options
+	* may include `PAGE_SIZE_ALL`. When set, `pageSize` is ignored.
+	*/
+	readonly pageSizeSelector?: GenericPageSizeSelector;
+	/** 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`.
- */
+* 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;