@camstack/ui-library 1.2.257 → 1.2.259

package/dist/composites/event-stream.d.ts

@@ -1,52 +1,69 @@
-import { LiveBuffer } from '../hooks/use-live-buffer';
+/**
+* EventStream — universal event viewer for ui-library.
+*
+* Hierarchical scope: agentId → addonId → deviceId (same as LogStream).
+* Two filtering layers:
+*   1. `defaultCategories` (or legacy `categories`) — initial active
+*      whitelist. The user can mutate this through the toolbar's
+*      multiselect popover; Reset restores the prop's set.
+*   2. Free-text search — case-insensitive substring match across
+*      category, source, data, and the rendered summary line.
+*
+* The backend subscription is mounted only while this component is
+* rendered, so callers can mount/unmount it on tab switches and the
+* tRPC subscription cleans up automatically. The historical query
+* input refreshes when the active category set changes.
+*/
+import { type JSX } from "react";
+import { type LiveBuffer } from "../hooks/use-live-buffer";
 interface EventEntry {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly source: {
-        readonly type: string;
-        readonly id: string | number;
-        readonly nodeId?: string;
-        readonly addonId?: string;
-        readonly deviceId?: number;
-    };
-    readonly category: string;
-    readonly data: Record<string, unknown>;
+	readonly id: string;
+	readonly timestamp: string;
+	readonly source: {
+		readonly type: string;
+		readonly id: string | number;
+		readonly nodeId?: string;
+		readonly addonId?: string;
+		readonly deviceId?: number;
+	};
+	readonly category: string;
+	readonly data: Record<string, unknown>;
 }
 export interface EventStreamProps {
-    readonly agentId?: string;
-    readonly addonId?: string;
-    readonly deviceId?: number;
-    /** Initial whitelist — the user can mutate through the multiselect popover.
-     *  Defaults to ALL EventCategory values when both this and `categories`
-     *  are omitted. */
-    readonly defaultCategories?: readonly string[];
-    /** Legacy alias for `defaultCategories`. Kept for back-compat. */
-    readonly categories?: readonly string[];
-    /** Category glob/pattern passed to the backend subscription (e.g. 'addon.*'). */
-    readonly category?: string;
-    readonly maxHeight?: string;
-    readonly limit?: number;
-    /** Show the multiselect filter button in the toolbar (default true). */
-    readonly showCategoryFilter?: boolean;
-    readonly showFilters?: boolean;
-    /**
-     * Optional controlled live buffer. When provided, the stream reads
-     * + appends to this external store rather than its own `useState`,
-     * so the visible list survives an unmount/remount of the component
-     * (used by `DeviceActivityPanel` to keep tab content alive across
-     * tab switches without keeping subscriptions open in inactive tabs).
-     */
-    readonly liveBuffer?: LiveBuffer<EventEntry>;
-    readonly onClose?: () => void;
-    readonly className?: string;
+	readonly agentId?: string;
+	readonly addonId?: string;
+	readonly deviceId?: number;
+	/** Initial whitelist — the user can mutate through the multiselect popover.
+	*  Defaults to ALL EventCategory values when both this and `categories`
+	*  are omitted. */
+	readonly defaultCategories?: readonly string[];
+	/** Legacy alias for `defaultCategories`. Kept for back-compat. */
+	readonly categories?: readonly string[];
+	/** Category glob/pattern passed to the backend subscription (e.g. 'addon.*'). */
+	readonly category?: string;
+	readonly maxHeight?: string;
+	readonly limit?: number;
+	/** Show the multiselect filter button in the toolbar (default true). */
+	readonly showCategoryFilter?: boolean;
+	readonly showFilters?: boolean;
+	/**
+	* Optional controlled live buffer. When provided, the stream reads
+	* + appends to this external store rather than its own `useState`,
+	* so the visible list survives an unmount/remount of the component
+	* (used by `DeviceActivityPanel` to keep tab content alive across
+	* tab switches without keeping subscriptions open in inactive tabs).
+	*/
+	readonly liveBuffer?: LiveBuffer<EventEntry>;
+	readonly onClose?: () => void;
+	readonly className?: string;
 }
 /** Categories visible in the events tab by default. The "All" badge
- *  reflects this set, not the raw enum. */
+*  reflects this set, not the raw enum. */
 export declare const DEFAULT_EVENT_CATEGORIES: readonly string[];
 export declare function summarizeEvent(category: string, data: Record<string, unknown>): string | null;
-export declare function EventStream({ agentId, addonId, deviceId, defaultCategories, categories: legacyCategories, category: propsCategory, maxHeight, limit, showCategoryFilter, showFilters: _showFilters, liveBuffer: externalBuffer, onClose, className, }: EventStreamProps): import("react").JSX.Element;
+export declare function EventStream({ agentId, addonId, deviceId, defaultCategories, categories: legacyCategories, category: propsCategory, maxHeight, limit, showCategoryFilter, showFilters: _showFilters, liveBuffer: externalBuffer, onClose, className }: EventStreamProps): JSX.Element | null;
 export interface FloatingEventStreamProps extends EventStreamProps {
-    readonly position?: 'bottom' | 'overlay';
+	readonly position?: "bottom" | "overlay";
 }
-export declare function FloatingEventStream({ position, className, ...props }: FloatingEventStreamProps): import("react").JSX.Element;
+export declare function FloatingEventStream({ position, className, ...props }: FloatingEventStreamProps): JSX.Element | null;
 export {};

package/dist/composites/extensions/AssociationSlotCard.d.ts

@@ -1,35 +1,56 @@
-import { ExtensionSlotSource, ExtensionSlotState } from '@camstack/types';
-import { TrackedOption } from './extensions-view-state.js';
+/**
+* One ASSOCIATION slot (D648): the devices a host lists, edited as a device
+* multiselect.
+*
+* - The saved value is the owner's store, read by `listSlots`. The draft is
+*   local until Save, and Save is `setSlot` — the owner validates and writes
+*   through its existing path, so a refusal comes back BY NAME and is shown.
+* - Candidates (`listCandidates`) are fetched only while editing. Suggestions
+*   are chips the operator must click to add; nothing is picked on its own
+*   (D356).
+* - Every saved source shows its health; a missing or unavailable one is
+*   shown with its reason and never silently dropped from the draft.
+* - A gate owned by ANOTHER authority (e.g. a wrapper's binding; no slot
+*   reports one today) is shown read-only, naming that authority (D62).
+* - A slot whose value carries a tracked-event opt-in (`linked-devices`,
+*   D655) gets one toggle per LINKED device — the picks, what the owner links
+*   by structure (`impliedSources`: tree children, never a container, D356)
+*   and any stored opt-in no longer linked, so each can be removed — saved
+*   with the picks, whole.
+*/
+import { type JSX } from "react";
+import { type ExtensionSlotSource, type ExtensionSlotState } from "@camstack/types";
+import { type TrackedOption } from "./extensions-view-state.js";
 export interface SlotSourceListProps {
-    readonly sources: readonly ExtensionSlotSource[];
-    /** The tracked-event opt-in, when the slot carries one. */
-    readonly tracked?: readonly number[] | undefined;
+	readonly sources: readonly ExtensionSlotSource[];
+	/** The tracked-event opt-in, when the slot carries one. */
+	readonly tracked?: readonly number[] | undefined;
 }
 /** The saved sources, each with its health — a bad one is shown, never hidden. */
-export declare function SlotSourceList({ sources, tracked }: SlotSourceListProps): import("react").JSX.Element;
+export declare function SlotSourceList({ sources, tracked }: SlotSourceListProps): JSX.Element | null;
 export interface AssociationSlotCardProps {
-    readonly deviceId: number;
-    readonly row: ExtensionSlotState;
-    readonly onSaved: () => void;
-    /**
-     * No Edit affordance — for a caller whose viewer cannot write `setSlot`
-     * (`auth: 'admin'`), never a client-side echo of a server refusal. The
-     * saved picks are still shown in full (D356: a link is only what the
-     * operator picked, and hiding it from a non-admin would read as gone).
-     */
-    readonly readOnly?: boolean;
+	readonly deviceId: number;
+	readonly row: ExtensionSlotState;
+	readonly onSaved: () => void;
+	/**
+	* No Edit affordance — for a caller whose viewer cannot write `setSlot`
+	* (`auth: 'admin'`), never a client-side echo of a server refusal. The
+	* saved picks are still shown in full (D356: a link is only what the
+	* operator picked, and hiding it from a non-admin would read as gone).
+	*/
+	readonly readOnly?: boolean;
 }
 export interface ActivationLineProps {
-    readonly row: ExtensionSlotState;
+	readonly row: ExtensionSlotState;
 }
 export interface ImpliedSourceListProps {
-    readonly sources: readonly ExtensionSlotSource[];
-    readonly tracked?: readonly number[] | undefined;
+	readonly sources: readonly ExtensionSlotSource[];
+	readonly tracked?: readonly number[] | undefined;
 }
 export interface TrackedTogglesProps {
-    readonly options: readonly TrackedOption[];
-    readonly tracked: readonly number[];
-    readonly nameOf: (id: number) => string;
-    readonly onToggle: (id: number) => void;
+	readonly options: readonly TrackedOption[];
+	readonly tracked: readonly number[];
+	readonly nameOf: (id: number) => string;
+	readonly onToggle: (id: number) => void;
 }
-export declare function AssociationSlotCard({ deviceId, row, onSaved, readOnly, }: AssociationSlotCardProps): import("react").JSX.Element;
+export declare function AssociationSlotCard({ deviceId, row, onSaved, readOnly }: AssociationSlotCardProps): JSX.Element | null;

package/dist/composites/extensions/ExtensionsPanel.d.ts

@@ -1,20 +1,43 @@
-import { ExtensionSlotId } from '@camstack/types';
+/**
+* `host/extensions-panel` — what a device is extended with by OTHER devices,
+* in one place (D648).
+*
+* Mounted by the framework: `device-extension.cap.ts` declares
+* `deviceConfig.ui = { kind:'widget', widgetId:'host/extensions-panel',
+* tab:'general', order:72 }` and `deriveDeviceConfigContribution` emits the
+* section (D14). The panel STORES NOTHING: every card is one row of
+* `device-extension.listSlots`, read by the slot's owner from the store it
+* already has, and every save is `setSlot`, written by that owner through its
+* existing path. It is the only editor of what it shows: the hand-written
+* "Linked devices" and "Virtual doorbell" sections it replaced were retired
+* once the live read matched them on every measured camera (D655).
+*
+* Every slot is an ASSOCIATION, so every card is a device multiselect. A
+* device that GAINS a capability from other devices is a composition, not a
+* slot, and is authored there (D663, amends D648).
+*
+* Absence is claimed only from an answer (D315): pending, failed and empty
+* are three different sentences, and an owner that could not answer is shown
+* with its reason, verbatim — never dropped.
+*/
+import type { ExtensionSlotId } from "@camstack/types";
+import { type JSX } from "react";
 export interface ExtensionsPanelProps {
-    readonly deviceId: number;
-    /**
-     * Only these slots are rendered; absent = every slot (the host widget's
-     * behaviour, unchanged). An owner that could not answer is shown either way:
-     * its row cannot say which slot it owns, and hiding it would read as
-     * "nothing configured" (D315). Used by the Customize tab (D676).
-     */
-    readonly slots?: readonly ExtensionSlotId[];
-    /** Panel title; absent = "Extensions". */
-    readonly title?: string;
-    /**
-     * No Edit affordance on any card (`setSlot` is `auth: 'admin'`). Used by a
-     * viewer who can read `listSlots` (`protected`) but not write — never a
-     * reason to hide the saved picks themselves.
-     */
-    readonly readOnly?: boolean;
+	readonly deviceId: number;
+	/**
+	* Only these slots are rendered; absent = every slot (the host widget's
+	* behaviour, unchanged). An owner that could not answer is shown either way:
+	* its row cannot say which slot it owns, and hiding it would read as
+	* "nothing configured" (D315). Used by the Customize tab (D676).
+	*/
+	readonly slots?: readonly ExtensionSlotId[];
+	/** Panel title; absent = "Extensions". */
+	readonly title?: string;
+	/**
+	* No Edit affordance on any card (`setSlot` is `auth: 'admin'`). Used by a
+	* viewer who can read `listSlots` (`protected`) but not write — never a
+	* reason to hide the saved picks themselves.
+	*/
+	readonly readOnly?: boolean;
 }
-export declare function ExtensionsPanel({ deviceId, slots, title, readOnly, }: ExtensionsPanelProps): import("react").JSX.Element;
+export declare function ExtensionsPanel({ deviceId, slots, title, readOnly }: ExtensionsPanelProps): JSX.Element;

package/dist/composites/extensions/extensions-view-state.d.ts

@@ -1,51 +1,69 @@
-import { ExtensionCandidate, ExtensionSlotCardinality, ExtensionSlotRow, ExtensionSlotState, ExtensionSlotUnreachable, ExtensionSlotValue } from '@camstack/types';
+/**
+* What the Extensions section may CLAIM, from what `listSlots` answered
+* (D648, D315).
+*
+* Four states, and the two a boolean would collapse are kept apart on purpose:
+*
+*  - `pending` — nobody has answered yet. Never "no extensions".
+*  - `unknown` — the query FAILED. It is not an answer, so it is not absence
+*    either; the reason is shown verbatim.
+*  - `none` — the query answered with nothing. The only state that may say
+*    "no extensions".
+*  - `rows` — cards, in the generated table's order, and every owner that
+*    could not answer as its own row with its reason (D554.4). A device whose
+*    ONLY owner failed is `rows` with no slots, not `none`.
+*
+* Also here, pure: the editor's draft rules, so the component holds no logic
+* a spec cannot reach.
+*/
+import { type ExtensionCandidate, type ExtensionSlotCardinality, type ExtensionSlotRow, type ExtensionSlotState, type ExtensionSlotUnreachable, type ExtensionSlotValue } from "@camstack/types";
 /** The one field of a query error this module reads. */
 export interface ExtensionsQueryError {
-    readonly message: string;
+	readonly message: string;
 }
 /** The fields of a query result this module reads — nothing else. */
 export interface ExtensionsQueryView {
-    readonly status: 'pending' | 'error' | 'success';
-    readonly data?: readonly ExtensionSlotRow[] | undefined;
-    readonly error?: ExtensionsQueryError | null;
+	readonly status: "pending" | "error" | "success";
+	readonly data?: readonly ExtensionSlotRow[] | undefined;
+	readonly error?: ExtensionsQueryError | null;
 }
 /** Nobody has answered yet. */
 export interface ExtensionsPendingView {
-    readonly kind: 'pending';
+	readonly kind: "pending";
 }
 /** The read FAILED — not an answer, so not absence either. */
 export interface ExtensionsUnknownView {
-    readonly kind: 'unknown';
-    readonly reason: string;
+	readonly kind: "unknown";
+	readonly reason: string;
 }
 /** Answered with nothing — the only state that may say "no extensions". */
 export interface ExtensionsNoneView {
-    readonly kind: 'none';
+	readonly kind: "none";
 }
 /**
- * A row of a slot this build does NOT declare — an older or newer server than
- * this admin UI (a rollback after slice 6 still answers `doorbell-source`).
- * It cannot be a card (no descriptor), so it is said by name instead: never
- * dropped, never crashing the panel (D315, task 17 re-review R1).
- */
+* A row of a slot this build does NOT declare — an older or newer server than
+* this admin UI (a rollback after slice 6 still answers `doorbell-source`).
+* It cannot be a card (no descriptor), so it is said by name instead: never
+* dropped, never crashing the panel (D315, task 17 re-review R1).
+*/
 export interface ExtensionsUnknownSlotRow {
-    readonly slot: string;
-    readonly slotRef: string;
+	readonly slot: string;
+	readonly slotRef: string;
 }
 /** Cards in table order, every slot this build does not know, and every owner that could not answer. */
 export interface ExtensionsRowsView {
-    readonly kind: 'rows';
-    readonly slots: readonly ExtensionSlotState[];
-    readonly unknownSlots: readonly ExtensionsUnknownSlotRow[];
-    readonly unreachable: readonly ExtensionSlotUnreachable[];
+	readonly kind: "rows";
+	readonly slots: readonly ExtensionSlotState[];
+	readonly unknownSlots: readonly ExtensionsUnknownSlotRow[];
+	readonly unreachable: readonly ExtensionSlotUnreachable[];
 }
 export type ExtensionsView = ExtensionsPendingView | ExtensionsUnknownView | ExtensionsNoneView | ExtensionsRowsView;
 /** The order cards are shown in: the generated slot table's. */
 export type ExtensionSlotTableOrder = readonly string[];
 /**
- * `order` is the generated table (`EXTENSION_SLOT_IDS`); a parameter only so a
- * spec can pin the comparator while the table holds a single slot.
- */
+* `order` is the generated table (`EXTENSION_SLOT_IDS`); a parameter only so a
+* spec can pin the comparator while the table holds a single slot.
+*/
 export declare function resolveExtensionsView(query: ExtensionsQueryView, order?: ExtensionSlotTableOrder): ExtensionsView;
 /** Add or remove one pick. `one` replaces; `many` toggles. */
 export declare function togglePick(draft: readonly number[], deviceId: number, cardinality: ExtensionSlotCardinality): readonly number[];
@@ -56,51 +74,51 @@ export declare function searchCandidates(candidates: readonly ExtensionCandidate
 /** Whether the draft differs from what the owner's store holds. */
 export declare function isDirty(saved: readonly number[], draft: readonly number[]): boolean;
 /**
- * The tracked-event opt-in a slot's value carries, or `undefined` when it
- * carries none — every slot but `linked-devices`, and a `linked-devices` row
- * from a server older than D655. `undefined` is "this owner offers no
- * opt-in", never "nothing is opted in": the card then shows no toggle rather
- * than a row of unticked ones it could not save.
- */
+* The tracked-event opt-in a slot's value carries, or `undefined` when it
+* carries none — every slot but `linked-devices`, and a `linked-devices` row
+* from a server older than D655. `undefined` is "this owner offers no
+* opt-in", never "nothing is opted in": the card then shows no toggle rather
+* than a row of unticked ones it could not save.
+*/
 export declare function trackedOptInOf(value: ExtensionSlotValue): readonly number[] | undefined;
 /** Flip one device's tracked-event opt-in. */
 export declare function toggleTracked(tracked: readonly number[], deviceId: number): readonly number[];
 /** Whether two opt-ins differ as SETS — the order carries no meaning. */
 export declare function isTrackedDirty(saved: readonly number[], draft: readonly number[]): boolean;
 /** Where a tracked-event toggle comes from — said next to it. */
-export type TrackedOptionOrigin = 'pick' | 'implied' | 'not-linked';
+export type TrackedOptionOrigin = "pick" | "implied" | "not-linked";
 /** One device the editor offers a tracked-event toggle for. */
 export interface TrackedOption {
-    readonly deviceId: number;
-    readonly origin: TrackedOptionOrigin;
+	readonly deviceId: number;
+	readonly origin: TrackedOptionOrigin;
 }
 /** What `trackedOptions` builds the toggle list from. */
 export interface TrackedOptionsInput {
-    /** The draft picks. */
-    readonly picks: readonly number[];
-    /** Saved picks that are not a valid source (a container, D356) — no toggle. */
-    readonly invalidPicks: readonly number[];
-    /** Linked by the owner's own structure (`impliedSources`). */
-    readonly implied: readonly number[];
-    /** The draft opt-in. */
-    readonly tracked: readonly number[];
+	/** The draft picks. */
+	readonly picks: readonly number[];
+	/** Saved picks that are not a valid source (a container, D356) — no toggle. */
+	readonly invalidPicks: readonly number[];
+	/** Linked by the owner's own structure (`impliedSources`). */
+	readonly implied: readonly number[];
+	/** The draft opt-in. */
+	readonly tracked: readonly number[];
 }
 /**
- * One toggle per device the camera links — the old section's set (D655):
- * the valid picks, then what the owner links by structure (tree children, a
- * picked container's child — never the container itself, D356), then every
- * opted-in device that is linked no more, so a stored opt-in is always
- * visible and can always be removed.
- */
+* One toggle per device the camera links — the old section's set (D655):
+* the valid picks, then what the owner links by structure (tree children, a
+* picked container's child — never the container itself, D356), then every
+* opted-in device that is linked no more, so a stored opt-in is always
+* visible and can always be removed.
+*/
 export declare function trackedOptions(input: TrackedOptionsInput): readonly TrackedOption[];
 /**
- * The opt-in after one device is removed from the draft picks: its toggle
- * goes with it, unless the camera still links it by structure.
- */
+* The opt-in after one device is removed from the draft picks: its toggle
+* goes with it, unless the camera still links it by structure.
+*/
 export declare function untrackUnpicked(tracked: readonly number[], deviceId: number, implied: readonly number[]): readonly number[];
 /**
- * The value a Save sends. The opt-in travels only when the owner offered one,
- * and then WHOLE: it replaces the stored one, and the owner accepts any id it
- * already stored, so what was read can be sent back unchanged (D655).
- */
+* The value a Save sends. The opt-in travels only when the owner offered one,
+* and then WHOLE: it replaces the stored one, and the owner accepts any id it
+* already stored, so what was read can be sent back unchanged (D655).
+*/
 export declare function slotWriteValue(saved: ExtensionSlotValue, deviceIds: readonly number[], tracked: readonly number[] | undefined): ExtensionSlotValue;

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

@@ -1,28 +1,29 @@
+import { type JSX } from "react";
 type FilterDef = {
-    type: 'search';
-    key: string;
-    placeholder?: string;
+	type: "search";
+	key: string;
+	placeholder?: string;
 } | {
-    type: 'select';
-    key: string;
-    label: string;
-    options: {
-        value: string;
-        label: string;
-    }[];
+	type: "select";
+	key: string;
+	label: string;
+	options: {
+		value: string;
+		label: string;
+	}[];
 } | {
-    type: 'badge-toggle';
-    key: string;
-    options: {
-        value: string;
-        label: string;
-    }[];
+	type: "badge-toggle";
+	key: string;
+	options: {
+		value: string;
+		label: string;
+	}[];
 };
 export type { FilterDef };
 export interface FilterBarProps {
-    filters: FilterDef[];
-    values: Record<string, unknown>;
-    onChange: (values: Record<string, unknown>) => void;
-    className?: string;
+	filters: FilterDef[];
+	values: Record<string, unknown>;
+	onChange: (values: Record<string, unknown>) => void;
+	className?: string;
 }
-export declare function FilterBar({ filters, values, onChange, className }: FilterBarProps): import("react").JSX.Element;
+export declare function FilterBar({ filters, values, onChange, className }: FilterBarProps): JSX.Element | null;

package/dist/composites/form-field.d.ts

@@ -1,11 +1,11 @@
-import { ReactNode } from 'react';
+import { type ReactNode, type JSX } from "react";
 export interface FormFieldProps {
-    label: string;
-    description?: string;
-    error?: string;
-    required?: boolean;
-    children: ReactNode;
-    orientation?: 'vertical' | 'horizontal';
-    className?: string;
+	label: string;
+	description?: string;
+	error?: string;
+	required?: boolean;
+	children: ReactNode;
+	orientation?: "vertical" | "horizontal";
+	className?: string;
 }
-export declare function FormField({ label, description, error, required, children, orientation, className, }: FormFieldProps): import("react").JSX.Element;
+export declare function FormField({ label, description, error, required, children, orientation, className }: FormFieldProps): JSX.Element;

package/dist/composites/format-state-value.d.ts

@@ -1,62 +1,34 @@
-/**
- * Leaf formatting for the device State panel — in particular, turning epoch
- * timestamps into readable local dates.
- *
- * ## Why this needs a rule rather than a `typeof`
- *
- * `lastFetchedAt: 1785060000000` is unreadable, and every `runtimeState` slice is
- * required to carry one. But "large number" is not "timestamp": `bitrate`,
- * `memoryRss`, `diskFree` and `retentionDays` are all numbers, and rendering a
- * bitrate as a date in 1970 is worse than leaving it raw.
- *
- * So a value is treated as a time point only when BOTH hold:
- *
- *   1. the KEY names a time point — `…At`, `…AtMs`, `timestamp`, `…Since`,
- *      `lastSeen`, `expires…`; and
- *   2. the NUMBER falls in a plausible epoch range.
- *
- * Requiring both is what keeps `uptimeSeconds` (a duration whose name contains
- * "time"), `timeoutMs` and `batchIntervalMs` (durations ending in "Ms") out of it.
- * Durations are deliberately NOT converted — this formats instants, not spans.
- *
- * ## The raw value is never lost
- *
- * This is a debugging panel, so the exact number still matters. The formatted text
- * is what is shown; `raw` is returned alongside for a `title` tooltip, and search
- * matches against both. Replacing the value outright would trade one kind of
- * unreadability for another.
- */
 export declare function isTimeKey(key: string): boolean;
 /** Epoch milliseconds for a numeric value under a time-shaped key, else null. */
 export declare function epochMsOf(value: number): number | null;
 /**
- * Locale-formatted instant. `undefined` locale means the viewer's own locale,
- * which is the point — an operator in Rome should not read UTC.
- */
+* Locale-formatted instant. `undefined` locale means the viewer's own locale,
+* which is the point — an operator in Rome should not read UTC.
+*/
 export declare function formatLocalDate(epochMs: number): string;
 export interface FormattedLeaf {
-    /** What is displayed. */
-    readonly text: string;
-    /**
-     * The untouched original, present ONLY when `text` differs from it — so a
-     * caller can show a tooltip without one on every unremarkable value.
-     */
-    readonly raw: string | null;
+	/** What is displayed. */
+	readonly text: string;
+	/**
+	* The untouched original, present ONLY when `text` differs from it — so a
+	* caller can show a tooltip without one on every unremarkable value.
+	*/
+	readonly raw: string | null;
 }
 /**
- * Format one leaf of the state tree, given the key it sits under.
- *
- * Handles two timestamp shapes:
- *   - a NUMBER under a time-shaped key → local date, raw kept
- *   - an ISO-8601 STRING → local date, raw kept. No key check needed: an ISO
- *     string is unambiguous, and a Moleculer round-trip turns every `Date` into
- *     one, so these appear whether or not the key looks temporal.
- */
+* Format one leaf of the state tree, given the key it sits under.
+*
+* Handles two timestamp shapes:
+*   - a NUMBER under a time-shaped key → local date, raw kept
+*   - an ISO-8601 STRING → local date, raw kept. No key check needed: an ISO
+*     string is unambiguous, and a Moleculer round-trip turns every `Date` into
+*     one, so these appear whether or not the key looks temporal.
+*/
 export declare function formatLeafValue(key: string, value: unknown): FormattedLeaf;
 /**
- * Strict ISO-8601 with a time part. Requires the `T` and at least
- * `hh:mm` — a bare `2026-07-26` is far more often a version, an id fragment or a
- * label than a date, and `Date.parse` would silently read it as UTC midnight and
- * shift it a day in a negative-offset locale.
- */
+* Strict ISO-8601 with a time part. Requires the `T` and at least
+* `hh:mm` — a bare `2026-07-26` is far more often a version, an id fragment or a
+* label than a date, and `Date.parse` would silently read it as UTC midnight and
+* shift it a day in a negative-offset locale.
+*/
 export declare function isIsoDateString(value: string): boolean;

package/dist/composites/grouped-model-selector.d.ts

@@ -1,8 +1,9 @@
-import { ModelVariantSource } from '@camstack/types';
+import type { JSX } from "react";
+import { type ModelVariantSource } from "@camstack/types";
 export interface GroupedModelSelectorProps {
-    readonly catalog: readonly ModelVariantSource[];
-    readonly value: string;
-    readonly onChange: (id: string) => void;
-    readonly disabled?: boolean;
+	readonly catalog: readonly ModelVariantSource[];
+	readonly value: string;
+	readonly onChange: (id: string) => void;
+	readonly disabled?: boolean;
 }
-export declare function GroupedModelSelector({ catalog, value, onChange, disabled, }: GroupedModelSelectorProps): import("react").JSX.Element | null;
+export declare function GroupedModelSelector({ catalog, value, onChange, disabled }: GroupedModelSelectorProps): JSX.Element | null;