@camstack/ui-library 1.2.256 → 1.2.258

package/dist/composites/cap-settings/SceneMonitorEditor.d.ts

@@ -1,53 +1,5 @@
-/**
- * SceneMonitorEditor — the per-camera half of the Scenes surface.
- *
- * **Imported directly, not resolved as a widget.** It briefly lived behind the
- * host widget `host/scene-monitor-editor`, mounted as a "Scenes" tab on one
- * camera's detail page. That put a standing question about the property ("is
- * the bin still out") one camera deep, where the operator's actual question —
- * "which of my scenes have tripped" — could not be asked at all. The overview
- * is now the top-level `/scenes` page; this component is what that page opens
- * once a camera is chosen, in a dialog. The widget id and its `deviceConfig`
- * declaration are both gone, in the same commit, because
- * `scripts/check-host-widget-resolves.ts` checks both directions.
- *
- * It renders BARE — no `WidgetPanel` — because its only caller supplies a
- * dialog header, and two stacked titles read as a layout bug.
- *
- * ## The flow, in the order the operator meets it
- *
- * 1. **Draw a region on the still frame.** A rect over a SNAPSHOT, not the live
- *    player: a scene is defined against a photograph, and drawing on a moving
- *    picture makes it impossible to see whether the box actually contains the
- *    bin. The editor starts in draw mode and warns above ~40 % of the frame,
- *    because a full-frame scene is dominated by weather, sky and parked cars —
- *    it will not work, and it will look broken rather than misconfigured.
- * 2. **Capture the initial state, per lighting variant.** Two buttons, Daylight
- *    and Night (IR), each forcing a fresh snapshot. The variant is DETECTED
- *    from the frame and shown rather than asked; the buttons exist so the
- *    operator can say "capture this as the night reference" while standing
- *    outside at 22:00 — which is exactly why **Night (IR) is labelled
- *    optional**. Almost nobody does that, and a scene captured only in daylight
- *    is a configuration, not a defect: under the default
- *    `onUncoveredCondition: 'skip'` the infrared hours are simply sat out.
- * 3. **Read the coverage line.** "Daylight ✓ · Night (IR) ✗ — optional; checks
- *    in night (ir) are skipped". This feature's failure mode is silence that
- *    reads as "nothing has happened", and that one line is the difference
- *    between a five-minute fix and a session of guessing — but it must say what
- *    HAPPENS, not complain. It used to end "reports 'can't tell'", which made a
- *    correctly configured scene look broken every night.
- * 4. **Reset.** Clears the flag AND re-captures the baseline for the current
- *    light, because the bin never goes back in exactly the same spot.
- * 5. **Settings.** Every knob the model has actually carried since the provider
- *    shipped — how often it looks, how closely it has to match, how many
- *    agreeing checks a change costs, what a missing light means, which boolean
- *    drives notifications, and whether a vision model adjudicates a flip. None
- *    of it was reachable before; see `SceneSettingsForm`.
- *
- * Live state arrives through the cap's `status.kind: 'push'` runtime slice, so
- * the card updates itself without polling.
- */
+import { type JSX } from "react";
 export interface SceneMonitorEditorProps {
-    readonly deviceId: number;
+	readonly deviceId: number;
 }
-export declare function SceneMonitorEditor({ deviceId }: SceneMonitorEditorProps): import("react").JSX.Element | null;
+export declare function SceneMonitorEditor({ deviceId }: SceneMonitorEditorProps): JSX.Element | null;

package/dist/composites/cap-settings/SceneReferenceGallery.d.ts

@@ -1,36 +1,75 @@
-import { SceneMonitor, SceneReference } from '@camstack/types';
+/**
+* SceneReferenceGallery — the photographs a scene is actually judging against,
+* grouped by lighting variant, each individually deletable.
+*
+* ## Why it has to exist
+*
+* A scene's whole answer is "does this region still look like the photograph".
+* Until now the operator could see a COUNT of references and never the
+* references themselves, which makes the two failure modes indistinguishable
+* from the outside: a blurry capture taken while a van was in the way poisons a
+* condition forever, and from a cosine score there is no way to tell which one
+* it was. `deleteReference` shipped with the cap for exactly this and had no
+* caller.
+*
+* ## The image
+*
+* A bare `<img>` against the `event-media` data plane
+* (`/addon/pipeline-analytics/event-media/m/<mediaId>` — D482), which is
+* `access: 'authenticated'` — that accepts the `camstack_session` cookie, and a
+* cookie is the only credential an `<img>` can send. Same mechanism, and the
+* same reasoning, as `use-device-snapshot`; no bearer-token blob fetch is
+* needed and no second copy of the auth plumbing is introduced here.
+*
+* `SceneReference.thumbnailMediaId` finally IS a media row id (D482). It was
+* named `…MediaId` while holding a composite MediaStore key
+* (`scene:<ownerId>:thumbnailSmall:<ts>`), which this component read
+* POSITIONALLY for its owner id — a name that described the right design
+* beside a value that did not, which is the shape of leftover this repo has
+* been bitten by three times. The tile now addresses the row.
+*
+* **A missing blob is normal, not exceptional.** Reference thumbnails written
+* before the `ownerKind: 'scene'` fix carried an `ownerId` no event row backs,
+* which made them eligible for the orphan sweep — so on an existing install
+* some of these ids resolve to nothing. That must degrade to a dated
+* placeholder: the reference is still real, still being scored against, and
+* still deletable. A gallery that blanks or throws over a missing picture would
+* take the delete button away exactly when it is needed.
+*/
+import type { SceneMonitor, SceneReference } from "@camstack/types";
+import { type JSX } from "react";
 /** The hub-proxied prefix for the pipeline-analytics event-media data plane. */
 export declare const SCENE_MEDIA_BASE: string;
 /** One reference, with the coordinates `deleteReference` addresses it by. */
 export interface SceneReferenceTile {
-    readonly stateId: string;
-    /** Index into THAT state's `references` array — the cap's own addressing. */
-    readonly index: number;
-    readonly reference: SceneReference;
+	readonly stateId: string;
+	/** Index into THAT state's `references` array — the cap's own addressing. */
+	readonly index: number;
+	readonly reference: SceneReference;
 }
 export interface SceneReferenceGroup {
-    readonly condition: string;
-    readonly tiles: readonly SceneReferenceTile[];
+	readonly condition: string;
+	readonly tiles: readonly SceneReferenceTile[];
 }
 /**
- * Flatten `states[].references[]` into per-condition groups while keeping each
- * reference's `(stateId, index)` — the pair `deleteReference` takes.
- *
- * The index is deliberately the position in the state's OWN array rather than
- * anything derived from the grouping: an index computed over the grouped view
- * would address a different reference the moment a scene holds two conditions,
- * and the operator would delete the wrong photograph with no way to tell.
- */
+* Flatten `states[].references[]` into per-condition groups while keeping each
+* reference's `(stateId, index)` — the pair `deleteReference` takes.
+*
+* The index is deliberately the position in the state's OWN array rather than
+* anything derived from the grouping: an index computed over the grouped view
+* would address a different reference the moment a scene holds two conditions,
+* and the operator would delete the wrong photograph with no way to tell.
+*/
 export declare function groupReferences(monitor: SceneMonitor): readonly SceneReferenceGroup[];
 /** Total references across every state — the count that decides whether a
- *  delete leaves the scene with no idea what "normal" looks like. */
+*  delete leaves the scene with no idea what "normal" looks like. */
 export declare function totalReferences(monitor: SceneMonitor): number;
 export interface SceneReferenceGalleryProps {
-    readonly monitor: SceneMonitor;
-    readonly disabled: boolean;
-    readonly onDelete: (input: {
-        stateId: string;
-        index: number;
-    }) => void;
+	readonly monitor: SceneMonitor;
+	readonly disabled: boolean;
+	readonly onDelete: (input: {
+		stateId: string;
+		index: number;
+	}) => void;
 }
-export declare function SceneReferenceGallery({ monitor, disabled, onDelete }: SceneReferenceGalleryProps): import("react").JSX.Element;
+export declare function SceneReferenceGallery({ monitor, disabled, onDelete }: SceneReferenceGalleryProps): JSX.Element;

package/dist/composites/cap-settings/SceneSettingsForm.d.ts

@@ -1,21 +1,57 @@
-import { SceneCheck, SceneMonitor, SceneUncoveredPolicy } from '@camstack/types';
+/**
+* SceneSettingsForm — every knob a scene actually has, per scene.
+*
+* ## Why this exists
+*
+* The model has carried `enabled`, `triggerMode`, `checkIntervalSec`,
+* `check.threshold`, `check.hysteresisCount`, `quietSeconds`,
+* `minObservationSpacingSec`, `emit`, `autoRestore` and `confirm` since the
+* provider shipped, and `updateScene` has accepted a patch for all of them —
+* but the editor exposed **none**. Every scene therefore ran on the creation
+* defaults, and an operator whose scene fired too eagerly (or not at all) had
+* no move available except deleting it and drawing it again. Tuning knobs that
+* exist and cannot be reached are worse than absent ones: they read, from the
+* code, as a feature that shipped.
+*
+* ## What is deliberately NOT here
+*
+* `check.mode: 'llm'`. The cap declares it and the engine has an adapter seam
+* for it, but no production caller supplies `SceneEngineDeps.llm` — an
+* `llm`-mode scene reports `availability: 'unavailable'` forever. Offering the
+* switch would let an operator convert a working scene into a permanently
+* broken one in one click. The vision model reaches a scene through the
+* **`confirm`** adjudicator instead, which IS wired (`SceneConfirmGate`, built
+* unconditionally at the engine's construction site) and is the better
+* topology anyway: CLIP proposes at the poll cadence, the model is asked only
+* on a candidate flip.
+*
+* ## Editing model
+*
+* Local draft, committed on blur when it differs — the `AutotrackSection`
+* shape. Selects and checkboxes commit on change, because there is no
+* intermediate state worth protecting. There is no second store and no "save"
+* button: `updateScene` writes the authority the provider already owns and the
+* caller refetches (D62).
+*/
+import type { SceneCheck, SceneMonitor, SceneUncoveredPolicy } from "@camstack/types";
+import { type JSX } from "react";
 /** The subset of `updateScene`'s patch this form can produce. */
 export interface SceneSettingsPatch {
-    readonly label?: string;
-    readonly enabled?: boolean;
-    readonly triggerMode?: SceneMonitor['triggerMode'];
-    readonly checkIntervalSec?: number;
-    readonly check?: SceneCheck;
-    readonly quietSeconds?: number;
-    readonly minObservationSpacingSec?: number;
-    readonly emit?: SceneMonitor['emit'];
-    readonly autoRestore?: boolean;
-    readonly onUncoveredCondition?: SceneUncoveredPolicy;
-    readonly confirm?: SceneMonitor['confirm'] | null;
+	readonly label?: string;
+	readonly enabled?: boolean;
+	readonly triggerMode?: SceneMonitor["triggerMode"];
+	readonly checkIntervalSec?: number;
+	readonly check?: SceneCheck;
+	readonly quietSeconds?: number;
+	readonly minObservationSpacingSec?: number;
+	readonly emit?: SceneMonitor["emit"];
+	readonly autoRestore?: boolean;
+	readonly onUncoveredCondition?: SceneUncoveredPolicy;
+	readonly confirm?: SceneMonitor["confirm"] | null;
 }
 export interface SceneSettingsFormProps {
-    readonly monitor: SceneMonitor;
-    readonly disabled: boolean;
-    readonly onPatch: (patch: SceneSettingsPatch) => void;
+	readonly monitor: SceneMonitor;
+	readonly disabled: boolean;
+	readonly onPatch: (patch: SceneSettingsPatch) => void;
 }
-export declare function SceneSettingsForm({ monitor, disabled, onPatch }: SceneSettingsFormProps): import("react").JSX.Element;
+export declare function SceneSettingsForm({ monitor, disabled, onPatch }: SceneSettingsFormProps): JSX.Element;

package/dist/composites/cap-settings/TimelineControls.d.ts

@@ -1,24 +1,25 @@
-import { DayWindow } from './recording-timeline-model';
+import { type JSX } from "react";
+import { type DayWindow } from "./recording-timeline-model";
 interface TimelineControlsProps {
-    /** Currently selected calendar day. */
-    readonly day: Date;
-    /** Called when the user picks a new day. */
-    readonly onDayChange: (d: Date) => void;
-    /** Current zoom+pan view window. */
-    readonly view: DayWindow;
-    /** Full day bounds (used for zoom/pan clamping). */
-    readonly dayBounds: DayWindow;
-    /** Called when zoom changes the view. */
-    readonly onViewChange: (w: DayWindow) => void;
+	/** Currently selected calendar day. */
+	readonly day: Date;
+	/** Called when the user picks a new day. */
+	readonly onDayChange: (d: Date) => void;
+	/** Current zoom+pan view window. */
+	readonly view: DayWindow;
+	/** Full day bounds (used for zoom/pan clamping). */
+	readonly dayBounds: DayWindow;
+	/** Called when zoom changes the view. */
+	readonly onViewChange: (w: DayWindow) => void;
 }
 /**
- * Date selector + prev/next pan + zoom-in / zoom-out buttons for the recording
- * timeline. Zoom cycles through ZOOM_LEVELS (widest → narrowest), anchored on
- * the view's RIGHT edge — so on today's timeline "now" stays pinned to the right
- * instead of drifting to a midday range. The ◀ / ▶ buttons step the visible
- * window earlier/later within the day (the discoverable equivalent of the
- * horizontal wheel-pan wired in RecordingTimeline), so a zoomed-in day can be
- * navigated back and forth without a mouse wheel.
- */
-export declare function TimelineControls({ day, onDayChange, view, dayBounds, onViewChange, }: TimelineControlsProps): import("react").JSX.Element;
+* Date selector + prev/next pan + zoom-in / zoom-out buttons for the recording
+* timeline. Zoom cycles through ZOOM_LEVELS (widest → narrowest), anchored on
+* the view's RIGHT edge — so on today's timeline "now" stays pinned to the right
+* instead of drifting to a midday range. The ◀ / ▶ buttons step the visible
+* window earlier/later within the day (the discoverable equivalent of the
+* horizontal wheel-pan wired in RecordingTimeline), so a zoomed-in day can be
+* navigated back and forth without a mouse wheel.
+*/
+export declare function TimelineControls({ day, onDayChange, view, dayBounds, onViewChange }: TimelineControlsProps): JSX.Element | null;
 export {};

package/dist/composites/cap-settings/camera-grid-layout.d.ts

@@ -1,119 +1,119 @@
 /**
- * The pure half of the camera-grid layout editor: what a grid IS on this side
- * of the wire, and the geometry the drag handles apply.
- *
- * Both rectangles an editor manipulates are NORMALIZED [0,1] — the crop taken
- * out of a source, and the cell it lands in. The addon stores them that way so
- * a source camera that changes resolution does not silently start cutting the
- * wrong part of the picture, and the editor has to speak the same language or
- * the conversion becomes a second place the convention can drift.
- */
+* The pure half of the camera-grid layout editor: what a grid IS on this side
+* of the wire, and the geometry the drag handles apply.
+*
+* Both rectangles an editor manipulates are NORMALIZED [0,1] — the crop taken
+* out of a source, and the cell it lands in. The addon stores them that way so
+* a source camera that changes resolution does not silently start cutting the
+* wrong part of the picture, and the editor has to speak the same language or
+* the conversion becomes a second place the convention can drift.
+*/
 export interface GridNormalizedRect {
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
+	readonly x: number;
+	readonly y: number;
+	readonly width: number;
+	readonly height: number;
 }
 export interface GridLayoutCell {
-    readonly deviceId: number;
-    /** The part of the SOURCE taken, normalized against the source. */
-    readonly source: GridNormalizedRect;
-    /** Where it lands, normalized against the CANVAS. */
-    readonly cell: GridNormalizedRect;
+	readonly deviceId: number;
+	/** The part of the SOURCE taken, normalized against the source. */
+	readonly source: GridNormalizedRect;
+	/** Where it lands, normalized against the CANVAS. */
+	readonly cell: GridNormalizedRect;
 }
 /**
- * Which profiles this grid can compose, and which sources stop it.
- *
- * Read-only in the editor. The operator does not choose what is on offer — the
- * source cameras do, by what they have assigned — and a checkbox that pretended
- * otherwise would publish a composition with a hole in it.
- */
+* Which profiles this grid can compose, and which sources stop it.
+*
+* Read-only in the editor. The operator does not choose what is on offer — the
+* source cameras do, by what they have assigned — and a checkbox that pretended
+* otherwise would publish a composition with a hole in it.
+*/
 export interface GridProfileOffer {
-    readonly profile: 'high' | 'mid' | 'low';
-    readonly offered: boolean;
-    readonly missingSources: readonly number[];
-    /**
-     * The canvas this profile composes onto, `WxH`, or empty when it is not
-     * offered. DERIVED — the operator no longer types a resolution, so this is
-     * the only place the grid's actual size is ever stated.
-     */
-    readonly canvas: string;
-    /**
-     * Whether this profile is PUBLISHED, of the ones the grid could serve.
-     *
-     * A grid's `high` composes its sources' `high`, so on a 4K fleet it is a 4K
-     * canvas built from 4K decodes — an opt-in, not something a viewer's adaptive
-     * should be handed by climbing to the top rung it can see.
-     */
-    readonly published: boolean;
+	readonly profile: "high" | "mid" | "low";
+	readonly offered: boolean;
+	readonly missingSources: readonly number[];
+	/**
+	* The canvas this profile composes onto, `WxH`, or empty when it is not
+	* offered. DERIVED — the operator no longer types a resolution, so this is
+	* the only place the grid's actual size is ever stated.
+	*/
+	readonly canvas: string;
+	/**
+	* Whether this profile is PUBLISHED, of the ones the grid could serve.
+	*
+	* A grid's `high` composes its sources' `high`, so on a 4K fleet it is a 4K
+	* canvas built from 4K decodes — an opt-in, not something a viewer's adaptive
+	* should be handed by climbing to the top rung it can see.
+	*/
+	readonly published: boolean;
 }
 export interface GridLayoutView {
-    readonly instanceId: string;
-    readonly deviceId: number;
-    readonly name: string;
-    readonly fps: number;
-    readonly cells: readonly GridLayoutCell[];
-    readonly profiles: readonly GridProfileOffer[];
+	readonly instanceId: string;
+	readonly deviceId: number;
+	readonly name: string;
+	readonly fps: number;
+	readonly cells: readonly GridLayoutCell[];
+	readonly profiles: readonly GridProfileOffer[];
 }
 /**
- * What a read of the grid can be.
- *
- * Three OUTCOMES, never two: a grid, an answer of "this device is not a grid"
- * (`null`), and a reply this page could not read (`'unreadable'`). Collapsing
- * the last two makes "not yet known" indistinguishable from "not installed",
- * which is exactly the failure D315 exists to stop.
- */
-export type GridLayoutReadOutcome = GridLayoutView | null | 'unreadable';
+* What a read of the grid can be.
+*
+* Three OUTCOMES, never two: a grid, an answer of "this device is not a grid"
+* (`null`), and a reply this page could not read (`'unreadable'`). Collapsing
+* the last two makes "not yet known" indistinguishable from "not installed",
+* which is exactly the failure D315 exists to stop.
+*/
+export type GridLayoutReadOutcome = GridLayoutView | null | "unreadable";
 /**
- * Parse the `camera-grid-layout.getLayout` reply. See {@link GridLayoutReadOutcome}.
- *
- * The cap answers the view itself, or `null` — there is no envelope. It used to
- * come back as `{ grid }` from `addons.custom`, which was the mechanism the
- * widget reached the addon through before the geometry had a capability of its
- * own; the widget now asks THE CAMERA and the envelope went with the bridge.
- */
+* Parse the `camera-grid-layout.getLayout` reply. See {@link GridLayoutReadOutcome}.
+*
+* The cap answers the view itself, or `null` — there is no envelope. It used to
+* come back as `{ grid }` from `addons.custom`, which was the mechanism the
+* widget reached the addon through before the geometry had a capability of its
+* own; the widget now asks THE CAMERA and the envelope went with the bridge.
+*/
 export declare function parseGridView(raw: unknown): GridLayoutReadOutcome;
 /**
- * Keep a rectangle inside the unit square.
- *
- * The addon THROWS on a rectangle that falls outside — a silently clipped
- * picture is worse than a refusal — so the editor must never hand it one.
- */
+* Keep a rectangle inside the unit square.
+*
+* The addon THROWS on a rectangle that falls outside — a silently clipped
+* picture is worse than a refusal — so the editor must never hand it one.
+*/
 export declare function clampNormalizedRect(rect: GridNormalizedRect): GridNormalizedRect;
 /** Drag: translate by a normalized delta, clamped. */
 export declare function moveNormalizedRect(rect: GridNormalizedRect, dx: number, dy: number): GridNormalizedRect;
 /** Resize from the bottom-right corner: the origin stays put. */
 export declare function resizeNormalizedRect(rect: GridNormalizedRect, dw: number, dh: number): GridNormalizedRect;
 /** The eight grips on a rectangle. A corner moves two edges, an edge one. */
-export type GridResizeHandle = 'nw' | 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w';
+export type GridResizeHandle = "nw" | "n" | "ne" | "e" | "se" | "s" | "sw" | "w";
 /**
- * Resize from ANY handle: the opposite side is the anchor.
- *
- * The editor had one grip, in the bottom-right, which meant a cell could only
- * grow away from its origin — to move its top edge an operator had to drag the
- * whole cell and then resize it back. The rectangle is expressed as its two
- * edges here rather than origin+extent, because that is what makes "the
- * opposite edge does not move" fall out instead of being arithmetic to get
- * wrong. `clampNormalizedRect` still has the last word: the addon THROWS on a
- * rectangle outside the unit square.
- */
+* Resize from ANY handle: the opposite side is the anchor.
+*
+* The editor had one grip, in the bottom-right, which meant a cell could only
+* grow away from its origin — to move its top edge an operator had to drag the
+* whole cell and then resize it back. The rectangle is expressed as its two
+* edges here rather than origin+extent, because that is what makes "the
+* opposite edge does not move" fall out instead of being arithmetic to get
+* wrong. `clampNormalizedRect` still has the last word: the addon THROWS on a
+* rectangle outside the unit square.
+*/
 export declare function resizeNormalizedRectFrom(rect: GridNormalizedRect, handle: GridResizeHandle, dx: number, dy: number): GridNormalizedRect;
 /**
- * Tile the whole canvas with `count` cells, leaving no gap.
- *
- * Autofill exists because the useful answer to "put these four cameras up" is
- * almost never the one hand-dragging produces: rectangles land a pixel apart
- * and the composition shows black seams the operator cannot see in the editor
- * but will see in the stream.
- *
- * The shape is the near-square one — `ceil(sqrt(n))` columns — and a short last
- * row STRETCHES to the full width rather than leaving a hole. Three cameras
- * become two over one, not a 2x2 with an empty quarter, which is precisely the
- * layout autofill is asked to avoid.
- *
- * Aspect is deliberately not considered: these are CANVAS fractions, and what a
- * source shows inside its cell is the crop's business (the source rectangle),
- * not the placement's. Mixing the two here would silently re-crop every cell
- * whenever the canvas was resized.
- */
+* Tile the whole canvas with `count` cells, leaving no gap.
+*
+* Autofill exists because the useful answer to "put these four cameras up" is
+* almost never the one hand-dragging produces: rectangles land a pixel apart
+* and the composition shows black seams the operator cannot see in the editor
+* but will see in the stream.
+*
+* The shape is the near-square one — `ceil(sqrt(n))` columns — and a short last
+* row STRETCHES to the full width rather than leaving a hole. Three cameras
+* become two over one, not a 2x2 with an empty quarter, which is precisely the
+* layout autofill is asked to avoid.
+*
+* Aspect is deliberately not considered: these are CANVAS fractions, and what a
+* source shows inside its cell is the crop's business (the source rectangle),
+* not the placement's. Mixing the two here would silently re-crop every cell
+* whenever the canvas was resized.
+*/
 export declare function autofillCellRects(count: number): readonly GridNormalizedRect[];

package/dist/composites/cap-settings/event-thumb.d.ts

@@ -1,11 +1,12 @@
-export type ClipKind = 'motion' | 'object' | 'audio';
+import { type JSX } from "react";
+export type ClipKind = "motion" | "object" | "audio";
 interface EventThumbProps {
-    readonly mediaUrl?: string;
-    readonly kind: ClipKind;
+	readonly mediaUrl?: string;
+	readonly kind: ClipKind;
 }
-export declare function EventThumb({ mediaUrl, kind }: EventThumbProps): import("react").JSX.Element;
-export declare function EventKindIcon({ kind, large, }: {
-    readonly kind: ClipKind;
-    readonly large?: boolean;
-}): import("react").JSX.Element;
+export declare function EventThumb({ mediaUrl, kind }: EventThumbProps): JSX.Element;
+export declare function EventKindIcon({ kind, large }: {
+	readonly kind: ClipKind;
+	readonly large?: boolean;
+}): JSX.Element;
 export {};

package/dist/composites/cap-settings/index.d.ts

@@ -1,23 +1,23 @@
-export { AutotrackSection } from './AutotrackSection';
-export { ConsumablesPanel } from './ConsumablesPanel';
-export type { MaskShapeCanvasProps, MaskShapeItem } from './MaskShapeCanvas';
-export { MaskShapeCanvas } from './MaskShapeCanvas';
-export { MotionZonesSettings } from './MotionZonesSettings';
-export { PrivacyMaskSettings } from './PrivacyMaskSettings';
-export { NavigationPanel } from './NavigationPanel';
-export { PtzPanel } from './PtzPanel';
-export { RecordingBandsEditor } from './RecordingBandsEditor';
-export { RecordingPanel } from './RecordingPanel';
-export { RecordingSettings } from './RecordingSettings';
-export { SceneMonitorEditor } from './SceneMonitorEditor';
+export { AutotrackSection } from "./AutotrackSection";
+export { ConsumablesPanel } from "./ConsumablesPanel";
+export type { MaskShapeCanvasProps, MaskShapeItem } from "./MaskShapeCanvas";
+export { MaskShapeCanvas } from "./MaskShapeCanvas";
+export { MotionZonesSettings } from "./MotionZonesSettings";
+export { PrivacyMaskSettings } from "./PrivacyMaskSettings";
+export { NavigationPanel } from "./NavigationPanel";
+export { PtzPanel } from "./PtzPanel";
+export { RecordingBandsEditor } from "./RecordingBandsEditor";
+export { RecordingPanel } from "./RecordingPanel";
+export { RecordingSettings } from "./RecordingSettings";
+export { SceneMonitorEditor } from "./SceneMonitorEditor";
 /**
- * Props every cap-settings component receives.
- *
- * Components are resolved by `componentId` through the admin-ui
- * `UI_COMPONENTS` registry (the cap-name-keyed `CAP_SETTINGS_COMPONENTS`
- * registry has been retired). This shape mirrors the admin-ui
- * `UiComponentProps` contract.
- */
+* Props every cap-settings component receives.
+*
+* Components are resolved by `componentId` through the admin-ui
+* `UI_COMPONENTS` registry (the cap-name-keyed `CAP_SETTINGS_COMPONENTS`
+* registry has been retired). This shape mirrors the admin-ui
+* `UiComponentProps` contract.
+*/
 export interface CapSettingsComponentProps {
-    readonly deviceId: number;
+	readonly deviceId: number;
 }