@camstack/ui-library 0.1.57 → 0.2.0

package/dist/composites/addon-global-settings-form.d.ts

@@ -56,5 +56,5 @@ interface AddonGlobalSettingsFormProps {
      */
     readonly onOverrideChange?: (patch: Record<string, unknown>, effective: Record<string, unknown>) => void;
 }
-export declare function AddonGlobalSettingsForm({ trpc, addonId, nodeId, title, disabled, onAfterChange, refreshToken, collapsible, defaultOpen, mode, onOverrideChange, }: AddonGlobalSettingsFormProps): import("react/jsx-runtime").JSX.Element;
+export declare function AddonGlobalSettingsForm({ trpc, addonId, nodeId, title, disabled, onAfterChange, refreshToken, collapsible, defaultOpen, mode, onOverrideChange, }: AddonGlobalSettingsFormProps): import("react").JSX.Element;
 export {};

package/dist/composites/agent-step-editor.d.ts

@@ -12,4 +12,4 @@ export interface AgentStepEditorProps {
     readonly onChangePatch?: (next: CameraStepOverridePatch | null) => void;
     readonly engineFormat: string;
 }
-export declare function AgentStepEditor(props: AgentStepEditorProps): import("react/jsx-runtime").JSX.Element;
+export declare function AgentStepEditor(props: AgentStepEditorProps): import("react").JSX.Element;

package/dist/composites/app-shell/app-shell.d.ts

@@ -16,4 +16,4 @@ export interface AppShellProps {
     children: ReactNode;
     className?: string;
 }
-export declare function AppShell({ sidebar, header, mobileLogo, mobileActions, children, className }: AppShellProps): import("react/jsx-runtime").JSX.Element;
+export declare function AppShell({ sidebar, header, mobileLogo, mobileActions, children, className, }: AppShellProps): import("react").JSX.Element;

package/dist/composites/app-shell/sidebar-item.d.ts

@@ -7,4 +7,4 @@ export interface SidebarItemProps {
     active?: boolean;
     className?: string;
 }
-export declare function SidebarItem({ label, icon: Icon, href, badge, active, className, }: SidebarItemProps): import("react/jsx-runtime").JSX.Element;
+export declare function SidebarItem({ label, icon: Icon, href, badge, active, className, }: SidebarItemProps): import("react").JSX.Element;

package/dist/composites/app-shell/sidebar.d.ts

@@ -11,4 +11,4 @@ export interface SidebarProps {
     onNavigate?: () => void;
     className?: string;
 }
-export declare function Sidebar({ logo, sections, footer, onNavigate, className }: SidebarProps): import("react/jsx-runtime").JSX.Element;
+export declare function Sidebar({ logo, sections, footer, onNavigate, className }: SidebarProps): import("react").JSX.Element;

package/dist/composites/audio-classification-list.d.ts

@@ -17,4 +17,4 @@ export interface AudioClassificationListProps {
 /**
  * Displays audio classification results as a ranked list with score bars.
  */
-export declare function AudioClassificationList({ classifications, processing, inferenceMs, maxItems, className, }: AudioClassificationListProps): import("react/jsx-runtime").JSX.Element;
+export declare function AudioClassificationList({ classifications, processing, inferenceMs, maxItems, className, }: AudioClassificationListProps): import("react").JSX.Element;

package/dist/composites/audio-level-waveform.d.ts

@@ -32,4 +32,4 @@ export interface AudioLevelWaveformProps {
  * Designed to be fed from the `pipeline.audio-inference-result` event
  * (each chunk, ~0.5s, produces one sample via `frame.level.dbfs`).
  */
-export declare function AudioLevelWaveform({ currentDbfs, durationSec, maxSamples, height, className, color, clipColor, clipThreshold, minDbfs, }: AudioLevelWaveformProps): import("react/jsx-runtime").JSX.Element;
+export declare function AudioLevelWaveform({ currentDbfs, durationSec, maxSamples, height, className, color, clipColor, clipThreshold, minDbfs, }: AudioLevelWaveformProps): import("react").JSX.Element;

package/dist/composites/audio-waveform.d.ts

@@ -17,4 +17,4 @@ export interface AudioWaveformProps {
  * Renders a waveform from Float32Array audio samples.
  * Downsamples to pixel resolution for performance.
  */
-export declare function AudioWaveform({ samples, sampleRate, height, className, color, bgColor, }: AudioWaveformProps): import("react/jsx-runtime").JSX.Element;
+export declare function AudioWaveform({ samples, sampleRate, height, className, color, bgColor, }: AudioWaveformProps): import("react").JSX.Element;

package/dist/composites/battery-badge.d.ts

@@ -2,6 +2,9 @@ export interface BatteryStatusLike {
     readonly percentage: number;
     readonly charging: 'dc' | 'solar' | 'none';
     readonly sleeping: boolean;
+    /** True for a binary LOW_BAT source with no real % — render "Normal"/"Low"
+     *  instead of a misleading exact percentage. */
+    readonly binary?: boolean;
 }
 export interface BatteryBadgeProps {
     readonly status: BatteryStatusLike | null | undefined;
@@ -9,4 +12,4 @@ export interface BatteryBadgeProps {
     readonly variant?: 'compact' | 'full';
     readonly className?: string;
 }
-export declare function BatteryBadge({ status, variant, className }: BatteryBadgeProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function BatteryBadge({ status, variant, className }: BatteryBadgeProps): import("react").JSX.Element | null;

package/dist/composites/breadcrumb.d.ts

@@ -1,3 +1,4 @@
+import { default as React } from 'react';
 export interface BreadcrumbItem {
     /** Display label */
     label: string;
@@ -22,4 +23,4 @@ export interface BreadcrumbProps {
  * ]} />
  * ```
  */
-export declare function Breadcrumb({ items, className }: BreadcrumbProps): import("react/jsx-runtime").JSX.Element;
+export declare function Breadcrumb({ items, className }: BreadcrumbProps): React.JSX.Element;

package/dist/composites/camera-stream-player.d.ts

@@ -1,5 +1,35 @@
 import { ReactNode } from 'react';
+import { CamProfile } from '@camstack/types';
+type WebkitPresentationMode = 'inline' | 'picture-in-picture' | 'fullscreen';
+declare global {
+    interface HTMLVideoElement {
+        webkitSetPresentationMode?: (mode: WebkitPresentationMode) => void;
+        readonly webkitPresentationMode?: WebkitPresentationMode;
+    }
+}
 export type PlayerConnectionState = 'connecting' | 'playing' | 'error' | 'disconnected' | 'idle';
+/**
+ * Discriminated WebRTC target — same shape as `WebrtcStreamTarget` on the
+ * backend cap; the `profile` tier uses the canonical `CamProfile` enum.
+ * Carried by `getSessionState`'s `pendingRenegotiation` and handed back to
+ * `reoffer` verbatim during an adaptive re-offer.
+ */
+export type PlayerWebrtcTarget = {
+    readonly kind: 'adaptive';
+} | {
+    readonly kind: 'profile';
+    readonly profile: CamProfile;
+} | {
+    readonly kind: 'cam-stream';
+    readonly camStreamId: string;
+};
+/** Live signaling state polled mid-stream — the adaptive re-offer signal. */
+export interface SessionSignalingState {
+    readonly pendingRenegotiation: {
+        readonly target: PlayerWebrtcTarget;
+        readonly epoch: number;
+    } | null;
+}
 /**
  * Signaling function for WebRTC connection.
  * Called by the player to establish the WebRTC session.
@@ -72,6 +102,15 @@ export interface CameraStreamPlayerProps {
     muted?: boolean;
     /** Show toolbar controls (default: true) */
     showControls?: boolean;
+    /** Show a live client-side WebRTC stats overlay (bitrate/fps/res/RTT),
+     *  computed from the PeerConnection's getStats(). Default: false. */
+    showStats?: boolean;
+    /** DEBUG: when provided, polls inbound-video getStats() ~1 Hz during playback
+     *  and reports per-window health metrics (frames received/decoded/dropped,
+     *  freezes, jitter, playback-clock advance). The embed forwards these over the
+     *  existing host log bridge (`{type:'log'}`), so they respect the app's
+     *  debug-mode flag. Used to diagnose recorded VOD-over-WebRTC stutter. */
+    onPlaybackStats?: (data: Record<string, unknown>) => void;
     /** Additional CSS classes for the root container */
     className?: string;
     /** Called on connection state change */
@@ -101,7 +140,7 @@ export interface CameraStreamPlayerProps {
      * Main/High (incl. 4K) source pass through with NO transcode — the only
      * path that lets iOS decode High. The caller closes over the target.
      */
-    handleOffer?: (sdpOffer: string) => Promise<ClientOfferResult>;
+    handleOffer?: (sdpOffer: string, sessionId?: string) => Promise<ClientOfferResult>;
     /**
      * Fetch the browser-side ICE servers (STUN + TURN) for client-offer mode.
      * Called BEFORE the offer is built so a remote/CGNAT viewer can gather a
@@ -117,11 +156,64 @@ export interface CameraStreamPlayerProps {
     }>;
     /** Explicitly close the WebRTC session on server (cleanup on unmount). */
     closeSession?: (sessionId: string) => Promise<void>;
+    /**
+     * Poll the live signaling state of a session (client-offer mode only).
+     * After the server swaps the broker source to a different tier (adaptive
+     * downgrade), this returns a non-null `pendingRenegotiation` with the new
+     * target + a monotonic `epoch`. The player then transparently re-offers
+     * on the SAME sessionId — building a fresh PeerConnection in the
+     * background and only swapping the live `<video>` to the new stream once
+     * it delivers media, so the last decoded frame stays on screen with no
+     * loader. Best-effort: omit it to disable adaptive re-offer entirely.
+     */
+    getSessionState?: (sessionId: string) => Promise<SessionSignalingState>;
+    /**
+     * Re-offer signaling for an adaptive tier switch (client-offer mode).
+     * Posts a fresh browser-built offer for an EXISTING `sessionId` against
+     * the new `target` (from `getSessionState`'s `pendingRenegotiation`). The
+     * server closes the stale session and creates a fresh one under the same
+     * id, bound to the new tier's source. Distinct from `handleOffer`, whose
+     * target is fixed at the player's selected stream — a re-offer must carry
+     * the server-chosen downgrade target instead. Required (alongside
+     * `getSessionState`) for adaptive re-offer to run.
+     */
+    reoffer?: (sessionId: string, sdpOffer: string, target: PlayerWebrtcTarget) => Promise<ClientOfferResult>;
+    /**
+     * Optional poster image (snapshot data-URL) shown by the <video> before
+     * the FIRST-EVER frame is decoded. Only a cold-start fallback — once a
+     * frame is showing, the player keeps the last decoded frame across
+     * renegotiations and never falls back to the poster. Caller-supplied.
+     */
+    posterUrl?: string;
     /**
      * Override client hints sent to the server at session creation.
      * Values provided here replace the auto-computed browser values.
      * Use for network simulation (benchmark) or manual tier forcing.
      */
     hintsOverride?: Partial<ClientStreamHints>;
+    /**
+     * Host-driven fast reconnect. Bump this number (monotonic) to force a
+     * full reconnect WITHOUT remounting the player — used by the embed when
+     * the native shell detects a network change (Wi-Fi↔cellular) or returns
+     * from background. Because `cleanup()` no longer clears `srcObject`, the
+     * LAST DECODED FRAME stays on screen across the reconnect (no black
+     * flash, no covering loader). The initial value is ignored — only
+     * changes trigger a reconnect. Distinct from remounting via `streamKey`,
+     * which blanks the element.
+     */
+    reconnectSignal?: number;
+    /**
+     * Optional control data-channel hook (client-offer mode only). When
+     * provided, the player opens a `camstack-control` `RTCDataChannel` on the
+     * PeerConnection BEFORE building the offer (so it is negotiated into the
+     * m=application section) and hands the channel to this callback for each new
+     * connection. Used by the recorded-playback timeline embed to drive the
+     * broker's `TimelineSession` (seek / scrub-commit / play-rate / go-live) and
+     * receive server state/position over the SAME WebRTC session that carries the
+     * unified live-or-recorded `<video>` track. Omit it (the default) for a plain
+     * live player — no data channel is created and behaviour is unchanged.
+     */
+    onControlChannel?: (channel: RTCDataChannel) => void;
 }
-export declare function CameraStreamPlayer({ serverUrl, streamKey, label, autoPlay, muted: initialMuted, showControls, className, onStateChange, onError, overlay, createSession, sendAnswer, handleOffer, getIceServers, addIceCandidate, getIceCandidates, closeSession, hintsOverride, }: CameraStreamPlayerProps): import("react/jsx-runtime").JSX.Element;
+export declare function CameraStreamPlayer({ serverUrl, streamKey, label, autoPlay, muted: initialMuted, showControls, showStats, onPlaybackStats, className, onStateChange, onError, overlay, createSession, sendAnswer, handleOffer, getIceServers, addIceCandidate, getIceCandidates, closeSession, getSessionState, reoffer, posterUrl, hintsOverride, reconnectSignal, onControlChannel, }: CameraStreamPlayerProps): import("react").JSX.Element;
+export {};

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

@@ -1,5 +1,5 @@
 interface AutotrackSectionProps {
     readonly deviceId: number;
 }
-export declare function AutotrackSection({ deviceId }: AutotrackSectionProps): import("react/jsx-runtime").JSX.Element;
+export declare function AutotrackSection({ deviceId }: AutotrackSectionProps): import("react").JSX.Element;
 export {};

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

@@ -0,0 +1,2 @@
+import { CapSettingsComponentProps } from './index';
+export declare function ConsumablesPanel({ deviceId }: CapSettingsComponentProps): import("react").JSX.Element;

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

@@ -0,0 +1,12 @@
+import { PlaybackSpan } from './recording-spans';
+interface CoverageTrackProps {
+    readonly windowFrom: number;
+    readonly windowTo: number;
+    readonly spans: readonly PlaybackSpan[];
+    /** Last-seeked position to mark with the playhead, or null. */
+    readonly playheadMs: number | null;
+    /** Called with the absolute ms a click maps to within the window. */
+    readonly onSeek: (clickMs: number) => void;
+}
+export declare function CoverageTrack({ windowFrom, windowTo, spans, playheadMs, onSeek, }: CoverageTrackProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,25 @@
+import { ClipKind } from './event-thumb';
+export interface BucketClip {
+    readonly id: string;
+    readonly timestamp: number;
+    readonly kind: ClipKind;
+    readonly label: string;
+    readonly mediaUrl?: string;
+}
+interface EventBucketStripProps {
+    readonly clips: readonly BucketClip[];
+    readonly loading: boolean;
+    /** Key of the clip whose manifest is resolving, for the spinner. */
+    readonly busyKey: string | null;
+    readonly onPlay: (clip: BucketClip) => void;
+    /** Which kinds are currently enabled for display. */
+    readonly enabledKinds: ReadonlySet<ClipKind>;
+    /** Called when the user toggles a kind checkbox. */
+    readonly onToggleKind: (kind: ClipKind) => void;
+    /** True when more results may exist beyond the current page. */
+    readonly hasMore: boolean;
+    /** Called when the user clicks "Load more". */
+    readonly onLoadMore: () => void;
+}
+export declare function EventBucketStrip({ clips, loading, busyKey, onPlay, enabledKinds, onToggleKind, hasMore, onLoadMore, }: EventBucketStripProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import { DensityBucket } from './recording-timeline-model';
+interface EventHeatmapProps {
+    readonly windowFrom: number;
+    readonly windowTo: number;
+    readonly buckets: readonly DensityBucket[];
+    readonly selectedIndex: number | null;
+    readonly onSelectBucket: (index: number) => void;
+}
+export declare function EventHeatmap({ windowFrom, windowTo, buckets, selectedIndex, onSelectBucket, }: EventHeatmapProps): import("react").JSX.Element;
+export {};

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

@@ -38,7 +38,7 @@ export interface MaskShapeCanvasProps {
         readonly height: number;
     };
 }
-declare function MaskShapeCanvasImpl({ items, selectedId, onSelect, onShapeChange, onDrawComplete, drawingKind, supportedShapes, transparent, backdrop, polygonVertices, grid, }: MaskShapeCanvasProps): import("react/jsx-runtime").JSX.Element;
+declare function MaskShapeCanvasImpl({ items, selectedId, onSelect, onShapeChange, onDrawComplete, drawingKind, supportedShapes, transparent, backdrop, polygonVertices, grid, }: MaskShapeCanvasProps): import("react").JSX.Element;
 /**
  * Memoised export. The Konva scene is expensive to re-evaluate (many nodes per
  * item + per-item drag-bound closures) and overlay parents re-render on every

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

@@ -1,2 +1,2 @@
 import { CapSettingsComponentProps } from './index';
-export declare function MotionZonesSettings({ deviceId }: CapSettingsComponentProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function MotionZonesSettings({ deviceId }: CapSettingsComponentProps): import("react").JSX.Element | null;

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

@@ -1,2 +1,2 @@
 import { CapSettingsComponentProps } from './index';
-export declare function PrivacyMaskSettings({ deviceId }: CapSettingsComponentProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function PrivacyMaskSettings({ deviceId }: CapSettingsComponentProps): import("react").JSX.Element | null;

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

@@ -1,2 +1,2 @@
 import { CapSettingsComponentProps } from './index';
-export declare function PtzPanel({ deviceId }: CapSettingsComponentProps): import("react/jsx-runtime").JSX.Element;
+export declare function PtzPanel({ deviceId }: CapSettingsComponentProps): import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+import { HostWidgetProps } from '../../widgets/host-widgets';
+export declare function RecordingPanel({ deviceId }: HostWidgetProps): import("react").JSX.Element;

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

@@ -0,0 +1,7 @@
+import { RecordingRule } from '@camstack/types';
+interface RecordingRulesEditorProps {
+    readonly rules: readonly RecordingRule[];
+    readonly onChange: (rules: RecordingRule[]) => void;
+}
+export declare function RecordingRulesEditor({ rules, onChange }: RecordingRulesEditorProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,8 @@
+import { RecordingConfig } from '@camstack/types';
+interface RecordingSettingsProps {
+    readonly initial: RecordingConfig;
+    readonly saving: boolean;
+    readonly onSave: (config: RecordingConfig) => void;
+}
+export declare function RecordingSettings({ initial, saving, onSave }: RecordingSettingsProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,5 @@
+interface RecordingTimelineProps {
+    readonly deviceId: number;
+}
+export declare function RecordingTimeline({ deviceId }: RecordingTimelineProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+import { RecordingSchedule } from '@camstack/types';
+interface ScheduleBandsEditorProps {
+    readonly schedules: readonly RecordingSchedule[];
+    readonly onChange: (schedules: RecordingSchedule[]) => void;
+}
+export declare function ScheduleBandsEditor({ schedules, onChange }: ScheduleBandsEditorProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,21 @@
+import { 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;
+}
+/**
+ * Date selector + zoom-in / zoom-out buttons for the recording timeline.
+ * Zoom cycles through ZOOM_LEVELS (widest → narrowest), centred on the
+ * current view midpoint. Horizontal pan is wired via wheel events in
+ * RecordingTimeline directly.
+ */
+export declare function TimelineControls({ day, onDayChange, view, dayBounds, onViewChange, }: TimelineControlsProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+export type ClipKind = 'motion' | 'object' | 'audio';
+interface EventThumbProps {
+    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 {};

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

@@ -1,7 +1,11 @@
 export { PtzPanel } from './PtzPanel';
+export { ConsumablesPanel } from './ConsumablesPanel';
 export { AutotrackSection } from './AutotrackSection';
 export { MotionZonesSettings } from './MotionZonesSettings';
 export { PrivacyMaskSettings } from './PrivacyMaskSettings';
+export { RecordingPanel } from './RecordingPanel';
+export { RecordingSettings } from './RecordingSettings';
+export { RecordingRulesEditor } from './RecordingRulesEditor';
 export { MaskShapeCanvas } from './MaskShapeCanvas';
 export type { MaskShapeItem, MaskShapeCanvasProps } from './MaskShapeCanvas';
 /**

package/dist/composites/cap-settings/recording-config-form.d.ts

@@ -0,0 +1,34 @@
+import { RecordingRule, RecordingMode, RecordingConfig, RecordingStorageMode, RecordingSchedule, RecordingTriggers, RecordingRetention, CamProfile } from '@camstack/types';
+export declare function emptyRule(): RecordingRule;
+export declare function isTriggerMode(mode: RecordingMode): boolean;
+export declare function withRuleAt(rules: readonly RecordingRule[], index: number, patch: Partial<RecordingRule>): RecordingRule[];
+export declare function removeRuleAt(rules: readonly RecordingRule[], index: number): RecordingRule[];
+/**
+ * The editable shape of the Basic recording form: the authoritative `mode` plus
+ * its mode-specific parameters. `schedules` are the recording time-bands (empty
+ * = always); `triggers`/buffers apply to `events`. Never carries `rules` — Base
+ * is mode-authoritative and the backend compiles `rules` from `mode`.
+ */
+export interface RecordingFormState {
+    readonly mode: RecordingStorageMode;
+    readonly profiles?: readonly CamProfile[];
+    readonly segmentSeconds?: number;
+    readonly schedules: readonly RecordingSchedule[];
+    readonly triggers: RecordingTriggers;
+    readonly preBufferSec?: number;
+    readonly postBufferSec?: number;
+    readonly retention?: RecordingRetention;
+}
+/** Read a persisted/migrated config into the Basic form state. `mode` is read
+ *  directly; a legacy mode-less config falls back to continuous/off by `enabled`. */
+export declare function formStateFromConfig(cfg: RecordingConfig): RecordingFormState;
+/** Serialize the Basic form state back to the wire config. `enabled` is derived
+ *  from `mode`; `rules`/singular `schedule` are never emitted. Schedules,
+ *  triggers and buffers are preserved even when off so they survive a re-enable. */
+export declare function configFromFormState(state: RecordingFormState): RecordingConfig;
+/**
+ * A config is "advanced" when it carries `rules[]` that the backend could NOT
+ * cleanly collapse to a `mode` (the non-destructive `migrateRulesToMode` leaves
+ * `mode` absent). The settings UI opens such a config in the Advanced rules tab.
+ */
+export declare function isAdvancedConfig(cfg: RecordingConfig): boolean;

package/dist/composites/cap-settings/recording-spans.d.ts

@@ -0,0 +1,22 @@
+export interface AvailabilityRange {
+    readonly profile: string;
+    readonly startMs: number;
+    readonly endMs: number;
+}
+export interface PlaybackSpan {
+    readonly startMs: number;
+    readonly endMs: number;
+}
+/**
+ * Merge availability ranges (across every profile) into the union of distinct
+ * time windows, ascending by start. Overlapping or touching intervals coalesce;
+ * zero/negative-length inputs are dropped. Newest-first ordering is the caller's
+ * concern (it reverses for display).
+ */
+export declare function mergeAvailabilitySpans(ranges: readonly AvailabilityRange[]): PlaybackSpan[];
+/**
+ * Pick the right unit for a byte count and render it with a sensible number of
+ * significant digits (binary prefixes, matching recording sizes elsewhere).
+ * KB and up render one decimal under 100, none above; bytes never get a decimal.
+ */
+export declare function formatBytes(bytes: number): string;

package/dist/composites/cap-settings/recording-timeline-model.d.ts

@@ -0,0 +1,84 @@
+import { PlaybackSpan } from './recording-spans';
+/** Fixed heatmap bucket size: 15 minutes → 96 buckets over 24h. */
+export declare const BUCKET_MS: number;
+/** Event kinds the timeline understands. */
+export type TimelineKind = 'motion' | 'object' | 'audio';
+export interface DensityBucket {
+    readonly index: number;
+    readonly startMs: number;
+    readonly endMs: number;
+    readonly counts: Readonly<Record<TimelineKind, number>>;
+    readonly total: number;
+    /** Highest-count kind, or null when the bucket is empty. */
+    readonly dominant: TimelineKind | null;
+}
+/** Row returned by the server `getEventDensity` call (one per non-empty bucket). */
+export interface EventDensityRow {
+    readonly bucketStart: number;
+    readonly motion: number;
+    readonly object: number;
+    readonly audio: number;
+}
+/**
+ * Convert server-side density rows into `DensityBucket[]` for the timeline
+ * heatmap. Rows with total === 0 are skipped (defensive; server already omits
+ * them). Returns a sparse, ascending-by-index array — EventHeatmap positions
+ * each bar by `b.startMs` rather than array index, so gaps are fine.
+ */
+export declare function densityRowsToBuckets(rows: readonly EventDensityRow[], windowFrom: number, bucketMs: number): DensityBucket[];
+export interface SeekTarget {
+    readonly fromMs: number;
+    readonly toMs: number;
+}
+/**
+ * Resolve a playback window for a click at `clickMs` against recorded `spans`.
+ * Inside a span → play from the click to that span's end. In a gap / outside →
+ * snap to the WHOLE nearest span. No spans → null (nothing to play).
+ * `spans` are expected ascending by start (as `mergeAvailabilitySpans` returns).
+ */
+export declare function seekTargetForSpans(clickMs: number, spans: readonly PlaybackSpan[]): SeekTarget | null;
+/**
+ * Position `ms` inside the window `[fromMs, toMs]` as a clamped percentage
+ * (0–100). A zero/negative-width window yields 0. Callers use this for `left:`.
+ */
+export declare function pctForMs(ms: number, fromMs: number, toMs: number): number;
+/** A [fromMs, toMs) window spanning (at most) one calendar day. */
+export interface DayWindow {
+    readonly fromMs: number;
+    readonly toMs: number;
+}
+/**
+ * Build a DayWindow for the given calendar `date` using local time.
+ * For any day strictly in the past: `fromMs` = local midnight, `toMs` =
+ * next local midnight (exactly 24 h).
+ * For today (or any future day that contains `nowMs`): `toMs = nowMs` so the
+ * window never extends into the future.
+ */
+export declare function dayWindow(date: Date, nowMs: number): DayWindow;
+/** Available zoom levels in ms, from widest (24h) to narrowest (15 min). */
+export declare const ZOOM_LEVELS: readonly number[];
+/**
+ * Produce a `levelMs`-wide DayWindow centred on `centerMs`, clamped within
+ * `dayBounds`. If `levelMs >= dayBounds span`, returns `dayBounds` unchanged.
+ */
+export declare function zoomWindow(_current: DayWindow, dayBounds: DayWindow, levelMs: number, centerMs: number): DayWindow;
+/**
+ * Shift `win` by `deltaMs`, preserving width, clamped within `dayBounds`.
+ */
+export declare function panWindow(win: DayWindow, dayBounds: DayWindow, deltaMs: number): DayWindow;
+/**
+ * Choose a sensible heatmap bucket size for a visible span of `spanMs`,
+ * targeting ~96-120 buckets. Always picks from `BUCKET_CANDIDATES`.
+ */
+export declare function bucketMsForSpan(spanMs: number): number;
+/** One labelled tick on the time axis. */
+export interface AxisTick {
+    readonly pct: number;
+    readonly label: string;
+}
+/**
+ * Produce `count` evenly-spaced axis ticks spanning [fromMs, toMs].
+ * - `pct` is via pctForMs (first=0, last=100).
+ * - `label` is a localised HH:MM clock string.
+ */
+export declare function axisTicks(fromMs: number, toMs: number, count: number): AxisTick[];

package/dist/composites/code-block.d.ts

@@ -3,4 +3,4 @@ export interface CodeBlockProps {
     maxHeight?: number;
     className?: string;
 }
-export declare function CodeBlock({ children, maxHeight, className }: CodeBlockProps): import("react/jsx-runtime").JSX.Element;
+export declare function CodeBlock({ children, maxHeight, className }: CodeBlockProps): import("react").JSX.Element;

package/dist/composites/config-form-builder.d.ts

@@ -14,5 +14,5 @@ interface FormBuilderProps {
     /** Callback to clear a probe result when a field value changes */
     onClearProbe?: (key: string) => void;
 }
-export declare function ConfigFormBuilder({ schema, values, onChange, disabled, translationFn, onTestField, probeResults, onClearProbe }: FormBuilderProps): import("react/jsx-runtime").JSX.Element;
+export declare function ConfigFormBuilder({ schema, values, onChange, disabled, translationFn, onTestField, probeResults, onClearProbe, }: FormBuilderProps): import("react").JSX.Element;
 export {};

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

@@ -44,14 +44,14 @@ export declare function NodeSelectField({ field, value, onChange, disabled, tran
     onChange: (v: unknown) => void;
     disabled?: boolean;
     translationFn?: TranslationFn;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export declare function NodeMultiSelectField({ field, value, onChange, disabled, translationFn, }: {
     field: ConfigNodeMultiSelectField;
     value: unknown;
     onChange: (v: unknown) => void;
     disabled?: boolean;
     translationFn?: TranslationFn;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 /**
  * Resolve a `ConfigCondition` against the form's flat values bag and the
  * sibling-field list (used to recover schema defaults when the
@@ -66,5 +66,5 @@ export declare function NodeMultiSelectField({ field, value, onChange, disabled,
  * rendered without instantiating a React subtree.
  */
 export declare function isFieldVisible(field: ConfigField, values: Record<string, unknown>, allFields?: readonly ConfigField[]): boolean;
-export declare function FormField({ field, values, onChange, disabled, translationFn, onTestField, externalProbe, allFields, onAction }: FormFieldProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function FormField({ field, values, onChange, disabled, translationFn, onTestField, externalProbe, allFields, onAction, }: FormFieldProps): import("react").JSX.Element | null;
 export { FormField as ConfigFormField };

package/dist/composites/confirm-action-button.d.ts

@@ -38,4 +38,4 @@ export interface ConfirmActionButtonProps<TResult> {
     /** Called after `action` resolves, with the result. */
     readonly onSuccess?: (result: TResult) => void;
 }
-export declare function ConfirmActionButton<TResult>({ label, icon: Icon, title, description, confirmLabel, triggerVariant, confirmVariant, size, disabled, className, action, onSuccess, }: ConfirmActionButtonProps<TResult>): import("react/jsx-runtime").JSX.Element;
+export declare function ConfirmActionButton<TResult>({ label, icon: Icon, title, description, confirmLabel, triggerVariant, confirmVariant, size, disabled, className, action, onSuccess, }: ConfirmActionButtonProps<TResult>): import("react").JSX.Element;

package/dist/composites/confirm-dialog.d.ts

@@ -9,5 +9,5 @@ interface ConfirmOptions {
 export declare function useConfirm(): (options: ConfirmOptions) => Promise<boolean>;
 export declare function ConfirmDialogProvider({ children }: {
     children: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export {};

package/dist/composites/data-table/data-table-header.d.ts

@@ -6,5 +6,5 @@ interface DataTableHeaderProps<T> {
     stickyHeader?: boolean;
     flexRender: typeof flexRender;
 }
-export declare function DataTableHeader<T>({ headerGroups, onSortingChange, stickyHeader, flexRender: render, }: DataTableHeaderProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTableHeader<T>({ headerGroups, onSortingChange, stickyHeader, flexRender: render, }: DataTableHeaderProps<T>): import("react").JSX.Element;
 export {};

package/dist/composites/data-table/data-table-pagination.d.ts

@@ -5,5 +5,5 @@ interface DataTablePaginationProps {
     total: number;
     onPaginationChange?: (pagination: PaginationState) => void;
 }
-export declare function DataTablePagination({ page, pageSize, total, onPaginationChange, }: DataTablePaginationProps): import("react/jsx-runtime").JSX.Element;
+export declare function DataTablePagination({ page, pageSize, total, onPaginationChange, }: DataTablePaginationProps): import("react").JSX.Element;
 export {};

package/dist/composites/data-table/data-table-row.d.ts

@@ -6,5 +6,5 @@ interface DataTableRowProps<T> {
     rowActions?: (row: T) => DataTableAction[];
     flexRender: typeof flexRender;
 }
-export declare function DataTableRow<T>({ row, onRowClick, rowActions, flexRender: render, }: DataTableRowProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTableRow<T>({ row, onRowClick, rowActions, flexRender: render, }: DataTableRowProps<T>): import("react").JSX.Element;
 export {};

package/dist/composites/data-table/data-table.d.ts

@@ -1,2 +1,2 @@
 import { DataTableProps } from './types';
-export declare function DataTable<T>({ data, columns: userColumns, sorting, onSortingChange, filtering, onFilteringChange, pagination, onPaginationChange, loading, emptyState, rowActions, onRowClick, selectable, compact, stickyHeader, className, mobileMode, }: DataTableProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTable<T>({ data, columns: userColumns, sorting, onSortingChange, filtering, onFilteringChange, pagination, onPaginationChange, loading, emptyState, rowActions, onRowClick, selectable, compact, stickyHeader, className, mobileMode, }: DataTableProps<T>): import("react").JSX.Element;