@camstack/ui-library 1.2.256 → 1.2.258

package/dist/hooks/use-device-battery.d.ts

@@ -1,16 +1,29 @@
-import { BatteryStatus } from '@camstack/types';
-import { UseDeviceProxyTrpc } from './use-device-proxy';
 /**
- * The cap's own runtime-state shape (`z.infer<BatteryStatusSchema>`) —
- * `percentage` is `number | null`: `null` means no reading has landed yet
- * (D315). Re-exported so call sites don't have to reach into
- * `@camstack/types` themselves.
- */
+* useDeviceBattery — battery status for a device.
+*
+* Thin wrapper over the `useDeviceState` combinator, which itself
+* wraps `useDeviceProxy + useDeviceStateSlice(dev?.state.battery)`.
+* The kernel runtime-state mirror keeps the slice value warm — one
+* initial fetch on first subscribe, then push updates on every
+* `setCapSlice` for the battery slice. No manual event subscription,
+* no parallel `getStatus` polling.
+*
+* Returns `null` when no provider has emitted yet (non-battery
+* camera, or initial fetch hasn't returned).
+*/
+import type { BatteryStatus } from "@camstack/types";
+import { type UseDeviceProxyTrpc } from "./use-device-proxy";
+/**
+* The cap's own runtime-state shape (`z.infer<BatteryStatusSchema>`) —
+* `percentage` is `number | null`: `null` means no reading has landed yet
+* (D315). Re-exported so call sites don't have to reach into
+* `@camstack/types` themselves.
+*/
 export type { BatteryStatus };
 /**
- * Backwards-compatible alias for the trpc shape — historically the
- * hook took its own narrow contract; the proxy generalisation
- * supersedes that.
- */
+* Backwards-compatible alias for the trpc shape — historically the
+* hook took its own narrow contract; the proxy generalisation
+* supersedes that.
+*/
 export type UseDeviceBatteryTrpc = UseDeviceProxyTrpc;
 export declare function useDeviceBattery(trpc: UseDeviceProxyTrpc, deviceId: number | null): BatteryStatus | null;

package/dist/hooks/use-device-cap-slice.d.ts

@@ -1,19 +1,19 @@
-import { SliceHandleApi } from '@camstack/types';
+import { type SliceHandleApi } from "@camstack/types";
 /**
- * The tRPC shape required by this hook — a superset of `UseDeviceProxyTrpc`
- * that also exposes `deviceState.getCapSlice` and `deviceState.setCapSlice`
- * so the lazy source can bootstrap a per-cap subscription.
- *
- * `System.trpcClient` satisfies this structurally.
- */
+* The tRPC shape required by this hook — a superset of `UseDeviceProxyTrpc`
+* that also exposes `deviceState.getCapSlice` and `deviceState.setCapSlice`
+* so the lazy source can bootstrap a per-cap subscription.
+*
+* `System.trpcClient` satisfies this structurally.
+*/
 export type UseDeviceCapSliceTrpc = SliceHandleApi;
 /**
- * Read an arbitrary cap's runtime-state slice by its raw kebab-case name.
- *
- * Returns `unknown | undefined`:
- *  - `undefined` while the slice hasn't been seeded yet (cold-start)
- *  - the raw slice record once the kernel has published at least one push
- *
- * Pass `null` for `deviceId` to suppress all fetches (renders `undefined`).
- */
+* Read an arbitrary cap's runtime-state slice by its raw kebab-case name.
+*
+* Returns `unknown | undefined`:
+*  - `undefined` while the slice hasn't been seeded yet (cold-start)
+*  - the raw slice record once the kernel has published at least one push
+*
+* Pass `null` for `deviceId` to suppress all fetches (renders `undefined`).
+*/
 export declare function useDeviceCapSlice(trpc: UseDeviceCapSliceTrpc, deviceId: number | null, capName: string): unknown | undefined;

package/dist/hooks/use-device-capability.d.ts

@@ -1,29 +1,63 @@
-import { DeviceProxy, SliceHandle } from '@camstack/types';
-import { UseDeviceProxyTrpc } from './use-device-proxy';
-export interface UseDeviceCapabilityOptions<TCap, TSlice> {
-    readonly trpc: UseDeviceProxyTrpc;
-    readonly deviceId: number | null;
-    readonly cap: (dev: DeviceProxy) => TCap | undefined;
-    readonly slice: (dev: DeviceProxy) => SliceHandle<TSlice> | undefined;
-    readonly requireFeature?: string;
-    readonly deviceFeatures?: readonly string[];
+/**
+* useDeviceCapability — accessor-based readiness wrapper around
+* `useDeviceProxy` + `useDeviceStateSlice`. Combines the three
+* preconditions a UI quick-action needs in one call:
+*
+*   1. Device proxy resolved (bindings landed)
+*   2. Cap handle present on the proxy (i.e. cap is bound)
+*   3. Slice has arrived (provider has published its first snapshot)
+*
+* Optional fourth precondition: a `DeviceFeature` flag advertised on
+* the device row. Useful for surfaces that only render a control when
+* the feature is declared (e.g. the on-motion toggle on a switch).
+*
+* Caller passes typed accessor callbacks so the cap + slice types
+* carry through TypeScript without casts:
+*
+*   const { dev, cap, slice, available } = useDeviceCapability({
+*     trpc, deviceId,
+*     cap:   (dev) => dev.switch,
+*     slice: (dev) => dev.state.switch,
+*     requireFeature: 'switch',          // optional
+*     deviceFeatures: device.features,   // optional, only if feature gate used
+*   })
+*   if (available) await cap.setState({ on: !slice.on })
+*/
+import type { DeviceProxy, SliceHandle } from "@camstack/types";
+import { type UseDeviceProxyTrpc } from "./use-device-proxy";
+export interface UseDeviceCapabilityOptions<
+	TCap,
+	TSlice
+> {
+	readonly trpc: UseDeviceProxyTrpc;
+	readonly deviceId: number | null;
+	readonly cap: (dev: DeviceProxy) => TCap | undefined;
+	readonly slice: (dev: DeviceProxy) => SliceHandle<TSlice> | undefined;
+	readonly requireFeature?: string;
+	readonly deviceFeatures?: readonly string[];
 }
-export interface UseDeviceCapabilityResult<TCap, TSlice> {
-    readonly dev: DeviceProxy | null;
-    readonly cap: TCap | undefined;
-    readonly slice: TSlice | undefined;
-    readonly available: boolean;
-    /**
-     * Resolved device liveness from the auto-registered `device-status`
-     * cap slice. Defaults to `true` until the slice lands so initial load
-     * never false-disables a control. Drives `available` (offline = no
-     * control).
-     */
-    readonly online: boolean;
-    /**
-     * Ms epoch of the last `online` transition when the device is
-     * currently offline, else `null`. Lets a badge render "offline since".
-     */
-    readonly offlineSince: number | null;
+export interface UseDeviceCapabilityResult<
+	TCap,
+	TSlice
+> {
+	readonly dev: DeviceProxy | null;
+	readonly cap: TCap | undefined;
+	readonly slice: TSlice | undefined;
+	readonly available: boolean;
+	/**
+	* Resolved device liveness from the auto-registered `device-status`
+	* cap slice. Defaults to `true` until the slice lands so initial load
+	* never false-disables a control. Drives `available` (offline = no
+	* control).
+	*/
+	readonly online: boolean;
+	/**
+	* Ms epoch of the last `online` transition when the device is
+	* currently offline, else `null`. Lets a badge render "offline since".
+	*/
+	readonly offlineSince: number | null;
 }
-export declare function useDeviceCapability<TCap, TSlice>(options: UseDeviceCapabilityOptions<TCap, TSlice>): UseDeviceCapabilityResult<TCap, TSlice>;
+export declare function useDeviceCapability<
+	TCap,
+	TSlice
+>(options: UseDeviceCapabilityOptions<TCap, TSlice>): UseDeviceCapabilityResult<TCap, TSlice>;

package/dist/hooks/use-device-detections.d.ts

@@ -1,50 +1,50 @@
-import { ObjectDetection } from '@camstack/types';
+import type { ObjectDetection } from "@camstack/types";
 export interface MotionZone {
-    readonly x: number;
-    readonly y: number;
-    readonly w: number;
-    readonly h: number;
-    readonly intensity: number;
+	readonly x: number;
+	readonly y: number;
+	readonly w: number;
+	readonly h: number;
+	readonly intensity: number;
 }
 export interface MotionState {
-    readonly zones: readonly MotionZone[];
-    readonly frameWidth: number;
-    readonly frameHeight: number;
+	readonly zones: readonly MotionZone[];
+	readonly frameWidth: number;
+	readonly frameHeight: number;
 }
 export interface DetectionState {
-    readonly detections: readonly ObjectDetection[];
-    readonly frameWidth: number;
-    readonly frameHeight: number;
+	readonly detections: readonly ObjectDetection[];
+	readonly frameWidth: number;
+	readonly frameHeight: number;
 }
 export interface MotionRawBox {
-    readonly bbox: readonly [number, number, number, number];
-    readonly changeScore: number;
+	readonly bbox: readonly [number, number, number, number];
+	readonly changeScore: number;
 }
 export interface MotionRawState {
-    readonly boxes: readonly MotionRawBox[];
-    readonly frameWidth: number;
-    readonly frameHeight: number;
-    readonly motionScore: number;
+	readonly boxes: readonly MotionRawBox[];
+	readonly frameWidth: number;
+	readonly frameHeight: number;
+	readonly motionScore: number;
 }
 export interface DeviceDetections {
-    readonly motion: MotionState | null;
-    readonly motionRaw: MotionRawState | null;
-    readonly detection: DetectionState | null;
-    readonly phase: string;
+	readonly motion: MotionState | null;
+	readonly motionRaw: MotionRawState | null;
+	readonly detection: DetectionState | null;
+	readonly phase: string;
 }
 interface LiveOnEvent {
-    subscribe: (input: {
-        category: string;
-    }, opts: {
-        onData: (event: unknown) => void;
-    }) => {
-        unsubscribe: () => void;
-    };
+	subscribe: (input: {
+		category: string;
+	}, opts: {
+		onData: (event: unknown) => void;
+	}) => {
+		unsubscribe: () => void;
+	};
 }
 interface UseDetectionsTrpc {
-    live?: {
-        onEvent?: LiveOnEvent;
-    };
+	live?: {
+		onEvent?: LiveOnEvent;
+	};
 }
 export declare function useDeviceDetections(trpc: UseDetectionsTrpc, deviceId: number | null): DeviceDetections;
 export {};

package/dist/hooks/use-device-features.d.ts

@@ -1,25 +1,25 @@
-import { UseDeviceProxyTrpc } from './use-device-proxy';
-export type ResolvedFeatureKind = 'native' | 'enhanced' | 'marker';
+import type { UseDeviceProxyTrpc } from "./use-device-proxy";
+export type ResolvedFeatureKind = "native" | "enhanced" | "marker";
 export type ResolvedFeature = {
-    readonly kind: 'native';
-    readonly feature: string;
-    readonly capName: string;
+	readonly kind: "native";
+	readonly feature: string;
+	readonly capName: string;
 } | {
-    readonly kind: 'enhanced';
-    readonly feature: string;
-    readonly capName: string;
+	readonly kind: "enhanced";
+	readonly feature: string;
+	readonly capName: string;
 } | {
-    readonly kind: 'marker';
-    readonly feature: string;
+	readonly kind: "marker";
+	readonly feature: string;
 };
 export interface UseDeviceFeaturesResult {
-    /** Pending or unresolved (during initial bindings fetch). */
-    readonly loading: boolean;
-    /**
-     * Resolved list — features whose corresponding cap is in bindings,
-     * PLUS pure markers (FEATURE_TO_CAP_NAME has no entry). Features
-     * with a cap mapping that is NOT in bindings are filtered out.
-     */
-    readonly resolved: readonly ResolvedFeature[];
+	/** Pending or unresolved (during initial bindings fetch). */
+	readonly loading: boolean;
+	/**
+	* Resolved list — features whose corresponding cap is in bindings,
+	* PLUS pure markers (FEATURE_TO_CAP_NAME has no entry). Features
+	* with a cap mapping that is NOT in bindings are filtered out.
+	*/
+	readonly resolved: readonly ResolvedFeature[];
 }
 export declare function useDeviceFeatures(trpc: UseDeviceProxyTrpc, deviceId: number | null, rawFeatures: readonly string[]): UseDeviceFeaturesResult;

package/dist/hooks/use-device-list-page-size.d.ts

@@ -1,4 +1,17 @@
-import { SetPageSize } from './use-persisted-page-size';
+/**
+* useDeviceListPageSize — global page-size preference for the device-list
+* surfaces (Devices, Integrations, integration detail).
+*
+* ONE shared localStorage key (`camstack.device-list.pageSize`) so changing
+* the per-page size on any device-list page applies everywhere. The stored
+* value is validated against {@link DEVICE_LIST_PAGE_SIZE_OPTIONS}; any
+* garbage / out-of-range value falls back to the provided default.
+*
+* A thin binding of `usePersistedPageSize` to that key and option set; a
+* surface with a different default or options uses the generic hook with a
+* key of its own.
+*/
+import { type SetPageSize } from "./use-persisted-page-size";
 /** Selectable per-page sizes. The table default (50) is intentionally one of them. */
 export declare const DEVICE_LIST_PAGE_SIZE_OPTIONS: readonly number[];
 /** Canonical default — used whenever a caller's `defaultSize` is itself invalid. */
@@ -7,9 +20,9 @@ export declare const DEVICE_LIST_PAGE_SIZE_DEFAULT = 50;
 export declare const DEVICE_LIST_PAGE_SIZE_KEY = "camstack.device-list.pageSize";
 export type SetDeviceListPageSize = SetPageSize;
 /**
- * @param defaultSize fallback when nothing valid is stored. If it is not itself
- *   a member of {@link DEVICE_LIST_PAGE_SIZE_OPTIONS}, it is replaced by
- *   {@link DEVICE_LIST_PAGE_SIZE_DEFAULT} so it can never seed a phantom value.
- * @returns `[size, setSize]` — `setSize` ignores values outside the allowed set.
- */
+* @param defaultSize fallback when nothing valid is stored. If it is not itself
+*   a member of {@link DEVICE_LIST_PAGE_SIZE_OPTIONS}, it is replaced by
+*   {@link DEVICE_LIST_PAGE_SIZE_DEFAULT} so it can never seed a phantom value.
+* @returns `[size, setSize]` — `setSize` ignores values outside the allowed set.
+*/
 export declare function useDeviceListPageSize(defaultSize: number): readonly [number, SetDeviceListPageSize];

package/dist/hooks/use-device-network-link.d.ts

@@ -1,10 +1,18 @@
-import { UseDeviceProxyTrpc } from './use-device-proxy';
+/**
+* useDeviceNetworkLink — the device's own network link (medium + signal).
+*
+* Same shape as `useDeviceBattery`: a thin wrapper over `useDeviceState`,
+* fed by the kernel runtime-state mirror (one fetch on first subscribe, then
+* push updates on every `network-link` slice write). Returns `null` when no
+* provider has emitted yet — a device without the cap simply has no badge.
+*/
+import { type UseDeviceProxyTrpc } from "./use-device-proxy";
 export interface NetworkLinkStatus {
-    readonly type: 'wifi' | 'ethernet' | 'cellular' | 'unknown';
-    /** `null` = not known or not applicable (a wired link has no signal). */
-    readonly signalPercent: number | null;
-    readonly rssiDbm?: number;
-    readonly ssid?: string;
-    readonly lastUpdated: number;
+	readonly type: "wifi" | "ethernet" | "cellular" | "unknown";
+	/** `null` = not known or not applicable (a wired link has no signal). */
+	readonly signalPercent: number | null;
+	readonly rssiDbm?: number;
+	readonly ssid?: string;
+	readonly lastUpdated: number;
 }
 export declare function useDeviceNetworkLink(trpc: UseDeviceProxyTrpc, deviceId: number | null): NetworkLinkStatus | null;

package/dist/hooks/use-device-proxy.d.ts

@@ -1,106 +1,112 @@
-import { DeviceBinding, DeviceProxy } from '@camstack/types';
+import type { DeviceBinding, DeviceProxy } from "@camstack/types";
 /**
- * Reactive runtime-state read handle as exposed by the codegen
- * `DeviceProxy` factory. Same shape useDeviceStateSlice expects —
- * defined here so the combinator's selector parameter has a tight
- * type without re-importing the codegen file.
- */
+* Reactive runtime-state read handle as exposed by the codegen
+* `DeviceProxy` factory. Same shape useDeviceStateSlice expects —
+* defined here so the combinator's selector parameter has a tight
+* type without re-importing the codegen file.
+*/
 interface StateSliceHandle<T> {
-    readonly value: T | undefined;
-    subscribe(cb: (slice: T | undefined) => void): () => void;
+	readonly value: T | undefined;
+	subscribe(cb: (slice: T | undefined) => void): () => void;
 }
-interface QueryFn<I, O> {
-    query(input: I): Promise<O>;
+interface QueryFn<
+	I,
+	O
+> {
+	query(input: I): Promise<O>;
 }
-interface SubscribeFn<I, T> {
-    subscribe(input: I, opts: {
-        onData: (evt: {
-            data: T;
-        }) => void;
-        onError?: (err: unknown) => void;
-    }): {
-        unsubscribe: () => void;
-    };
+interface SubscribeFn<
+	I,
+	T
+> {
+	subscribe(input: I, opts: {
+		onData: (evt: {
+			data: T;
+		}) => void;
+		onError?: (err: unknown) => void;
+	}): {
+		unsubscribe: () => void;
+	};
 }
 /**
- * Minimal vanilla tRPC proxy shape. Same contract `useDeviceWebrtc`,
- * `useDeviceBattery` etc. use — both `BackendClient.trpc` and an
- * addon page's injected `trpc` satisfy this structurally.
- *
- * The proxy is also passed (cast) into `createDeviceProxy` as the
- * `AddonApi` argument — the cap-method dispatchers structurally
- * match `client.<cap>.<method>.{query|mutate|subscribe}`.
- */
+* Minimal vanilla tRPC proxy shape. Same contract `useDeviceWebrtc`,
+* `useDeviceBattery` etc. use — both `BackendClient.trpc` and an
+* addon page's injected `trpc` satisfy this structurally.
+*
+* The proxy is also passed (cast) into `createDeviceProxy` as the
+* `AddonApi` argument — the cap-method dispatchers structurally
+* match `client.<cap>.<method>.{query|mutate|subscribe}`.
+*/
 export interface UseDeviceProxyTrpc {
-    readonly deviceManager: {
-        readonly getBindings: QueryFn<{
-            deviceId: number;
-        }, DeviceBinding>;
-    };
-    readonly live?: {
-        readonly onEvent: SubscribeFn<{
-            category: string;
-        }, {
-            category?: string;
-            data?: unknown;
-            source?: {
-                type: string;
-                id: string | number;
-            };
-        }>;
-    };
+	readonly deviceManager: {
+		readonly getBindings: QueryFn<{
+			deviceId: number;
+		}, DeviceBinding>;
+	};
+	readonly live?: {
+		readonly onEvent: SubscribeFn<{
+			category: string;
+		}, {
+			category?: string;
+			data?: unknown;
+			source?: {
+				type: string;
+				id: string | number;
+			};
+		}>;
+	};
 }
 /**
- * @returns the proxy, or `null` while bindings are still loading or
- * when `deviceId` is null. Re-rendered when bindings change.
- */
+* @returns the proxy, or `null` while bindings are still loading or
+* when `deviceId` is null. Re-rendered when bindings change.
+*/
 export declare function useDeviceProxy(trpc: UseDeviceProxyTrpc, deviceId: number | null): DeviceProxy | null;
 /**
- * Companion hook — reads a `SliceHandle` reactively, returning the
- * current value and re-rendering on every push from the kernel
- * mirror. Pass `dev?.state.battery` etc. as the handle.
- *
- *   const dev = useDeviceProxy(trpc, deviceId)
- *   const battery = useDeviceStateSlice(dev?.state.battery)
- *
- * Why a hook (and not just `dev.state.battery.subscribe(...)` inline)?
- * React doesn't observe external mutations on its own — a bare
- * subscribe call inside a render would fire on every render (memory
- * leak), wouldn't trigger a re-render on slice change, and wouldn't
- * clean up at unmount. The hook bridges the imperative
- * `(value, subscribe)` pair into React's declarative lifecycle via
- * `useSyncExternalStore` (the canonical React 18 primitive for
- * external stores — handles tearing in concurrent rendering and
- * de-dups identical pushes).
- */
+* Companion hook — reads a `SliceHandle` reactively, returning the
+* current value and re-rendering on every push from the kernel
+* mirror. Pass `dev?.state.battery` etc. as the handle.
+*
+*   const dev = useDeviceProxy(trpc, deviceId)
+*   const battery = useDeviceStateSlice(dev?.state.battery)
+*
+* Why a hook (and not just `dev.state.battery.subscribe(...)` inline)?
+* React doesn't observe external mutations on its own — a bare
+* subscribe call inside a render would fire on every render (memory
+* leak), wouldn't trigger a re-render on slice change, and wouldn't
+* clean up at unmount. The hook bridges the imperative
+* `(value, subscribe)` pair into React's declarative lifecycle via
+* `useSyncExternalStore` (the canonical React 18 primitive for
+* external stores — handles tearing in concurrent rendering and
+* de-dups identical pushes).
+*/
 export declare function useDeviceStateSlice<T>(handle: StateSliceHandle<T> | undefined): T | undefined;
 /**
- * One-line combinator — collapse the common
- * `useDeviceProxy + useDeviceStateSlice(dev?.state.<cap>)` pair into a
- * single hook. The selector receives the live `DeviceProxy['state']`
- * bag (typed against the codegen, so `s.battery` etc. autocomplete)
- * and returns one slice handle. Returns the slice value, undefined
- * while the binding resolves OR when the slice has no cached push yet.
- *
- * Idiomatic call-site:
- *
- *   const battery = useDeviceState(trpc, deviceId, (s) => s.battery)
- *   const zones = useDeviceState(trpc, deviceId, (s) => s.zones)
- *
- * vs. the manual pair:
- *
- *   const dev = useDeviceProxy(trpc, deviceId)
- *   const battery = useDeviceStateSlice(dev?.state.battery)
- *   const zones = useDeviceStateSlice(dev?.state.zones)
- *
- * Use the manual pair when:
- *   - you also need the proxy's cap method bag (`dev.zones?.addZone(...)`)
- *   - you want to share the proxy across multiple slice reads with a
- *     single binding fetch (the combinator calls useDeviceProxy
- *     internally, which dedups bindings via React Query in practice
- *     but spawns one extra subscription per call site)
- *
- * Use the combinator when reading just one slice — most common case.
- */
-export declare function useDeviceState<T>(trpc: UseDeviceProxyTrpc, deviceId: number | null, select: (state: DeviceProxy['state']) => StateSliceHandle<T>): T | undefined;
+* One-line combinator — collapse the common
+* `useDeviceProxy + useDeviceStateSlice(dev?.state.<cap>)` pair into a
+* single hook. The selector receives the live `DeviceProxy['state']`
+* bag (typed against the codegen, so `s.battery` etc. autocomplete)
+* and returns one slice handle. Returns the slice value, undefined
+* while the binding resolves OR when the slice has no cached push yet.
+*
+* Idiomatic call-site:
+*
+*   const battery = useDeviceState(trpc, deviceId, (s) => s.battery)
+*   const zones = useDeviceState(trpc, deviceId, (s) => s.zones)
+*
+* vs. the manual pair:
+*
+*   const dev = useDeviceProxy(trpc, deviceId)
+*   const battery = useDeviceStateSlice(dev?.state.battery)
+*   const zones = useDeviceStateSlice(dev?.state.zones)
+*
+* Use the manual pair when:
+*   - you also need the proxy's cap method bag (`dev.zones?.addZone(...)`)
+*   - you want to share the proxy across multiple slice reads with a
+*     single binding fetch (the combinator calls useDeviceProxy
+*     internally, which dedups bindings via React Query in practice
+*     but spawns one extra subscription per call site)
+*
+* Use the combinator when reading just one slice — most common case.
+*/
+export declare function useDeviceState<T>(trpc: UseDeviceProxyTrpc, deviceId: number | null, select: (state: DeviceProxy["state"]) => StateSliceHandle<T>): T | undefined;
 export {};

package/dist/hooks/use-device-snapshot.d.ts

@@ -1,30 +1,30 @@
 /** The hub-proxied path prefix for the snapshot image data plane, composed
- *  below on `baseUrl` or, for the same-origin case, on the page's mount. */
+*  below on `baseUrl` or, for the same-origin case, on the page's mount. */
 export declare const SNAPSHOT_MEDIA_PATH = "/addon/snapshot/media";
 export interface DeviceSnapshotImage {
-    /** Image URL ready for `<img src>`, or `null` when there is no device. */
-    readonly src: string | null;
-    /**
-     * Always false. Kept so existing callers' spinners compile; a URL needs no
-     * fetch state, and the `<img>` element owns its own load lifecycle (an
-     * unavailable snapshot surfaces as `onError`, which every consumer already
-     * handles because a device can legitimately have no camera).
-     */
-    readonly loading: boolean;
-    /** Force ONE fresh capture (bypasses the wrapper's freshness gate, and wakes
-     *  a battery camera — an operator action only). */
-    readonly refresh: () => void;
+	/** Image URL ready for `<img src>`, or `null` when there is no device. */
+	readonly src: string | null;
+	/**
+	* Always false. Kept so existing callers' spinners compile; a URL needs no
+	* fetch state, and the `<img>` element owns its own load lifecycle (an
+	* unavailable snapshot surfaces as `onError`, which every consumer already
+	* handles because a device can legitimately have no camera).
+	*/
+	readonly loading: boolean;
+	/** Force ONE fresh capture (bypasses the wrapper's freshness gate, and wakes
+	*  a battery camera — an operator action only). */
+	readonly refresh: () => void;
 }
 export interface UseDeviceSnapshotOptions {
-    /**
-     * Target width in px. The server snaps it to a ladder
-     * ([160, 240, 320, 480, 640, 960]) and derives the variant once per capture,
-     * so nearby sizes share one image. **Omitting it returns the frame as
-     * captured** — which is how a 28 px thumbnail came to cost a megabyte.
-     */
-    readonly width?: number;
-    /** Absolute hub base. Omit in the admin UI, which is same-origin with the
-     *  hub — the path then follows the page's mount (`hub-mount.ts`). */
-    readonly baseUrl?: string;
+	/**
+	* Target width in px. The server snaps it to a ladder
+	* ([160, 240, 320, 480, 640, 960]) and derives the variant once per capture,
+	* so nearby sizes share one image. **Omitting it returns the frame as
+	* captured** — which is how a 28 px thumbnail came to cost a megabyte.
+	*/
+	readonly width?: number;
+	/** Absolute hub base. Omit in the admin UI, which is same-origin with the
+	*  hub — the path then follows the page's mount (`hub-mount.ts`). */
+	readonly baseUrl?: string;
 }
 export declare function useDeviceSnapshotImage(deviceId: number | null, options?: UseDeviceSnapshotOptions): DeviceSnapshotImage;