@camstack/ui-library 0.1.39 → 0.1.40

package/dist/hooks/index.d.ts

@@ -0,0 +1,27 @@
+export { useIsMobile, useIsMidWidth } from './use-is-mobile';
+export { useDeviceDetections } from './use-device-detections';
+export { useDeviceWebrtc } from './use-device-webrtc';
+export { usePTZ } from './use-ptz';
+export type { UsePTZResult, UsePTZOptions, PTZDirection, PTZTrpcProxy } from './use-ptz';
+export { useDeviceBattery } from './use-device-battery';
+export type { UseDeviceBatteryTrpc } from './use-device-battery';
+export { useDoorbellEvents } from './use-doorbell-events';
+export type { DoorbellPressEvent, UseDoorbellEventsResult, UseDoorbellEventsOptions } from './use-doorbell-events';
+export { useClusterNodes } from './use-cluster-nodes';
+export { useDebouncedString } from './use-debounced-string';
+export { useEventStreamLatest, useEventStreamMap } from './use-event-stream';
+export { useDeviceProxy, useDeviceStateSlice, useDeviceState } from './use-device-proxy';
+export type { UseDeviceProxyTrpc } from './use-device-proxy';
+export { useDeviceCapability } from './use-device-capability';
+export type { UseDeviceCapabilityOptions, UseDeviceCapabilityResult, } from './use-device-capability';
+export { useDeviceSnapshotImage } from './use-device-snapshot';
+export type { DeviceSnapshotImage } from './use-device-snapshot';
+export type { ClusterNode } from './use-cluster-nodes';
+export type { DeviceDetections, MotionState, MotionZone, MotionRawState, MotionRawBox, DetectionState, } from './use-device-detections';
+export type { DeviceWebrtcResult, UseDeviceWebrtcTrpc, DevicePipelineMetrics } from './use-device-webrtc';
+export { useLiveBuffer } from './use-live-buffer';
+export type { LiveBuffer } from './use-live-buffer';
+export { useDevices, useDevice } from './use-devices';
+export { useSystemQuery, useSystemMutation, type SystemQuerySelector, type SystemMutationSelector, } from './use-system-query';
+export { useLiveEvent, type LiveEventCallback } from './use-live-event';
+export { useEventInvalidation } from './use-event-invalidation';

package/dist/hooks/use-cluster-nodes.d.ts

@@ -0,0 +1,17 @@
+export interface ClusterNode {
+    readonly id: string;
+    readonly name: string;
+    /** Compact label for pill bars: "HUB" for the hub, agent name for agents. */
+    readonly shortName: string;
+    readonly isHub: boolean;
+    readonly isOnline: boolean;
+    readonly localIps: readonly string[];
+    readonly addons: readonly {
+        readonly addonId: string;
+        readonly capabilities: readonly string[];
+    }[];
+}
+export declare function useClusterNodes(): {
+    readonly nodes: readonly ClusterNode[];
+    readonly isLoading: boolean;
+};

package/dist/hooks/use-debounced-string.d.ts

@@ -0,0 +1 @@
+export declare function useDebouncedString(value: string, delayMs: number): string;

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

@@ -0,0 +1,14 @@
+import { UseDeviceProxyTrpc } from './use-device-proxy';
+export interface BatteryStatus {
+    readonly percentage: number;
+    readonly charging: 'dc' | 'solar' | 'none';
+    readonly sleeping: boolean;
+    readonly lastUpdated: number;
+}
+/**
+ * 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-capability.d.ts

@@ -0,0 +1,17 @@
+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[];
+}
+export interface UseDeviceCapabilityResult<TCap, TSlice> {
+    readonly dev: DeviceProxy | null;
+    readonly cap: TCap | undefined;
+    readonly slice: TSlice | undefined;
+    readonly available: boolean;
+}
+export declare function useDeviceCapability<TCap, TSlice>(options: UseDeviceCapabilityOptions<TCap, TSlice>): UseDeviceCapabilityResult<TCap, TSlice>;

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

@@ -0,0 +1,50 @@
+import { ObjectDetection } from '@camstack/types';
+export interface MotionZone {
+    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;
+}
+export interface DetectionState {
+    readonly detections: readonly ObjectDetection[];
+    readonly frameWidth: number;
+    readonly frameHeight: number;
+}
+export interface MotionRawBox {
+    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;
+}
+export interface DeviceDetections {
+    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;
+    };
+}
+interface UseDetectionsTrpc {
+    live?: {
+        onEvent?: LiveOnEvent;
+    };
+}
+export declare function useDeviceDetections(trpc: UseDetectionsTrpc, deviceId: number | null): DeviceDetections;
+export {};

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

@@ -0,0 +1,25 @@
+import { 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: 'enhanced';
+    readonly feature: string;
+    readonly capName: 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[];
+}
+export declare function useDeviceFeatures(trpc: UseDeviceProxyTrpc, deviceId: number | null, rawFeatures: readonly string[]): UseDeviceFeaturesResult;

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

@@ -0,0 +1,106 @@
+import { 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.
+ */
+interface StateSliceHandle<T> {
+    readonly value: T | undefined;
+    subscribe(cb: (slice: T | undefined) => void): () => void;
+}
+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;
+    };
+}
+/**
+ * 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;
+            };
+        }>;
+    };
+}
+/**
+ * @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).
+ */
+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;
+export {};

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

@@ -0,0 +1,10 @@
+import { UseDeviceProxyTrpc } from './use-device-proxy';
+export interface DeviceSnapshotImage {
+    /** Data-URL for the most recently fetched snapshot, or `null`. */
+    readonly src: string | null;
+    /** True while a fetch is in flight. */
+    readonly loading: boolean;
+    /** Force the next fetch to bypass cache (single use). */
+    readonly refresh: () => void;
+}
+export declare function useDeviceSnapshotImage(trpc: UseDeviceProxyTrpc, deviceId: number | null): DeviceSnapshotImage;

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

@@ -0,0 +1,108 @@
+import { StreamChoice } from '../composites/stream-panel';
+import { ClientStreamHints, SignalingResult } from '../composites/camera-stream-player';
+/**
+ * Discriminated WebRTC target — same shape as `WebrtcStreamTarget` on
+ * the backend cap. Repeated locally to keep the hook self-contained
+ * (no cross-package import from `@camstack/types`).
+ */
+export type WebrtcTarget = {
+    readonly kind: 'adaptive';
+} | {
+    readonly kind: 'profile';
+    readonly profile: 'high' | 'mid' | 'low';
+} | {
+    readonly kind: 'cam-stream';
+    readonly camStreamId: string;
+};
+/** Mutation call shape: `.mutate(input)` → Promise. */
+interface MutateFn<I, O> {
+    mutate(input: I): Promise<O>;
+}
+/** Query call shape: `.query(input?)` → Promise. */
+interface QueryFn<I, O> {
+    query(input: I): Promise<O>;
+}
+interface StreamChoiceRow {
+    readonly id: string;
+    readonly label: string;
+    readonly target: WebrtcTarget;
+    readonly codec: string | null;
+    readonly resolution: {
+        width: number;
+        height: number;
+    } | null;
+    readonly status: string | null;
+    readonly inputFps: number | null;
+    readonly decodeFps: number | null;
+    readonly bitrateKbps: number | null;
+}
+/**
+ * Minimal subset of the tRPC proxy needed for WebRTC signaling.
+ * Both `BackendClient.trpc` and `AddonPageProps['trpc']` satisfy this
+ * at runtime.
+ */
+export interface UseDeviceWebrtcTrpc {
+    webrtcSession: {
+        listStreams: QueryFn<{
+            deviceId: number;
+        }, readonly StreamChoiceRow[]>;
+        createSession: MutateFn<{
+            deviceId: number;
+            target: WebrtcTarget;
+            hints?: ClientStreamHints;
+        }, {
+            sessionId: string;
+            sdpOffer: string;
+        }>;
+        handleAnswer: MutateFn<{
+            deviceId: number;
+            sessionId: string;
+            sdpAnswer: string;
+        }, void>;
+        closeSession: MutateFn<{
+            deviceId: number;
+            sessionId: string;
+        }, void>;
+    };
+    pipelineOrchestrator?: {
+        getCameraMetrics: QueryFn<{
+            deviceId: number;
+        }, {
+            phase: string;
+            actualFps: number;
+            avgInferenceTimeMs: number;
+            droppedFrames: number;
+            configuredFps: number;
+        } | null>;
+    };
+}
+/** Pipeline detection metrics for a device. */
+export interface DevicePipelineMetrics {
+    readonly phase: string;
+    readonly detectionFps: number;
+    readonly avgInferenceMs: number;
+    readonly droppedFrames: number;
+}
+export interface DeviceWebrtcResult {
+    /** Available stream choices for the dropdown (Adaptive + assigned profiles). */
+    readonly streams: readonly StreamChoice[];
+    /** Whether the device has at least one assigned profile (can stream). */
+    readonly hasWebrtc: boolean;
+    /** Live pipeline metrics (phase, detection fps, inference time). */
+    readonly pipelineMetrics: DevicePipelineMetrics | null;
+    /** Server-offer signaling: create a WebRTC session. */
+    readonly createSession: (target: WebrtcTarget, hints?: ClientStreamHints) => Promise<SignalingResult>;
+    /** Server-offer signaling: send the client's SDP answer. */
+    readonly sendAnswer: (sessionId: string, sdpAnswer: string) => Promise<void>;
+    /** Close a WebRTC session on the server. */
+    readonly closeSession: (sessionId: string) => Promise<void>;
+}
+/**
+ * Hook that provides WebRTC signaling callbacks and stream choices for a device.
+ *
+ * @param trpc  - tRPC proxy (admin-ui BackendClient.trpc or addon page trpc)
+ * @param deviceId - numeric device ID (null = disabled)
+ * @param pollIntervalMs - how often to refresh profile slots (default: 5000)
+ */
+export declare function useDeviceWebrtc(trpc: UseDeviceWebrtcTrpc, deviceId: number | null, pollIntervalMs?: number): DeviceWebrtcResult;
+export {};

package/dist/hooks/use-devices.d.ts

@@ -0,0 +1,13 @@
+import { DeviceProxy, DeviceQueryFilters } from '@camstack/types';
+/**
+ * Reactive list of devices matching the optional filter set. Returns a
+ * stable array reference between updates so consumers passing it as a
+ * prop don't tear down memoized children.
+ */
+export declare function useDevices(filters?: DeviceQueryFilters): readonly DeviceProxy[];
+/**
+ * Single-device variant. Returns `null` until the device is in the
+ * mirror; re-renders when the device is removed (back to `null`) or
+ * added.
+ */
+export declare function useDevice(deviceId: number | null): DeviceProxy | null;

package/dist/hooks/use-doorbell-events.d.ts

@@ -0,0 +1,20 @@
+export interface DoorbellPressEvent {
+    readonly deviceId: number;
+    readonly timestamp: number;
+}
+export interface UseDoorbellEventsResult {
+    /** Most recent press, or null if none observed since mount. */
+    readonly latest: DoorbellPressEvent | null;
+    /** Recent presses, newest-first. Capped at `historyLimit`. */
+    readonly history: readonly DoorbellPressEvent[];
+}
+export interface UseDoorbellEventsOptions {
+    /**
+     * Scope the subscription to a specific deviceId. Pass `null` (or
+     * omit) to receive every press across the cluster.
+     */
+    readonly deviceId?: number | null;
+    /** Max history entries kept in memory. Defaults to 20. */
+    readonly historyLimit?: number;
+}
+export declare function useDoorbellEvents(options?: UseDoorbellEventsOptions): UseDoorbellEventsResult;

package/dist/hooks/use-event-invalidation.d.ts

@@ -0,0 +1 @@
+export declare function useEventInvalidation(queryKey: readonly unknown[], categories: readonly string[]): void;

package/dist/hooks/use-event-stream.d.ts

@@ -0,0 +1,5 @@
+export declare function useEventStreamLatest<T>(category: string, filter?: (data: T) => boolean): T | null;
+export declare function useEventStreamMap<T, K extends string | number>(category: string, keyOf: (data: T) => K, filter?: (data: T) => boolean): {
+    readonly map: ReadonlyMap<K, T>;
+    readonly values: readonly T[];
+};

package/dist/hooks/use-is-mobile.d.ts

@@ -0,0 +1,8 @@
+export declare function useIsMobile(): boolean;
+/**
+ * True when the viewport is in the medium (`md`) Tailwind range —
+ * 768px ≤ width < 1024px. Use to drive layouts that should pack denser
+ * than full-desktop but more legibly than mobile (e.g. icons-only
+ * sidebar rail, narrower stat tiles).
+ */
+export declare function useIsMidWidth(): boolean;

package/dist/hooks/use-live-buffer.d.ts

@@ -0,0 +1,8 @@
+export interface LiveBuffer<T> {
+    readonly entries: readonly T[];
+    /** Append one entry; oldest is evicted past `max`. */
+    readonly append: (entry: T) => void;
+    /** Replace all entries — used by Clear / scope-change resets. */
+    readonly reset: () => void;
+}
+export declare function useLiveBuffer<T>(max: number): LiveBuffer<T>;

package/dist/hooks/use-live-event.d.ts

@@ -0,0 +1,3 @@
+import { SystemLiveEvent } from '@camstack/sdk';
+export type LiveEventCallback<TData = unknown> = (event: SystemLiveEvent<TData>) => void;
+export declare function useLiveEvent<TData = unknown>(category: string, cb: LiveEventCallback<TData>): void;

package/dist/hooks/use-ptz.d.ts

@@ -0,0 +1,54 @@
+import { UseDeviceProxyTrpc } from './use-device-proxy';
+/**
+ * Cardinal + intercardinal direction tokens. The hook translates them
+ * into normalised `(pan, tilt)` vectors before calling the underlying
+ * cap so the cap surface stays speed-vector-shaped.
+ */
+export type PTZDirection = 'up' | 'down' | 'left' | 'right' | 'up-left' | 'up-right' | 'down-left' | 'down-right';
+interface PTZPreset {
+    readonly id: string;
+    readonly name: string;
+}
+/**
+ * Backwards-compatible alias for the trpc shape — historically the
+ * hook took its own narrow contract; the proxy generalisation
+ * supersedes that.
+ */
+export type PTZTrpcProxy = UseDeviceProxyTrpc;
+export interface UsePTZOptions {
+    /** Default speed (0..1) for moves when the caller omits one. */
+    readonly defaultSpeed?: number;
+    /** Pulse duration (ms) for one-shot `move` calls. */
+    readonly pulseMs?: number;
+    /**
+     * Gate the hook's network calls. When `false`, the initial preset
+     * refresh is skipped and every method becomes a no-op. Use to avoid
+     * "provider not available" errors on devices that don't advertise
+     * the `ptz` capability.
+     */
+    readonly enabled?: boolean;
+}
+export interface UsePTZResult {
+    /** One-shot directional pulse. Stops itself after `pulseMs`. */
+    readonly move: (direction: PTZDirection, speed?: number) => Promise<void>;
+    /** Begin continuous motion in `direction` until `stopContinuous` is called. */
+    readonly startContinuous: (direction: PTZDirection, speed?: number) => Promise<void>;
+    /** Stop any ongoing continuous motion. Idempotent. */
+    readonly stopContinuous: () => Promise<void>;
+    /** Discrete zoom step (in or out). */
+    readonly zoom: (direction: 'in' | 'out', speed?: number) => Promise<void>;
+    /** Jump to the home preset (0 on most cameras). */
+    readonly goHome: () => Promise<void>;
+    /** Jump to a named preset. */
+    readonly goToPreset: (presetId: string) => Promise<void>;
+    /** List of presets reported by the camera. Empty until first refresh. */
+    readonly presets: readonly PTZPreset[];
+    /** Force a refresh of the presets list. */
+    readonly refreshPresets: () => Promise<void>;
+    /** True while a control call is in flight (any path). */
+    readonly busy: boolean;
+    /** Last error message from any cap call, or null. */
+    readonly error: string | null;
+}
+export declare function usePTZ(trpc: UseDeviceProxyTrpc, deviceId: number, options?: UsePTZOptions): UsePTZResult;
+export {};

package/dist/hooks/use-system-query.d.ts

@@ -0,0 +1,12 @@
+import { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { System } from '@camstack/sdk';
+/**
+ * `select` MUST return a thunk that, when invoked, performs the
+ * request. Two-step factory keeps the query-key + thunk identities
+ * stable between renders: the hook re-creates the thunk on every
+ * render (cheap), but React Query keys off `[queryKey]` only.
+ */
+export type SystemQuerySelector<TData> = (system: System) => () => Promise<TData>;
+export type SystemMutationSelector<TInput, TData> = (system: System) => (input: TInput) => Promise<TData>;
+export declare function useSystemQuery<TData>(queryKey: QueryKey, select: SystemQuerySelector<TData>, opts?: Omit<UseQueryOptions<TData, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData, Error>;
+export declare function useSystemMutation<TInput, TData>(select: SystemMutationSelector<TInput, TData>, opts?: Omit<UseMutationOptions<TData, Error, TInput>, 'mutationFn'>): UseMutationResult<TData, Error, TInput>;

package/dist/icons/index.d.ts

@@ -0,0 +1,2 @@
+export * from './provider-icons';
+export * from './status-icons';

package/dist/icons/provider-icons.d.ts

@@ -0,0 +1,3 @@
+import { LucideIcon } from 'lucide-react';
+export type ProviderType = 'frigate' | 'scrypted' | 'reolink' | 'homeAssistant' | 'rtsp';
+export declare const providerIcons: Record<ProviderType, LucideIcon>;

package/dist/icons/status-icons.d.ts

@@ -0,0 +1,3 @@
+import { LucideIcon } from 'lucide-react';
+export type StatusType = 'online' | 'offline' | 'degraded' | 'unknown';
+export declare const statusIcons: Record<StatusType, LucideIcon>;