@camstack/ui-library 1.2.221 → 1.2.223

package/dist/composites/device-picker/DevicePicker.d.ts

@@ -0,0 +1,35 @@
+import { PickerFleetView } from './device-fleet-view';
+import { PickerGroup, PickerId, PickerItem } from './device-picker-model';
+import { DeviceListState } from './device-selection';
+import { PickerNoun } from './device-selection-rows';
+export interface DevicePickerProps<Id extends PickerId = number> {
+    /** The devices the list DRAWS — the caller's answered list, `[]` otherwise. */
+    readonly devices: readonly PickerItem<Id>[];
+    /** Whether `devices` ANSWERED (D315). */
+    readonly listState: DeviceListState;
+    /** What an off-list selected id is judged against. Defaults to the list. */
+    readonly fleet?: PickerFleetView<Id>;
+    readonly value: readonly Id[];
+    readonly onChange: (next: Id[]) => void;
+    /** Empty selection means EVERY device: say so, and warn when it widens. */
+    readonly emptyMeansAll?: boolean;
+    /** Whether the saved rule had devices — the widening warning survives a remount. */
+    readonly savedHadDevices?: boolean;
+    /** What the list holds, for its sentences. */
+    readonly noun?: PickerNoun;
+    /** A group header's title. Defaults to "<type> · <room>". */
+    readonly groupTitle?: (group: PickerGroup<Id>) => string;
+    /** What an empty selection reads as, when it does not mean "every device". */
+    readonly emptyLabel?: string;
+    /** A per-device note drawn beside the name (the alarm's "not covered"). */
+    readonly annotate?: (id: Id) => string | undefined;
+    readonly disabled?: boolean;
+    readonly testId?: string;
+    /**
+     * List EVERYTHING, always open: no Edit/Done toggle, no "+N more" chips, no
+     * "Show N more" rows, every group open until the operator folds one. For a
+     * surface whose whole job is the list — the rule's Devices tab (R15).
+     */
+    readonly showAll?: boolean;
+}
+export declare function DevicePicker<Id extends PickerId = number>({ devices, listState, fleet, value, onChange, emptyMeansAll, savedHadDevices, noun, groupTitle, emptyLabel, annotate, disabled, testId, showAll, }: DevicePickerProps<Id>): import("react").JSX.Element;

package/dist/composites/device-picker/SelectedChip.d.ts

@@ -0,0 +1,12 @@
+/** The search box's shell — shared with multiselect fields that mirror this picker. */
+export declare const INPUT_SHELL = "flex items-center gap-1.5 rounded-md border border-border bg-background px-2 py-1.5 focus-within:border-primary focus-within:ring-1 focus-within:ring-primary/30";
+export interface SelectedChipProps {
+    readonly label: string;
+    readonly onRemove?: () => void;
+    /** A selection the hub no longer has — drawn in warning colour. */
+    readonly warning?: boolean;
+    readonly iconId?: string;
+    readonly testId?: string;
+}
+/** One selected entry as a removable chip. */
+export declare function SelectedChip({ label, onRemove, warning, iconId, testId, }: SelectedChipProps): import("react").JSX.Element;

package/dist/composites/device-picker/device-filter-bar.d.ts

@@ -0,0 +1,25 @@
+import { PickerFacetOption, PickerFilters, PickerGroupBy, PickerZonesFallback, PickerZonesRead } from './device-picker-model';
+/** The Group-by control's inputs, as `DevicePicker.tsx` passes them. */
+export interface DeviceFilterBarGrouping {
+    readonly groupBy: PickerGroupBy;
+    readonly onGroupByChange: (next: PickerGroupBy) => void;
+    /** Set when Zone mode is showing locations because the zones had not answered. */
+    readonly fallback: PickerZonesFallback | null;
+}
+export interface DeviceFilterBarProps {
+    readonly filters: PickerFilters;
+    readonly onFiltersChange: (next: PickerFilters) => void;
+    readonly typeOptions: readonly PickerFacetOption[];
+    readonly zoneOptions: readonly PickerFacetOption[];
+    readonly locationOptions: readonly PickerFacetOption[];
+    /** The zones read — decides whether the Zone dropdown is enabled and what it says. */
+    readonly zones: PickerZonesRead;
+    /** Group by, when the list offers it (the device picker and the alarm table do). */
+    readonly grouping?: DeviceFilterBarGrouping;
+    readonly searchPlaceholder: string;
+    readonly searchLabel: string;
+    readonly disabled?: boolean;
+}
+/** "media-player" → "Media player"; null → "No type". */
+export declare function typeLabel(type: string | null): string;
+export declare function DeviceFilterBar({ filters, onFiltersChange, typeOptions, zoneOptions, locationOptions, zones, grouping, searchPlaceholder, searchLabel, disabled, }: DeviceFilterBarProps): import("react").JSX.Element;

package/dist/composites/device-picker/device-fleet-view.d.ts

@@ -0,0 +1,7 @@
+import { DeviceListQueryLike, DeviceListState, NamedDevice, SelectionId } from './device-selection';
+export interface PickerFleetView<Id extends SelectionId = number> {
+    readonly state: DeviceListState;
+    readonly devices: readonly NamedDevice<Id>[] | undefined;
+}
+export type DeviceFleetView = PickerFleetView<number>;
+export declare function fleetViewOf(query: DeviceListQueryLike): DeviceFleetView;

package/dist/composites/device-picker/device-picker-grouping.d.ts

@@ -0,0 +1,14 @@
+import { PickerGroupBy, PickerZonesRead } from './device-picker-model';
+export declare const DEVICE_PICKER_GROUP_STORAGE_KEY = "camstack.admin.device-picker.group-by";
+/** The stored choice; the default when storage is absent, throws or is unreadable. */
+export declare function readStoredGroupBy(): PickerGroupBy;
+/** Remember the choice; a storage that refuses keeps it for this page only. */
+export declare function writeStoredGroupBy(next: PickerGroupBy): void;
+/** The group-by choice, seeded from and written to `localStorage`. */
+export interface StoredGroupBy {
+    readonly groupBy: PickerGroupBy;
+    readonly setGroupBy: (next: PickerGroupBy) => void;
+}
+export declare function useStoredGroupBy(): StoredGroupBy;
+/** The site zones, with whether the read ANSWERED — read only while `enabled`. */
+export declare function usePickerSiteZones(enabled: boolean): PickerZonesRead;

package/dist/composites/device-picker/device-picker-model.d.ts

@@ -0,0 +1,245 @@
+/**
+ * The smart device picker's decisions — search, groups, per-group bulk
+ * actions, the chip overflow and the bounded render — with no UI in it.
+ *
+ * One picker replaces every long device checklist in the notification editors
+ * (a rule's devices, a system rule's include/exclude, the timelapse and digest
+ * cameras, the alarm's non-blocking openings). A checklist of 293 rows on the
+ * admin, and of every camera on a phone, took the whole screen to say "two
+ * devices"; the picker shows the selection as chips and opens a searchable,
+ * grouped list only to change it.
+ *
+ * Since D637 the same model also serves the system family's node and package
+ * pickers, keyed by string: every item and function is generic over
+ * {@link PickerId}, and a device picker is simply `PickerItem<number>`.
+ *
+ * It has to hold at HUNDREDS of devices of ONE type (a fleet of HA sensors),
+ * which is what shapes it:
+ *
+ *  - search is a debounced, case-insensitive AND over name, room, type,
+ *    container and id — "sala temp" finds the living-room thermometer among
+ *    nine "Temperatura";
+ *  - the DEVICE picker groups by what the operator chose at the top of the
+ *    list — site zone (default), location, or nothing
+ *    ({@link groupPickerDevicesBy}); the node and package pickers keep
+ *    (type, liveness) groups;
+ *  - (type, room) groups, where they are still used — and any group bigger than
+ *    {@link PICKER_GROUP_COLLAPSE_AT} starts COLLAPSED unless a search is
+ *    running or it holds a selected device — a collapsed header still says how
+ *    many it holds and offers select-all / clear;
+ *  - the list is rendered in bounded pieces ({@link pageRows} for a capped
+ *    render with "show N more"; a virtualised list sizes itself from
+ *    {@link PICKER_WINDOW});
+ *  - the list can be NARROWED by search plus Type / Zone / Location filters
+ *    ({@link applyPickerFilters}); "Reset filters" clears those and leaves
+ *    "Group by" alone ({@link resetPickerFilters}, D697);
+ *  - the chips show at most {@link PICKER_CHIP_LIMIT} and a "+N more".
+ *
+ * It reads NOTHING. It filters the list the caller already holds; an id the
+ * list lacks is the caller's to resolve (`device-selection.ts`), which is also
+ * where D315 and D49 live.
+ *
+ * TWO BYTE-IDENTICAL COPIES: `camstack/src/components/notifications/
+ * device-picker-model.ts` (viewer) and `packages/addon-admin-ui/src/pages/
+ * system/device-picker-model.ts` (admin), for the reason `device-selection.ts`
+ * has two. `scripts/check-device-selection-in-sync.ts` fails the commit when
+ * they differ. No `toSorted` here: the viewer runs on Hermes.
+ */
+/** What a picker item is keyed by: a device id, or a node id / package name (D637). */
+export type PickerId = number | string;
+/** One item as the picker lists it. */
+export interface PickerItem<Id extends PickerId> {
+    readonly id: Id;
+    readonly name: string;
+    /** Groups by this (`DeviceType`, node role, package kind); absent groups under "no type". */
+    readonly type?: string;
+    /** The second grouping axis (room, liveness); absent or null groups under "none". */
+    readonly location?: string | null;
+    /** A second line — the container a child device belongs to, a node's id, a version. */
+    readonly detail?: string;
+}
+/** One device as the picker lists it. */
+export type PickerDevice = PickerItem<number>;
+/** How long the search waits after the last keystroke. */
+export declare const PICKER_SEARCH_DEBOUNCE_MS = 200;
+/** A group with more devices than this starts collapsed (unless searching). */
+export declare const PICKER_GROUP_COLLAPSE_AT = 8;
+/** How many selected chips are drawn before "+N more". */
+export declare const PICKER_CHIP_LIMIT = 6;
+/** Rows a capped render draws per "show more". */
+export declare const PICKER_PAGE_SIZE = 60;
+/** Rows a virtualised list renders per batch and initially. */
+export declare const PICKER_WINDOW = 30;
+/** Everything a query can match on, lower-cased. */
+export declare function pickerSearchText(device: PickerItem<PickerId>): string;
+/** The query's tokens; empty for a blank query. */
+export declare function pickerQueryTokens(query: string): readonly string[];
+/** Devices matching EVERY token. A blank query keeps the list as it is. */
+export declare function filterPickerDevices<Id extends PickerId>(devices: readonly PickerItem<Id>[], query: string): readonly PickerItem<Id>[];
+/**
+ * What a "Group by" group is named after. Absent on the (type, room) groups
+ * the node and package pickers still use.
+ */
+export type PickerGroupHeading = {
+    readonly kind: 'zone';
+    readonly label: string;
+} | {
+    readonly kind: 'location';
+    readonly label: string;
+} | {
+    readonly kind: 'no-zone';
+} | {
+    readonly kind: 'no-location';
+};
+/** One (type, room) group — or, under "Group by", one zone or location. */
+export interface PickerGroup<Id extends PickerId = number> {
+    readonly key: string;
+    readonly type: string | null;
+    readonly location: string | null;
+    readonly devices: readonly PickerItem<Id>[];
+    readonly selectedCount: number;
+    readonly heading?: PickerGroupHeading;
+}
+/** The key a group is remembered by (collapsed / expanded). */
+export declare function pickerGroupKey(type: string | null, location: string | null): string;
+/** Group by type, then room; both ascending, "none" last; devices by name. */
+export declare function groupPickerDevices<Id extends PickerId>(devices: readonly PickerItem<Id>[], selected: readonly Id[]): readonly PickerGroup<Id>[];
+/**
+ * Whether a group is open. The operator's own toggle wins; otherwise a small
+ * group is open, a big one is closed — unless a search is running (the result
+ * IS what they asked to see) or it holds a selected device.
+ */
+export declare function isGroupExpanded<Id extends PickerId>(group: PickerGroup<Id>, toggles: ReadonlyMap<string, boolean>, searching: boolean): boolean;
+/** One row of the flattened list: a group header, or a device under it. */
+export type PickerRow<Id extends PickerId = number> = {
+    readonly kind: 'header';
+    readonly key: string;
+    readonly group: PickerGroup<Id>;
+    readonly expanded: boolean;
+} | {
+    readonly kind: 'device';
+    readonly key: string;
+    readonly device: PickerItem<Id>;
+    readonly groupKey: string;
+    readonly selected: boolean;
+};
+/** The groups as ONE list of rows — what a virtualised list renders. */
+export declare function flattenPickerRows<Id extends PickerId>(groups: readonly PickerGroup<Id>[], selected: readonly Id[], toggles: ReadonlyMap<string, boolean>, searching: boolean): readonly PickerRow<Id>[];
+/** Tick or untick one id. The order of the rest is kept. */
+export declare function togglePickerDevice<Id extends PickerId>(value: readonly Id[], id: Id): Id[];
+/** Add every device of the group (only the ones the current search shows). */
+export declare function selectPickerGroup<Id extends PickerId>(value: readonly Id[], group: PickerGroup<Id>): Id[];
+/** Remove every device of the group; ids outside it are untouched. */
+export declare function clearPickerGroup<Id extends PickerId>(value: readonly Id[], group: PickerGroup<Id>): Id[];
+/** The chips to draw, and how many are behind "+N more". */
+export interface ChipOverflow<T> {
+    readonly shown: readonly T[];
+    readonly hidden: number;
+}
+export declare function chipOverflow<T>(items: readonly T[], expanded: boolean): ChipOverflow<T>;
+/** A capped render: the first `shown` rows, and how many are left. */
+export interface PickerPage<Id extends PickerId = number> {
+    readonly rows: readonly PickerRow<Id>[];
+    readonly remaining: number;
+}
+export declare function pageRows<Id extends PickerId>(rows: readonly PickerRow<Id>[], shown: number): PickerPage<Id>;
+/** How the device picker groups its list. */
+export type PickerGroupBy = 'zone' | 'location' | 'none';
+/** The modes, in the order the control draws them. */
+export declare const PICKER_GROUP_BY_MODES: readonly PickerGroupBy[];
+/** What an operator who never chose gets. */
+export declare const PICKER_DEFAULT_GROUP_BY: PickerGroupBy;
+/** A stored choice; anything unreadable is the default. */
+export declare function parsePickerGroupBy(raw: unknown): PickerGroupBy;
+/** One site zone as the picker groups by it. */
+export interface PickerZone {
+    readonly zoneKey: string;
+    readonly label: string;
+    readonly locationKeys: readonly string[];
+}
+/** The zone read, with whether it ANSWERED (D315). */
+export type PickerZonesRead = {
+    readonly state: 'answered';
+    readonly zones: readonly PickerZone[];
+} | {
+    readonly state: 'pending';
+} | {
+    readonly state: 'failed';
+};
+/** Why Zone mode is grouping by location instead. */
+export type PickerZonesFallback = 'pending' | 'failed';
+/** The folded key a location label joins a zone by — `siteZoneKey`'s fold. */
+export declare function pickerLocationKey(label: string): string;
+/** The picker's groups under one "Group by" mode. */
+export interface PickerGrouping<Id extends PickerId = number> {
+    /** The mode the groups ARE — `location` when Zone could not be honoured. */
+    readonly groupBy: PickerGroupBy;
+    /** Set when Zone mode fell back to location: the zone read had not answered. */
+    readonly fallback: PickerZonesFallback | null;
+    /** One headerless list (None): no group to expand, select or clear. */
+    readonly flat: boolean;
+    readonly groups: readonly PickerGroup<Id>[];
+}
+/**
+ * Group the list by zone, location or nothing.
+ *
+ * Zone: a group per site zone that holds a listed device (by label), then
+ * "No zone" (a location no zone holds), then "No location". Location: a group
+ * per location (folded; named after the first device's trimmed spelling), then "No
+ * location". None: one flat list by name, then id.
+ *
+ * A zone read that is pending or failed can NOT say a location is in no zone
+ * (D315), so Zone mode then groups by location and returns the reason as
+ * {@link PickerGrouping.fallback} for the UI's one-line note.
+ */
+export declare function groupPickerDevicesBy<Id extends PickerId>(devices: readonly PickerItem<Id>[], selected: readonly Id[], groupBy: PickerGroupBy, zones: PickerZonesRead): PickerGrouping<Id>;
+/** The grouping as rows: a flat grouping draws no header and is always open. */
+export declare function flattenPickerGrouping<Id extends PickerId>(grouping: PickerGrouping<Id>, selected: readonly Id[], toggles: ReadonlyMap<string, boolean>, searching: boolean): readonly PickerRow<Id>[];
+/**
+ * What a row's second line adds under "Group by": the device TYPE (it left the
+ * group key), and the room wherever the header does not already say it.
+ */
+export interface PickerRowFacts {
+    readonly location: string | null;
+    readonly type: string | null;
+}
+export declare function pickerRowFacts<Id extends PickerId>(device: PickerItem<Id>, groupBy: PickerGroupBy): PickerRowFacts;
+/** The filter key of an item with no type / no location / no zone. */
+export declare const PICKER_NONE_KEY = "(none)";
+export type PickerFacet = 'type' | 'zone' | 'location';
+/** One choosable value of a facet, with how many listed items carry it. */
+export interface PickerFacetOption {
+    readonly key: string;
+    /** The type, the location (first trimmed spelling seen), the zone label; null for "(none)". */
+    readonly label: string | null;
+    readonly count: number;
+}
+/** What a picker (or the alarm table) narrows by, applied in this order. */
+export interface PickerFilters {
+    readonly query: string;
+    readonly types: readonly string[];
+    readonly zones: readonly string[];
+    readonly locations: readonly string[];
+}
+export declare const PICKER_NO_FILTERS: PickerFilters;
+/** The key an item filters by under one facet; `(none)` when it has no such value. */
+export declare function pickerFacetKey<Id extends PickerId>(item: PickerItem<Id>, facet: PickerFacet, zones: PickerZonesRead): string;
+/** Every value of a facet the list holds (plus chosen ones it no longer holds, at 0). */
+export declare function pickerFacetOptions<Id extends PickerId>(items: readonly PickerItem<Id>[], facet: PickerFacet, chosen: readonly string[], zones: PickerZonesRead): readonly PickerFacetOption[];
+/** A zone filter is chosen but the zones read has not answered: it is paused, not applied. */
+export declare function pickerZoneFilterSuspended(filters: PickerFilters, zones: PickerZonesRead): boolean;
+/** Search, then Type, Zone (only from an answered read), Location. No filter: the list itself. */
+export declare function applyPickerFilters<Id extends PickerId>(items: readonly PickerItem<Id>[], filters: PickerFilters, zones: PickerZonesRead): readonly PickerItem<Id>[];
+/** Tick or untick one filter key. */
+export declare function togglePickerKey(chosen: readonly string[], key: string): string[];
+export declare function pickerFiltersActive(filters: PickerFilters): boolean;
+/** Reset clears search, Type, Zone and Location — never "Group by". */
+export declare function resetPickerFilters(): PickerFilters;
+/**
+ * Selected ids the current filters hide — they stay selected, they are only not listed. Only a
+ * LISTED device can be hidden: an id the list does not hold at all (removed, unknown, off-offer)
+ * is not "hidden", so it is not counted.
+ */
+export declare function pickerHiddenSelectedCount<Id extends PickerId>(selected: readonly Id[], list: readonly PickerItem<Id>[], matches: readonly PickerItem<Id>[]): number;
+/** A dropdown is drawn when it can narrow (two values or more) or a key is chosen. */
+export declare function pickerFacetFilterShown(options: readonly PickerFacetOption[], chosen: readonly string[]): boolean;

package/dist/composites/device-picker/device-selection-rows.d.ts

@@ -0,0 +1,39 @@
+import { SelectedDeviceRow, SelectionId } from './device-selection';
+/**
+ * What a picker lists, for its sentences. `class` is a detection class (D641);
+ * `zone` and `face` are a rule's zone and known-face scopes (D690).
+ */
+export type PickerNoun = 'camera' | 'device' | 'node' | 'package' | 'class' | 'zone' | 'face';
+/** Each noun's plural. */
+export declare const PICKER_NOUN_PLURAL: {
+    readonly camera: "cameras";
+    readonly device: "devices";
+    readonly node: "nodes";
+    readonly package: "packages";
+    readonly class: "classes";
+    readonly zone: "zones";
+    readonly face: "faces";
+};
+/** What a picker lists, plural — the only words the loading / failed lines say. */
+export type PickerNounPlural = (typeof PICKER_NOUN_PLURAL)[PickerNoun];
+/** The label a picker gives a selected id its drawn list does not contain. */
+export declare function orphanDeviceLabel<Id extends SelectionId>(row: SelectedDeviceRow<Id>, noun?: PickerNoun): string;
+interface DevicesWidenWarningProps {
+    /** What the picker lists: the rule's Devices tab lists every device. */
+    readonly noun?: PickerNoun;
+}
+/** Said under a picker whose empty selection means EVERY device. */
+export declare function DevicesWidenWarning({ noun }: DevicesWidenWarningProps): import("react").JSX.Element;
+interface DevicesLoadingLineProps {
+    /** What the picker lists, plural — the rule's Devices tab lists every device. */
+    readonly noun?: PickerNounPlural;
+}
+/** A list that has not answered: never an absence claim (D315). */
+export declare function DevicesLoadingLine({ noun }: DevicesLoadingLineProps): import("react").JSX.Element;
+interface DevicesFailedLineProps {
+    /** What the picker lists, plural. */
+    readonly noun?: PickerNounPlural;
+}
+/** A list that failed: said, while the selected ids stay removable. */
+export declare function DevicesFailedLine({ noun }: DevicesFailedLineProps): import("react").JSX.Element;
+export {};

package/dist/composites/device-picker/device-selection.d.ts

@@ -0,0 +1,64 @@
+/**
+ * What a device picker says about the ids it has SELECTED — including the ones
+ * the hub no longer has.
+ *
+ * The picker draws the live camera list; a selected id outside that list would
+ * otherwise be invisible and impossible to deselect (operator report
+ * 2026-09-25: a deleted camera kept a rule matching nothing while the editor
+ * showed "all devices"). Two rules shape this module:
+ *
+ *  - D315: absence is claimed only from a list that ANSWERED. Pending and
+ *    failed lists never mark an id `removed`.
+ *  - D49: a read never destroys. Every selected id comes back as a row; the
+ *    selection is changed only by the operator.
+ *
+ * Generic over {@link SelectionId} since D637: the system family's node and
+ * package pickers select string ids under the same two rules. It declares its
+ * own id type rather than importing the picker model's, so the byte-identical
+ * copies share no import specifier that would differ between them.
+ *
+ * TWO BYTE-IDENTICAL COPIES: `camstack/src/components/notifications/
+ * device-selection.ts` (viewer) and `packages/addon-admin-ui/src/pages/system/
+ * device-selection.ts` (admin). The viewer resolves `@camstack/types` from a
+ * published release, so a helper added to the workspace would not exist
+ * there. `scripts/check-device-selection-in-sync.ts` (camstack-server) fails
+ * the commit when the copies differ; edit both.
+ */
+/** A selected id: a device id, or a node id / package name (D637). */
+export type SelectionId = number | string;
+/** Where the camera list is: answered (data present), pending, or failed. */
+export type DeviceListState = 'answered' | 'pending' | 'failed';
+/** The minimum a camera needs to name a selected row. */
+export interface NamedDevice<Id extends SelectionId = number> {
+    readonly id: Id;
+    readonly name: string;
+}
+/** One selected id. `name` only when the answered list has it. */
+export interface SelectedDeviceRow<Id extends SelectionId = number> {
+    readonly id: Id;
+    readonly name?: string;
+    readonly removed: boolean;
+}
+/** The slice of a query result the state is derived from. */
+export interface DeviceListQueryLike<Id extends SelectionId = number> {
+    readonly data: readonly NamedDevice<Id>[] | undefined;
+    readonly isError: boolean;
+}
+export declare function deviceListStateOf<Id extends SelectionId = number>(query: DeviceListQueryLike<Id>): DeviceListState;
+export declare function resolveSelectedDevices<Id extends SelectionId = number>(selectedIds: readonly Id[], cameras: readonly NamedDevice<Id>[] | undefined, state: DeviceListState): SelectedDeviceRow<Id>[];
+/**
+ * The selected ids a picker's DRAWN list does not contain, judged against the
+ * WHOLE fleet — never against the drawn list itself. A camera picker draws
+ * cameras, but a rule's devices can be a sensor picked on another surface: the
+ * camera list lacking it says nothing about whether it still exists. Each row
+ * is `removed` (the answered fleet lacks it), named (the fleet has it) or
+ * unnamed (the fleet has not answered).
+ */
+export declare function offListSelections<Id extends SelectionId = number>(selectedIds: readonly Id[], listed: readonly NamedDevice<Id>[] | undefined, fleet: readonly NamedDevice<Id>[] | undefined, fleetState: DeviceListState): SelectedDeviceRow<Id>[];
+/** The "no cameras" hint: only an ANSWERED empty list with nothing selected. */
+export declare function showsNoCamerasHint(state: DeviceListState, cameraCount: number, selectedCount: number): boolean;
+/**
+ * The widening warning: on a picker where an empty selection means ALL
+ * devices, an empty selection that once held devices must say so.
+ */
+export declare function emptyDevicesWidens(emptyMeansAll: boolean, selectedCount: number, hadDevices: boolean): boolean;

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

@@ -0,0 +1,8 @@
+export { DevicePicker, type DevicePickerProps } from './DevicePicker.js';
+export { DeviceFilterBar, typeLabel, type DeviceFilterBarGrouping, type DeviceFilterBarProps, } from './device-filter-bar.js';
+export type { PickerFleetView } from './device-fleet-view.js';
+export { DEVICE_PICKER_GROUP_STORAGE_KEY, readStoredGroupBy, writeStoredGroupBy, useStoredGroupBy, usePickerSiteZones, type StoredGroupBy, } from './device-picker-grouping.js';
+export * from './device-picker-model.js';
+export * from './device-selection.js';
+export { DevicesFailedLine, DevicesLoadingLine, DevicesWidenWarning, orphanDeviceLabel, PICKER_NOUN_PLURAL, type PickerNoun, type PickerNounPlural, } from './device-selection-rows.js';
+export { INPUT_SHELL, SelectedChip, type SelectedChipProps } from './SelectedChip.js';

package/dist/composites/index.d.ts

@@ -170,3 +170,6 @@ export * from './version-badge';
 export * from './widget-panel.js';
 export type { WidgetSlotProps } from './widget-slot';
 export { WidgetSlot } from './widget-slot';
+export * from './device-picker/index.js';
+export * from './unit-picker/index.js';
+export * from './placeholder-field/index.js';

package/dist/composites/placeholder-field/PlaceholderChipField.d.ts

@@ -0,0 +1,29 @@
+export interface PlaceholderChip {
+    readonly id: string;
+    readonly label: string;
+    /** Exact text inserted at the cursor. */
+    readonly token: string;
+}
+export interface PlaceholderChipFieldProps {
+    readonly label: string;
+    readonly value: string;
+    readonly onChange: (next: string) => void;
+    /**
+     * `undefined` = catalog has not answered: no chips, no warning (D315).
+     * `[]` = answered empty.
+     */
+    readonly chips: readonly PlaceholderChip[] | undefined;
+    readonly multiline?: boolean;
+    readonly placeholder?: string;
+    readonly disabled?: boolean;
+    readonly testId: string;
+    readonly maxLength?: number;
+}
+export declare function insertAtSelection(value: string, selection: {
+    readonly start: number;
+    readonly end: number;
+}, token: string): {
+    readonly value: string;
+    readonly cursor: number;
+};
+export declare function PlaceholderChipField({ label, value, onChange, chips, multiline, placeholder, disabled, testId, maxLength, }: PlaceholderChipFieldProps): import("react").JSX.Element;

package/dist/composites/placeholder-field/index.d.ts

@@ -0,0 +1 @@
+export { PlaceholderChipField, insertAtSelection, type PlaceholderChip, type PlaceholderChipFieldProps, } from './PlaceholderChipField.js';

package/dist/composites/unit-picker/UnitPicker.d.ts

@@ -0,0 +1,16 @@
+import { UnitDimension } from '@camstack/types';
+import { ReactNode } from 'react';
+export interface UnitPickerProps {
+    readonly dimension: UnitDimension | undefined;
+    readonly value: string;
+    readonly onChange: (unit: string) => void;
+    readonly disabled?: boolean;
+    /** Shown when `dimension` is undefined; never offered as a pickable unit. */
+    readonly emptyReason?: string;
+    /** Optional empty-value option label (inherit / source). */
+    readonly inheritLabel?: string;
+    readonly className?: string;
+    readonly id?: string;
+    readonly 'aria-label'?: string;
+}
+export declare function UnitPicker({ dimension, value, onChange, disabled, emptyReason, inheritLabel, className, id, 'aria-label': ariaLabel, }: UnitPickerProps): ReactNode;

package/dist/composites/unit-picker/UnitPicker.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/composites/unit-picker/index.d.ts

@@ -0,0 +1 @@
+export { UnitPicker, type UnitPickerProps } from './UnitPicker.js';

package/dist/generated/system-hooks.d.ts

@@ -1151,6 +1151,12 @@ export declare const useOsdManagerCopyDeviceConfiguration: typeof trpc.osdManage
 export declare const useOsdManagerPreviewSlot: typeof trpc.osdManager.previewSlot.useMutation;
 /** Generated alias around `trpc.osdManager.renderDevice.useMutation`. */
 export declare const useOsdManagerRenderDevice: typeof trpc.osdManager.renderDevice.useMutation;
+/** Generated alias around `trpc.osdManager.listTemplates.useQuery`. */
+export declare const useOsdManagerListTemplates: typeof trpc.osdManager.listTemplates.useQuery;
+/** Generated alias around `trpc.osdManager.upsertTemplate.useMutation`. */
+export declare const useOsdManagerUpsertTemplate: typeof trpc.osdManager.upsertTemplate.useMutation;
+/** Generated alias around `trpc.osdManager.deleteTemplate.useMutation`. */
+export declare const useOsdManagerDeleteTemplate: typeof trpc.osdManager.deleteTemplate.useMutation;
 /** Generated alias around `trpc.petFeeder.feed.useMutation`. */
 export declare const usePetFeederFeed: typeof trpc.petFeeder.feed.useMutation;
 /** Generated alias around `trpc.petFeeder.cancelFeed.useMutation`. */