@camstack/ui-library 1.2.256 → 1.2.258

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

@@ -1,5 +1,22 @@
+/**
+* Autotrack settings card — rendered inside the PTZ panel when the
+* device has `DeviceFeature.PtzAutotrack`. Three knobs (cross-vendor
+* schema): target type, stop delay, disappear delay, plus an enable /
+* disable toggle that drives the `ptz-autotrack` cap directly.
+*
+* Save semantics:
+*   - Toggle (enable/disable) calls `setEnabled` immediately.
+*   - Form fields debounce-save on blur — no explicit Save button.
+*
+* Vendor capability hints:
+*   - The cap's status carries `currentSettings` from the camera's
+*     own GET; rendered on every poll so the operator sees what's
+*     really applied vs what they typed.
+*   - When the firmware ignored a setting, the field stays editable.
+*/
+import { type JSX } from "react";
 interface AutotrackSectionProps {
-    readonly deviceId: number;
+	readonly deviceId: number;
 }
-export declare function AutotrackSection({ deviceId }: AutotrackSectionProps): import("react").JSX.Element;
+export declare function AutotrackSection({ deviceId }: AutotrackSectionProps): JSX.Element;
 export {};

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

@@ -1,4 +1,26 @@
+/**
+* The camera-grid layout editor.
+*
+* A grid's geometry is the one thing a DERIVED settings form cannot express: a
+* generated form renders "cell 1 source = 592, cell 1 crop x = 0.25, cell 1 crop
+* width = 0.5…" and nobody can hold a picture in their head from that. So the
+* geometry gets a widget — the canvas, drawn at the grid's own aspect ratio,
+* with the cells on it — while the knobs that ARE ordinary fields (the name,
+* the canvas size, the frame rate) sit beside it in the same panel.
+*
+* Every rectangle in here is NORMALIZED [0,1], on both sides: the crop taken
+* out of a source, and the cell it lands in. That is how the addon stores them
+* (a source camera can change resolution, and a stored pixel rectangle would
+* quietly start cutting the wrong region), so the editor speaks the same
+* language rather than converting at the boundary.
+*
+* The preview is the source cameras' own snapshots, positioned by CSS from the
+* SAME normalized numbers that will become the ffmpeg `crop`/`overlay`. It costs
+* the server nothing and it is wrong in exactly the ways the real composition
+* would be wrong.
+*/
+import { type JSX } from "react";
 export interface CameraGridLayoutEditorProps {
-    readonly deviceId: number;
+	readonly deviceId: number;
 }
-export declare function CameraGridLayoutEditor({ deviceId }: CameraGridLayoutEditorProps): import("react").JSX.Element;
+export declare function CameraGridLayoutEditor({ deviceId }: CameraGridLayoutEditorProps): JSX.Element;

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

@@ -1,2 +1,21 @@
-import { CapSettingsComponentProps } from './index';
-export declare function ConsumablesPanel({ deviceId }: CapSettingsComponentProps): import("react").JSX.Element;
+/**
+* ConsumablesPanel — maintenance-items surface for the generic
+* `consumables` capability. A cap-settings component (ui-library),
+* mounted as a cap-contributed top-level device-detail tab via the
+* cap-UI contribution mechanism (the `consumables` cap declares
+* `ui: { kind:'widget', widgetId:'host/consumables-panel', tab:'consumables', topTab:true, ... }`).
+*
+* Reads the cap's pushed runtime-state slice via `useDeviceCapability`
+* and renders one row per item: a fill bar + percentage when `level` is
+* known, else an `ok`/`replace` status pill when `status` is known, else
+* a muted em-dash. When a provider also reports `remaining` (a count in
+* days/hours/cycles), its value is shown alongside — `null` renders a
+* muted em-dash, never a fake `0` (D393); absent `remaining` renders
+* nothing, exactly as before this field existed. A per-item "Replaced"
+* button calls `cap.reset` when the item is `resettable`. The cap is
+* inert until a provider sets items — an empty list renders a muted
+* placeholder.
+*/
+import { type JSX } from "react";
+import type { CapSettingsComponentProps } from "./index";
+export declare function ConsumablesPanel({ deviceId }: CapSettingsComponentProps): JSX.Element;

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

@@ -1,23 +1,24 @@
-import { PlaybackSpan } from './recording-spans';
+import { type JSX } from "react";
+import type { 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;
-    /**
-     * Drag-scrub callbacks (R9, frame-push mode). When `onScrubEnd` is
-     * provided the track switches to pointer-driven scrubbing: pointer-down
-     * begins a drag, moves report the hovered epoch, release commits it —
-     * a motionless press+release behaves like a seek. `onSeek` is then
-     * suppressed (the pointer flow owns the gesture). Omit all three for the
-     * classic click-to-seek behaviour.
-     */
-    readonly onScrubStart?: () => void;
-    readonly onScrubMove?: (ms: number) => void;
-    readonly onScrubEnd?: (ms: number) => void;
+	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;
+	/**
+	* Drag-scrub callbacks (R9, frame-push mode). When `onScrubEnd` is
+	* provided the track switches to pointer-driven scrubbing: pointer-down
+	* begins a drag, moves report the hovered epoch, release commits it —
+	* a motionless press+release behaves like a seek. `onSeek` is then
+	* suppressed (the pointer flow owns the gesture). Omit all three for the
+	* classic click-to-seek behaviour.
+	*/
+	readonly onScrubStart?: () => void;
+	readonly onScrubMove?: (ms: number) => void;
+	readonly onScrubEnd?: (ms: number) => void;
 }
-export declare function CoverageTrack({ windowFrom, windowTo, spans, playheadMs, onSeek, onScrubStart, onScrubMove, onScrubEnd, }: CoverageTrackProps): import("react").JSX.Element;
+export declare function CoverageTrack({ windowFrom, windowTo, spans, playheadMs, onSeek, onScrubStart, onScrubMove, onScrubEnd }: CoverageTrackProps): JSX.Element | null;
 export {};

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

@@ -1,25 +1,26 @@
-import { ClipKind } from './event-thumb';
+import { type ClipKind } from "./event-thumb";
+import { type JSX } from "react";
 export interface BucketClip {
-    readonly id: string;
-    readonly timestamp: number;
-    readonly kind: ClipKind;
-    readonly label: string;
-    readonly mediaUrl?: string;
+	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;
+	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 declare function EventBucketStrip({ clips, loading, busyKey, onPlay, enabledKinds, onToggleKind, hasMore, onLoadMore }: EventBucketStripProps): JSX.Element;
 export {};

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

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

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

@@ -1,6 +1,6 @@
-import { UsePTZResult } from '../../hooks/use-ptz';
+import type { UsePTZResult } from "../../hooks/use-ptz";
 interface HomePresetPickerProps {
-    readonly controls: UsePTZResult;
+	readonly controls: UsePTZResult;
 }
 export declare function HomePresetPicker({ controls }: HomePresetPickerProps): React.ReactElement | null;
 export {};

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

@@ -1,48 +1,150 @@
-import { ReactNode } from 'react';
-import { MaskShape, MaskShapeKind } from '@camstack/types';
+/**
+* MaskShapeCanvas — ONE shared, Konva-based on-frame "drawing plane" editor
+* that handles ALL four `MaskShape` kinds: `rect`, `polygon`, `grid`, `line`.
+*
+* It is a generalization of the detection `ZoneCanvas` (orchestrator) so that
+* privacy-mask (rect/polygon), motion-zones (grid), and the
+* pipeline-orchestrator zones/lines editor can eventually all share a single
+* editor instead of three bespoke ones. Every coordinate is normalized 0..1 of
+* the camera frame (top-left origin), like every existing on-frame editor.
+*
+* ─────────────────────────────────────────────────────────────────────────────
+* Behaviours ported (the references are NOT edited — this generalizes them):
+*
+*   - From `ZoneCanvas` (orchestrator zone-editor):
+*       • ResizeObserver-sized `<Stage>`, `transparent` absolute-fill overlay
+*         mode for layering over a stream player, optional `backdrop` slot,
+*         pointer-events pass-through while not editing.
+*       • polygon draw / vertex-drag / body-drag with optimistic local override
+*         + the `useEffect` that drops the override once the controlled prop
+*         echoes the commit back, the rAF-throttled cursor ghost-line preview,
+*         the `Arrow` tripwire, and the memoised export.
+*   - From `PrivacyMaskCanvas`:
+*       • rect move + bottom-right-handle resize with 0..1 clamp, polygon
+*         vertex add (edge midpoint) / remove (✕, gated by min/max), and the
+*         `polygonVertices` {min,max} gate (e.g. Hikvision {min:4,max:4}).
+*   - From `MotionGridCanvas`:
+*       • grid cell-paint gesture (press-drag paints every touched cell to the
+*         value the first-touched cell flipped to), row-major `cells`.
+*
+* ─────────────────────────────────────────────────────────────────────────────
+* Usage — each consumer maps its own model onto `MaskShapeItem[]` and gates the
+* editor with `supportedShapes`:
+*
+* @example privacy-mask (rect + polygon)
+* ```tsx
+* const items: MaskShapeItem[] = regions.map((r) => ({ id: r.id, shape: r.shape }))
+* <MaskShapeCanvas
+*   transparent
+*   items={items}
+*   supportedShapes={['rect', 'polygon']}
+*   polygonVertices={options.polygonVertices}        // Hikvision {min:4,max:4}
+*   selectedId={selectedId}
+*   onSelect={setSelectedId}
+*   onShapeChange={(id, shape) =>
+*     onRegionsChange(regions.map((r) => (r.id === id ? { ...r, shape } : r)))}
+*   onDrawComplete={(shape) => onRegionsChange([...regions, { id: nextId(), shape }])}
+*   drawingKind={drawing ? 'rect' : null}
+* />
+* ```
+*
+* @example motion-zones (grid)
+* ```tsx
+* const items: MaskShapeItem[] = [{
+*   id: 'motion',
+*   shape: { kind: 'grid', gridWidth: w, gridHeight: h, cells },
+* }]
+* <MaskShapeCanvas
+*   transparent
+*   items={items}
+*   supportedShapes={['grid']}
+*   grid={{ width: w, height: h }}
+*   selectedId="motion"
+*   onSelect={() => {}}
+*   onShapeChange={(_id, shape) => {
+*     if (shape.kind === 'grid') onCellsChange(shape.cells)
+*   }}
+*   onDrawComplete={() => {}}
+*   drawingKind={null}
+* />
+* ```
+*
+* @example orchestrator (polygon + line/tripwire)
+* ```tsx
+* const items: MaskShapeItem[] = zones.map((z) => ({
+*   id: z.id,
+*   label: z.name,
+*   color: z.color,
+*   shape: z.kind === 'tripwire'
+*     ? { kind: 'line', points: z.points }
+*     : { kind: 'polygon', points: z.points },
+* }))
+* <MaskShapeCanvas
+*   transparent
+*   items={items}
+*   supportedShapes={['polygon', 'line']}
+*   selectedId={selectedZoneId}
+*   onSelect={onSelectZone}
+*   onShapeChange={(id, shape) => {
+*     if (shape.kind === 'polygon' || shape.kind === 'line')
+*       onZonePointsChange(id, shape.points)
+*   }}
+*   onDrawComplete={(shape) => onZoneComplete(shape)}
+*   drawingKind={drawingKind === 'tripwire' ? 'line' : drawingKind}
+*   backdrop={<CameraStreamPlayer ... />}
+* />
+* ```
+*
+* Purely controlled — the parent owns the truth. Every edit fires
+* `onShapeChange(id, shape)` (or `onDrawComplete(shape)` for a freshly-drawn
+* shape) with a brand-new immutable shape object; points and cells are never
+* mutated in place.
+*/
+import { type JSX, type MemoExoticComponent, type ReactNode } from "react";
+import type { MaskShape, MaskShapeKind } from "@camstack/types";
 /** One editable item on the drawing plane. */
 export interface MaskShapeItem {
-    readonly id: string | number;
-    readonly shape: MaskShape;
-    /** Small text label rendered near the shape. */
-    readonly label?: string;
-    /** Stroke/fill color. Falls back to a sensible per-kind default. */
-    readonly color?: string;
-    /** `false` → rendered dimmed (and skipped for hit-testing of editing chrome). */
-    readonly enabled?: boolean;
+	readonly id: string | number;
+	readonly shape: MaskShape;
+	/** Small text label rendered near the shape. */
+	readonly label?: string;
+	/** Stroke/fill color. Falls back to a sensible per-kind default. */
+	readonly color?: string;
+	/** `false` → rendered dimmed (and skipped for hit-testing of editing chrome). */
+	readonly enabled?: boolean;
 }
 export interface MaskShapeCanvasProps {
-    readonly items: MaskShapeItem[];
-    readonly selectedId: string | number | null;
-    readonly onSelect: (id: string | number | null) => void;
-    /** Fired on every edit (controlled — parent owns truth, immutable updates). */
-    readonly onShapeChange: (id: string | number, shape: MaskShape) => void;
-    /** Fired when a new shape is finished while drawing. */
-    readonly onDrawComplete: (shape: MaskShape) => void;
-    /** When set, clicks draw a new shape of that kind. */
-    readonly drawingKind: MaskShapeKind | null;
-    /** Which kinds this mount allows. */
-    readonly supportedShapes: readonly MaskShapeKind[];
-    /** Transparent absolute-fill overlay mode (layer over a stream player). */
-    readonly transparent?: boolean;
-    /** Backdrop element rendered behind the Stage in standalone mode. */
-    readonly backdrop?: ReactNode;
-    /** Gate polygon vertex add/remove (e.g. Hikvision {min:4,max:4}). */
-    readonly polygonVertices?: {
-        readonly min: number;
-        readonly max: number;
-    };
-    /** Grid dims when drawing/seeding a `grid` shape. */
-    readonly grid?: {
-        readonly width: number;
-        readonly height: number;
-    };
+	readonly items: MaskShapeItem[];
+	readonly selectedId: string | number | null;
+	readonly onSelect: (id: string | number | null) => void;
+	/** Fired on every edit (controlled — parent owns truth, immutable updates). */
+	readonly onShapeChange: (id: string | number, shape: MaskShape) => void;
+	/** Fired when a new shape is finished while drawing. */
+	readonly onDrawComplete: (shape: MaskShape) => void;
+	/** When set, clicks draw a new shape of that kind. */
+	readonly drawingKind: MaskShapeKind | null;
+	/** Which kinds this mount allows. */
+	readonly supportedShapes: readonly MaskShapeKind[];
+	/** Transparent absolute-fill overlay mode (layer over a stream player). */
+	readonly transparent?: boolean;
+	/** Backdrop element rendered behind the Stage in standalone mode. */
+	readonly backdrop?: ReactNode;
+	/** Gate polygon vertex add/remove (e.g. Hikvision {min:4,max:4}). */
+	readonly polygonVertices?: {
+		readonly min: number;
+		readonly max: number;
+	};
+	/** Grid dims when drawing/seeding a `grid` shape. */
+	readonly grid?: {
+		readonly width: number;
+		readonly height: number;
+	};
 }
-declare function MaskShapeCanvasImpl({ items, selectedId, onSelect, onShapeChange, onDrawComplete, drawingKind, supportedShapes, transparent, backdrop, polygonVertices, grid, }: MaskShapeCanvasProps): import("react").JSX.Element;
+declare function MaskShapeCanvasImpl({ items, selectedId, onSelect, onShapeChange, onDrawComplete, drawingKind, supportedShapes, transparent, backdrop, polygonVertices, grid }: MaskShapeCanvasProps): 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
- * detection/motion event. Mirrors ZoneCanvas's `memo`.
- */
-export declare const MaskShapeCanvas: import('react').MemoExoticComponent<typeof MaskShapeCanvasImpl>;
+* 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
+* detection/motion event. Mirrors ZoneCanvas's `memo`.
+*/
+export declare const MaskShapeCanvas: MemoExoticComponent<typeof MaskShapeCanvasImpl>;
 export {};

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

@@ -1,2 +1,41 @@
-import { CapSettingsComponentProps } from './index';
-export declare function MotionZonesSettings({ deviceId }: CapSettingsComponentProps): import("react").JSX.Element | null;
+/**
+* MotionZonesSettings — management surface for the on-camera
+* `motion-zones` capability. A cap-settings component (ui-library),
+* mounted into the device-detail Config tab via the cap-UI
+* contribution mechanism (the `motion-zones` cap declares a `ui` block).
+*
+* The on-camera motion mask is a SINGLE `grid` region in the shared
+* MaskShape vocabulary (a row-major boolean cell lattice). This component
+* owns its own control panel (Edit toggle, All on / All off / Invert,
+* count, Revert, Save) and paints the editable lattice over the live frame
+* with the shared `MaskShapeCanvas` drawing-plane — registered as a
+* player-overlay layer ONLY while "Edit grid" is toggled on (OFF by
+* default — nothing draws on mount).
+*
+* Detection enable + sensitivity are NOT edited here — they are the
+* camera's on-board motion master switch, owned by the driver's
+* "On-camera motion" settings section. Saving sends a `cells`-only patch
+* (one grid region); enable / sensitivity are left untouched camera-side.
+*
+* ── Resizable input grid (resampled to the camera grid on save) ──────────────
+* The camera's native motion grid (`getOptions().grid`, e.g. 22×18) is the
+* FINEST resolution that round-trips — painting finer than it can't be stored
+* (not reconstructible). So the camera grid is the FLOOR (×1) and the operator
+* picks BIGGER cells: an integer cell-size multiplier (×1/×2/×3) where a UI cell
+* spans an m×m block of camera cells (×2 → quarter as many, ×3 → ninth). The
+* CAMERA grid stays authoritative:
+*   - LOAD: the camera grid is COARSENED into the chosen UI resolution (a UI
+*     cell is `true` if ANY camera cell in its block is painted) so existing
+*     masks display on the bigger-celled surface.
+*   - SAVE: the UI grid is EXPANDED back to camera gridWidth×gridHeight — every
+*     camera cell takes the value of the UI cell whose block covers it.
+* At ×1 both transforms are the identity, so the camera-grid round-trip is
+* exact; at higher multipliers `coarsen(expand(uiCells)) === uiCells`, so an
+* edit made at the chosen resolution survives the round-trip exactly. The
+* component's draft (`uiCells`) lives at the UI resolution; the last-saved truth
+* (`committedCamera`) and every comparison stay anchored to the camera-native
+* grid so `dirty`/Save/Revert math is resolution-independent.
+*/
+import { type JSX } from "react";
+import type { CapSettingsComponentProps } from "./index";
+export declare function MotionZonesSettings({ deviceId }: CapSettingsComponentProps): JSX.Element | null;

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

@@ -1,2 +1,14 @@
-import { CapSettingsComponentProps } from './index';
-export declare function NavigationPanel({ deviceId }: CapSettingsComponentProps): import("react").JSX.Element;
+/**
+* NavigationPanel — the `navigation` cap's own panel (`host/navigation-panel`):
+* a drive pad, the data-driven action and sound buttons, the fill light.
+*
+* Nothing here knows a vendor: the buttons come from `listActions()` (enabled
+* entries only, icons mapped from the entry's lucide hint), the primitives
+* from `getFeatures()`, and the live chips from the `navigation` slice. Hold
+* a drive button to move — the hook nudges at 1 Hz and stops on release, like
+* the robot app's joystick. The manual level slider appears only in manual
+* mode, as the cap's own contract asks.
+*/
+import { type JSX } from "react";
+import type { CapSettingsComponentProps } from "./index";
+export declare function NavigationPanel({ deviceId }: CapSettingsComponentProps): JSX.Element;

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

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

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

@@ -1,2 +1,15 @@
-import { CapSettingsComponentProps } from './index';
-export declare function PtzPanel({ deviceId }: CapSettingsComponentProps): import("react").JSX.Element;
+/**
+* PtzPanel — live pan/tilt/zoom controls for the `ptz` capability. A
+* cap-settings component (ui-library), mounted as a cap-contributed
+* top-level device-detail tab via the cap-UI contribution mechanism
+* (the `ptz` cap declares `ui: { tab: 'ptz', kind: 'static', ... }`).
+*
+* Consolidates the former admin-ui `PTZPanelContent`: `usePTZ` drives
+* the controls, `PTZOverlay` renders them (`mode='panel'`), and an
+* Autofocus toggle is shown only when `getOptions().hasAutofocus`.
+* Autotrack is its own cap-UI contribution (`ptz-autotrack`), mounted
+* independently by the contribution mechanism — not nested here.
+*/
+import { type JSX } from "react";
+import type { CapSettingsComponentProps } from "./index";
+export declare function PtzPanel({ deviceId }: CapSettingsComponentProps): JSX.Element | null;

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

@@ -1,40 +1,41 @@
-import { RecordingBand } from '@camstack/types';
+import type { JSX } from "react";
+import type { RecordingBand } from "@camstack/types";
 interface RecordingBandsEditorProps {
-    readonly bands: readonly RecordingBand[];
-    readonly onChange: (bands: RecordingBand[]) => void;
-    /** Present when the host knows the camera — enables the sensor picker on events bands. */
-    readonly sensorContext?: RecordingSensorContext;
+	readonly bands: readonly RecordingBand[];
+	readonly onChange: (bands: RecordingBand[]) => void;
+	/** Present when the host knows the camera — enables the sensor picker on events bands. */
+	readonly sensorContext?: RecordingSensorContext;
 }
 /**
- * The band table — the ONLY authoring surface for recording intent since the
- * legacy mode/schedules/triggers/rules model was retired (2026-07-30).
- *
- * Each row is one `RecordingBand`: when it applies (weekdays + `HH:MM` span,
- * `end <= start` wraps past midnight) and how it records (continuous, or events
- * with its own triggers and pre/post buffers). No band covering *now* = nothing
- * is recorded then; "off" is the absence of a band, never a band value.
- */
-export declare function RecordingBandsEditor({ bands, onChange, sensorContext, }: RecordingBandsEditorProps): import("react").JSX.Element;
+* The band table — the ONLY authoring surface for recording intent since the
+* legacy mode/schedules/triggers/rules model was retired (2026-07-30).
+*
+* Each row is one `RecordingBand`: when it applies (weekdays + `HH:MM` span,
+* `end <= start` wraps past midnight) and how it records (continuous, or events
+* with its own triggers and pre/post buffers). No band covering *now* = nothing
+* is recorded then; "off" is the absence of a band, never a band value.
+*/
+export declare function RecordingBandsEditor({ bands, onChange, sensorContext }: RecordingBandsEditorProps): JSX.Element;
 /**
- * The camera a band belongs to, for the sensor picker: its own id is never a
- * sensor of itself, and its location is what the picker suggests first.
- */
+* The camera a band belongs to, for the sensor picker: its own id is never a
+* sensor of itself, and its location is what the picker suggests first.
+*/
 export interface RecordingSensorContext {
-    readonly cameraId: number;
-    readonly location: string | null;
-    /**
-     * Does this camera publish its own `recording-signal` — the LEVEL the
-     * `on-device-decision` MODE follows (D380)? Asked of the camera's bindings by
-     * the host, and read by `RecordingSettings` to decide whether that mode can
-     * be picked. It is no longer a band trigger: a band is an HOUR, and this
-     * feature has none to program. Absent = the host did not ask.
-     */
-    readonly deviceSignal?: DeviceSignalPresence;
+	readonly cameraId: number;
+	readonly location: string | null;
+	/**
+	* Does this camera publish its own `recording-signal` — the LEVEL the
+	* `on-device-decision` MODE follows (D380)? Asked of the camera's bindings by
+	* the host, and read by `RecordingSettings` to decide whether that mode can
+	* be picked. It is no longer a band trigger: a band is an HOUR, and this
+	* feature has none to program. Absent = the host did not ask.
+	*/
+	readonly deviceSignal?: DeviceSignalPresence;
 }
 /**
- * What the host knows about the camera's `recording-signal` binding. Four
- * states, not a boolean (D315): `pending` and `unknown` must render as
- * "not yet known", never as "this camera has no signal".
- */
-export type DeviceSignalPresence = 'pending' | 'present' | 'absent' | 'unknown';
+* What the host knows about the camera's `recording-signal` binding. Four
+* states, not a boolean (D315): `pending` and `unknown` must render as
+* "not yet known", never as "this camera has no signal".
+*/
+export type DeviceSignalPresence = "pending" | "present" | "absent" | "unknown";
 export {};

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

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

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

@@ -1,13 +1,14 @@
-import { RecordingConfig, CamProfile } from '@camstack/types';
-import { RecordingSensorContext } from './RecordingBandsEditor';
+import { type JSX } from "react";
+import type { RecordingConfig, CamProfile } from "@camstack/types";
+import { type RecordingSensorContext } from "./RecordingBandsEditor";
 interface RecordingSettingsProps {
-    readonly initial: RecordingConfig;
-    /** Broker-assigned profile slots for this camera (already deduped). */
-    readonly availableProfiles: readonly CamProfile[];
-    readonly saving: boolean;
-    readonly onSave: (config: RecordingConfig) => void;
-    /** The camera this config belongs to — enables the sensor picker on events bands. */
-    readonly sensorContext?: RecordingSensorContext;
+	readonly initial: RecordingConfig;
+	/** Broker-assigned profile slots for this camera (already deduped). */
+	readonly availableProfiles: readonly CamProfile[];
+	readonly saving: boolean;
+	readonly onSave: (config: RecordingConfig) => void;
+	/** The camera this config belongs to — enables the sensor picker on events bands. */
+	readonly sensorContext?: RecordingSensorContext;
 }
-export declare function RecordingSettings({ initial, availableProfiles, saving, onSave, sensorContext, }: RecordingSettingsProps): import("react").JSX.Element;
+export declare function RecordingSettings({ initial, availableProfiles, saving, onSave, sensorContext }: RecordingSettingsProps): JSX.Element | null;
 export {};

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

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