@camera.ui/browser 0.0.110 → 0.0.112

package/dist/index.d.ts

@@ -0,0 +1,1269 @@
+import { AudioProperty } from '@camera.ui/sdk';
+import { AudioSensorProperties } from '@camera.ui/sdk';
+import type { BaseCamera } from '@camera.ui/sdk';
+import { BasePlugin } from '@camera.ui/sdk';
+import { BatteryInfoProperties } from '@camera.ui/sdk';
+import { BatteryProperty } from '@camera.ui/sdk';
+import { Camera } from '@camera.ui/sdk';
+import type { CameraInputSettings } from '@camera.ui/sdk/internal';
+import { CameraSource } from '@camera.ui/sdk';
+import { ChargingState } from '@camera.ui/sdk';
+import { ClassifierProperty } from '@camera.ui/sdk';
+import { ClassifierSensorProperties } from '@camera.ui/sdk';
+import { ComputedRef } from 'vue';
+import { ConnectionTarget } from '@camera.ui/transport';
+import { ContactProperty } from '@camera.ui/sdk';
+import { ContactSensorProperties } from '@camera.ui/sdk';
+import { CoreManager } from '@camera.ui/sdk';
+import { Detection } from '@camera.ui/sdk';
+import { DoorbellProperty } from '@camera.ui/sdk';
+import { DoorbellTriggerProperties } from '@camera.ui/sdk';
+import { FaceDetection } from '@camera.ui/sdk';
+import { FaceProperty } from '@camera.ui/sdk';
+import { FaceSensorProperties } from '@camera.ui/sdk';
+import { FormSubmitResponse } from '@camera.ui/sdk';
+import { GarageControlProperties } from '@camera.ui/sdk';
+import { GarageProperty } from '@camera.ui/sdk';
+import { GarageState } from '@camera.ui/sdk';
+import { HTMLAttributes } from 'vue';
+import { HumidityInfoProperties } from '@camera.ui/sdk';
+import { HumidityProperty } from '@camera.ui/sdk';
+import { InjectionKey } from 'vue';
+import { LeakProperty } from '@camera.ui/sdk';
+import { LeakSensorProperties } from '@camera.ui/sdk';
+import { LicensePlateDetection } from '@camera.ui/sdk';
+import { LicensePlateProperty } from '@camera.ui/sdk';
+import { LicensePlateSensorProperties } from '@camera.ui/sdk';
+import { LightControlProperties } from '@camera.ui/sdk';
+import { LightProperty } from '@camera.ui/sdk';
+import { LockControlProperties } from '@camera.ui/sdk';
+import { LockProperty } from '@camera.ui/sdk';
+import { LockState } from '@camera.ui/sdk';
+import { MaybeRefOrGetter } from 'vue';
+import type { ModelSpec } from '@camera.ui/sdk';
+import { MotionProperty } from '@camera.ui/sdk';
+import { MotionSensorProperties } from '@camera.ui/sdk';
+import { Status as NatsStatus } from '@camera.ui/rpc';
+import { NatsTransport } from '@camera.ui/transport/transports/nats';
+import { OAuthMetadata } from '@camera.ui/sdk';
+import { OAuthState } from '@camera.ui/sdk';
+import { ObjectProperty } from '@camera.ui/sdk';
+import { ObjectSensorProperties } from '@camera.ui/sdk';
+import { OccupancyProperty } from '@camera.ui/sdk';
+import { OccupancySensorProperties } from '@camera.ui/sdk';
+import { PluginContract } from '@camera.ui/sdk';
+import type { PluginInfo } from '@camera.ui/sdk';
+import type { PluginInterface } from '@camera.ui/sdk';
+import { PluginInterfaces } from '@camera.ui/sdk';
+import { ProbeConfig } from '@camera.ui/sdk';
+import { ProbeStream } from '@camera.ui/sdk';
+import { Promisify } from '@camera.ui/rpc';
+import { PropertyChangedEvent } from '@camera.ui/sdk/internal';
+import { PTZControlProperties } from '@camera.ui/sdk';
+import { PTZDirection } from '@camera.ui/sdk';
+import { PTZPosition } from '@camera.ui/sdk';
+import { PTZProperty } from '@camera.ui/sdk';
+import { Ref } from 'vue';
+import { RPCClient } from '@camera.ui/rpc';
+import { SchemaConfig } from '@camera.ui/sdk';
+import { SecuritySystemProperties } from '@camera.ui/sdk';
+import { SecuritySystemProperty } from '@camera.ui/sdk';
+import { SecuritySystemState } from '@camera.ui/sdk';
+import type { SensorJSON } from '@camera.ui/sdk/internal';
+import { SensorType } from '@camera.ui/sdk';
+import { ShallowRef } from 'vue';
+import { SirenControlProperties } from '@camera.ui/sdk';
+import { SirenProperty } from '@camera.ui/sdk';
+import { SmokeProperty } from '@camera.ui/sdk';
+import { SmokeSensorProperties } from '@camera.ui/sdk';
+import type { SnapshotInterface } from '@camera.ui/sdk';
+import type { StreamingInterface } from '@camera.ui/sdk';
+import { StreamingRole } from '@camera.ui/sdk';
+import { SwitchControlProperties } from '@camera.ui/sdk';
+import { SwitchProperty } from '@camera.ui/sdk';
+import { TemperatureInfoProperties } from '@camera.ui/sdk';
+import { TemperatureProperty } from '@camera.ui/sdk';
+import { WatchSource } from 'vue';
+import { WsTransport } from '@camera.ui/transport/transports/ws';
+
+export declare function acquireSensorManager(cameraId: string, rpcOrContext: RPCClient | ReactiveCameraDeviceContext): CachedSensorManager;
+
+export declare interface ActivityMode extends ActivityModeState, ActivityModeActions {
+}
+
+declare interface ActivityModeActions {
+    setMode: (mode: CameraActivityMode) => void;
+    reportActivity: (hasActivity: boolean) => void;
+    resumeFromStandby: () => void;
+    resetIdleTimer: () => void;
+    dispose: () => void;
+}
+
+export declare interface ActivityModeConfig {
+    standbyTimeout?: number;
+    activityTimeout?: number;
+}
+
+declare interface ActivityModeState {
+    readonly mode: Ref<CameraActivityMode>;
+    readonly inStandby: Ref<boolean>;
+    readonly hasActivity: Ref<boolean>;
+}
+
+/* Excluded from this release type: AudioProperty */
+
+/* Excluded from this release type: AudioSensorProperties */
+
+export declare interface BaseLogger {
+    log: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    success: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    trace: (...args: unknown[]) => void;
+    attention: (...args: unknown[]) => void;
+}
+
+/* Excluded from this release type: BatteryInfoProperties */
+
+/* Excluded from this release type: BatteryProperty */
+
+declare interface CachedSensorManager {
+    manager: ReactiveSensorManager;
+    initPromise?: Promise<void>;
+}
+
+export declare const CAMERA_UI_INJECTION_KEY: InjectionKey<CameraUiContext>;
+
+export declare type CameraActivityMode = 'always-on' | 'standby' | 'activity';
+
+declare type CameraDeviceImplementation = PartialReturnType<StreamingInterface> & PartialReturnType<SnapshotInterface>;
+
+export declare interface CameraDeviceInterface extends CameraDeviceImplementation {
+    refreshStates(): Promise<RefreshedStates>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    probeStream(sourceId: string, probeConfig?: ProbeConfig, refresh?: boolean): Promise<ProbeStream | undefined>;
+    getStreamStatus(sourceId: string): Promise<string>;
+    registerSensor(sensor: SensorJSON, pluginId: string): Promise<boolean>;
+    unregisterSensor(sensorId: string): void;
+}
+
+declare type CameraIdentifier = MaybeRefOrGetter<string | ReactiveCameraDevice | undefined>;
+
+export declare interface CameraNamespaces {
+    cameraSubject: string;
+    cameraControllerRpc: string;
+}
+
+export declare interface CameraStream {
+    readonly status: Ref<StreamStatus>;
+    readonly isPlaying: Ref<boolean>;
+    readonly activeMode: Ref<'webrtc' | 'webrtc/tcp' | 'mse'>;
+    readonly activeResolution: Ref<StreamingRole>;
+    readonly hasAudio: Ref<boolean>;
+    readonly hasBackchannel: Ref<boolean>;
+    readonly error: Ref<Error | undefined>;
+    readonly isReconnecting: Ref<boolean>;
+    readonly activityMode: Ref<CameraActivityMode>;
+    readonly inStandby: Ref<boolean>;
+    readonly hasActivity: Ref<boolean>;
+    readonly isBusy: Ref<boolean>;
+    readonly hasSound: Ref<boolean>;
+    readonly hasIntercom: Ref<boolean>;
+    readonly stream: ShallowRef<ReactiveStream | undefined>;
+    readonly videoElement: ShallowRef<HTMLVideoElement | undefined>;
+    readonly containerElement: ShallowRef<HTMLElement | undefined>;
+    readonly fullscreenElement: ShallowRef<HTMLElement | undefined>;
+    readonly renderElement: ComputedRef<HTMLVideoElement | HTMLCanvasElement | undefined>;
+    readonly muted: ComputedRef<boolean>;
+    readonly paused: ComputedRef<boolean>;
+    readonly nativeWidth: Ref<number>;
+    readonly nativeHeight: Ref<number>;
+    readonly isPip: Ref<boolean>;
+    readonly supportsPip: ComputedRef<boolean>;
+    readonly isFullscreen: Ref<boolean>;
+    readonly isCameraDisabled: ComputedRef<boolean>;
+    start: () => Promise<void>;
+    stop: () => void;
+    restart: () => Promise<void>;
+    resumeFromStandby: () => void;
+    setMode: (mode: VideoStreamingMode) => Promise<void>;
+    setResolution: (resolution: StreamingRole) => Promise<void>;
+    setMicrophone: (track: MediaStreamTrack | null) => Promise<void>;
+    setActivityMode: (mode: CameraActivityMode) => void;
+    reportActivity: (hasActivity: boolean) => void;
+    setMuted: (muted: boolean) => void;
+    play: () => Promise<void>;
+    pause: () => void;
+    togglePip: () => void;
+    toggleFullscreen: () => Promise<void>;
+    captureScreenshot: () => string | null;
+}
+
+export declare interface CameraUiContext {
+    rpc: ShallowRef<RPCClient | undefined>;
+    target: Readonly<Ref<ConnectionTarget | null>>;
+    isConnected: Readonly<Ref<boolean>>;
+    endpoint: Readonly<Ref<string | undefined>>;
+    token: Readonly<Ref<string | undefined>>;
+    extraProxyQuery: Readonly<Ref<Record<string, string> | undefined>>;
+    error: Readonly<Ref<Error | undefined>>;
+    wsTransport?: WsTransport;
+    on: (event: CameraUiEventType, cb: CameraUiEventCallback) => void;
+    off: (event: CameraUiEventType, cb: CameraUiEventCallback) => void;
+}
+
+export declare type CameraUiEventCallback = () => void;
+
+export declare type CameraUiEventType = 'reconnected' | 'disconnected' | 'visibility-resumed';
+
+export declare type CameraUiPlugin = ReturnType<typeof createCameraUiPlugin>;
+
+export declare interface CameraUiPluginInput {
+    natsTransport: NatsTransport;
+    target: Ref<ConnectionTarget | null>;
+    wsTransport?: WsTransport;
+}
+
+/* Excluded from this release type: ClassifierProperty */
+
+/* Excluded from this release type: ClassifierSensorProperties */
+
+export declare function clearCameraCache(): void;
+
+export declare function clearOAuthCache(): void;
+
+export declare function clearPluginCache(): void;
+
+export declare function clearSensorCache(): void;
+
+export declare function clearSnapshotCache(): void;
+
+export declare function clearStorageCache(): void;
+
+export declare interface CodecCompatibility {
+    compatible: boolean;
+    audioCompatible: boolean;
+    videoCompatible: boolean;
+    incompatibleCodecs: string[];
+}
+
+/* Excluded from this release type: ContactProperty */
+
+/* Excluded from this release type: ContactSensorProperties */
+
+export declare interface CoreManagerInterface {
+    getFFmpegPath(): Promise<string>;
+    getServerAddresses(): Promise<string[]>;
+    getPlugin(pluginName: string): Promise<PluginInfo | undefined>;
+    getPluginsByInterface(interfaceName: PluginInterface): Promise<PluginInfo[]>;
+}
+
+export declare interface CoreManagerNamespaces {
+    coreManagerSubject: string;
+    coreManagerRpc: string;
+}
+
+export declare function createActivityMode(options: CreateActivityModeOptions): ActivityMode;
+
+declare interface CreateActivityModeOptions {
+    initialMode?: CameraActivityMode;
+    config?: ActivityModeConfig;
+    onStreamStart: () => void;
+    onStreamStop: () => void;
+    isStreamPlaying: () => boolean;
+}
+
+export declare function createCameraUiPlugin(input: CameraUiContext | CameraUiPluginInput): {
+    install(app: {
+        provide: (key: symbol, value: unknown) => void;
+    }): void;
+};
+
+export declare function createReactiveCameraDevice(rpcOrContext: RPCClient | ReactiveCameraDeviceContext, initialCamera: Camera): Promise<ReactiveCameraDevice>;
+
+export declare function createSensorManager(rpcOrContext: RPCClient | ReactiveCameraDeviceContext, cameraId: string, sensorSubjectNamespace: string, sensorRpcNamespace: string): ReactiveSensorManager;
+
+declare interface DBCamera extends BaseCamera {
+    sources: CameraInputSettings[];
+    workerAgentId?: string;
+}
+
+declare interface DetectionEventNamespaces {
+    detectionEventSubject: string;
+}
+
+export declare interface DeviceManagerInterface {
+    getCamera(cameraNameOrId: string, pluginId: string): Promise<Camera | undefined>;
+}
+
+export declare interface DeviceManagerNamespaces {
+    deviceManagerSubject: string;
+    deviceManagerRpc: string;
+}
+
+declare interface DiscoveryManagerNamespaces {
+    discoveryManagerSubject: string;
+    discoveryManagerRpc: string;
+}
+
+/* Excluded from this release type: DoorbellProperty */
+
+/* Excluded from this release type: DoorbellTriggerProperties */
+
+declare interface DownloadManagerNamespaces {
+    downloadManagerRpc: string;
+}
+
+/* Excluded from this release type: FaceProperty */
+
+/* Excluded from this release type: FaceSensorProperties */
+
+declare interface FrameWorkerDetectionNamespaces {
+    detectionRpc: string;
+}
+
+export declare interface FrameWorkerNamespaces {
+    frameWorkerChildRpc: string;
+    frameWorkerChild: string;
+}
+
+declare type FullscreenMode = 'fit' | 'scroll';
+
+/* Excluded from this release type: GarageControlProperties */
+
+/* Excluded from this release type: GarageProperty */
+
+export declare function getSnapshotUrl(cameraId: string): string | undefined;
+
+declare type HiddenCallback = () => void;
+
+/* Excluded from this release type: HumidityInfoProperties */
+
+/* Excluded from this release type: HumidityProperty */
+
+export declare const isReactiveAudioSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveAudioSensor;
+
+export declare const isReactiveBatteryInfo: (sensor: ReactiveSensor<any>) => sensor is ReactiveBatteryInfo;
+
+export declare const isReactiveClassifierSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveClassifierSensor;
+
+export declare const isReactiveContactSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveContactSensor;
+
+export declare const isReactiveDoorbellTrigger: (sensor: ReactiveSensor<any>) => sensor is ReactiveDoorbellTrigger;
+
+export declare const isReactiveFaceSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveFaceSensor;
+
+export declare const isReactiveGarageControl: (sensor: ReactiveSensor<any>) => sensor is ReactiveGarageControl;
+
+export declare const isReactiveHumidityInfo: (sensor: ReactiveSensor<any>) => sensor is ReactiveHumidityInfo;
+
+export declare const isReactiveLeakSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveLeakSensor;
+
+export declare const isReactiveLicensePlateSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveLicensePlateSensor;
+
+export declare const isReactiveLightControl: (sensor: ReactiveSensor<any>) => sensor is ReactiveLightControl;
+
+export declare const isReactiveLockControl: (sensor: ReactiveSensor<any>) => sensor is ReactiveLockControl;
+
+export declare const isReactiveMotionSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveMotionSensor;
+
+export declare const isReactiveObjectSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveObjectSensor;
+
+export declare const isReactiveOccupancySensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveOccupancySensor;
+
+export declare const isReactivePTZControl: (sensor: ReactiveSensor<any>) => sensor is ReactivePTZControl;
+
+export declare const isReactiveSecuritySystem: (sensor: ReactiveSensor<any>) => sensor is ReactiveSecuritySystem;
+
+export declare const isReactiveSirenControl: (sensor: ReactiveSensor<any>) => sensor is ReactiveSirenControl;
+
+export declare const isReactiveSmokeSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveSmokeSensor;
+
+export declare const isReactiveSwitchControl: (sensor: ReactiveSensor<any>) => sensor is ReactiveSwitchControl;
+
+export declare const isReactiveTemperatureInfo: (sensor: ReactiveSensor<any>) => sensor is ReactiveTemperatureInfo;
+
+/* Excluded from this release type: LeakProperty */
+
+/* Excluded from this release type: LeakSensorProperties */
+
+/* Excluded from this release type: LicensePlateProperty */
+
+/* Excluded from this release type: LicensePlateSensorProperties */
+
+/* Excluded from this release type: LightControlProperties */
+
+/* Excluded from this release type: LightProperty */
+
+/* Excluded from this release type: LockControlProperties */
+
+/* Excluded from this release type: LockProperty */
+
+/* Excluded from this release type: MotionProperty */
+
+/* Excluded from this release type: MotionSensorProperties */
+
+export declare class NamespaceManager {
+    static coreManagerNamespaces(): CoreManagerNamespaces {
+        return {
+            coreManagerSubject: 'coreManager.subscriber',
+            coreManagerRpc: 'coreManager.rpc',
+        };
+    }
+
+    static deviceManagerNamespaces(): DeviceManagerNamespaces {
+        return {
+            deviceManagerSubject: 'deviceManager.subscriber',
+            deviceManagerRpc: 'deviceManager.rpc',
+        };
+    }
+
+    static discoveryManagerNamespaces(): DiscoveryManagerNamespaces {
+        return {
+            discoveryManagerSubject: 'discoveryManager.subscriber',
+            discoveryManagerRpc: 'discoveryManager.rpc',
+        };
+    }
+
+    static pluginNamespaces(pluginId: string): PluginNamespaces {
+        return {
+            pluginDeviceManagerSubject: `plugin.${pluginId}.deviceManager.subscriber`,
+            pluginChildRpc: `plugin.${pluginId}.child.rpc`,
+            pluginChild: `plugin.${pluginId}.child`,
+            pluginStorageRpc: `plugin.${pluginId}.storage.rpc`,
+        };
+    }
+
+    static cameraNamespaces(cameraId: string): CameraNamespaces {
+        return {
+            cameraSubject: `camera.${cameraId}.subscriber`,
+            cameraControllerRpc: `camera.${cameraId}.controller.rpc`,
+        };
+    }
+
+    static frameWorkerNamespaces(cameraId: string): FrameWorkerNamespaces {
+        return {
+            frameWorkerChildRpc: `camera.${cameraId}.frameWorker.child.rpc`,
+            frameWorkerChild: `camera.${cameraId}.frameWorker.child`,
+        };
+    }
+
+    static pluginCameraNamespaces(pluginId: string, cameraId: string): PluginCameraNamespaces {
+        return {
+            cameraInterfacesRpc: `plugin.${pluginId}.camera.${cameraId}.cameraInterfaces.rpc`,
+            cameraStorageRpc: `plugin.${pluginId}.camera.${cameraId}.cameraStorage.rpc`,
+            cameraImplRpc: `plugin.${pluginId}.camera.${cameraId}.impl.rpc`,
+        };
+    }
+
+    static pluginSensorNamespaces(pluginId: string, cameraId: string, sensorId: string): PluginSensorNamespaces {
+        return {
+            sensorStorageRpc: `plugin.${pluginId}.camera.${cameraId}.sensor.${sensorId}.storage.rpc`,
+        };
+    }
+
+    static sensorControllerNamespaces(cameraId: string): SensorControllerNamespaces {
+        return {
+            sensorSubject: `camera.${cameraId}.sensors.subject`,
+            sensorRpc: `camera.${cameraId}.sensors.rpc`,
+            sensorWriteSubject: `camera.${cameraId}.sensors.writes`,
+        };
+    }
+
+    static sensorEventNamespaces(cameraId: string, sensorId: string): SensorEventNamespaces {
+        return {
+            sensorSubject: `camera.${cameraId}.sensor.${sensorId}.subject`,
+        };
+    }
+
+    static sensorProviderNamespaces(pluginId: string, cameraId: string, sensorId: string): SensorProviderNamespaces {
+        return {
+            sensorRpc: `plugin.${pluginId}.camera.${cameraId}.sensor.${sensorId}.rpc`,
+        };
+    }
+
+    static frameWorkerDetectionNamespaces(cameraId: string): FrameWorkerDetectionNamespaces {
+        return {
+            detectionRpc: `camera.${cameraId}.frameWorker.detection.rpc`,
+        };
+    }
+
+    static detectionEventNamespaces(cameraId: string): DetectionEventNamespaces {
+        return {
+            detectionEventSubject: `camera.${cameraId}.events.subject`,
+        };
+    }
+
+    static sensorControllerRpc(cameraId: string): string {
+        return `camera.${cameraId}.sensors.controller.rpc`;
+    }
+
+    static terminalManagerNamespaces(): TerminalManagerNamespaces {
+        return {
+            terminalManagerSubject: 'terminalManager.subscriber',
+            terminalManagerRpc: 'terminalManager.rpc',
+        };
+    }
+
+    static downloadManagerNamespaces(): DownloadManagerNamespaces {
+        return {
+            downloadManagerRpc: 'downloadManager.rpc',
+        };
+    }
+
+    static notificationManagerNamespaces(): NotificationManagerNamespaces {
+        return {
+            notificationsPublishSubject: 'notifications.publish',
+        };
+    }
+
+    static workerAgentRpc(agentId: string): string {
+        return `worker.${agentId}.rpc`;
+    }
+
+    static workerHeartbeat(): string {
+        return 'workers.heartbeat';
+    }
+
+    static workerDisconnect(): string {
+        return 'workers.disconnect';
+    }
+}
+
+export { NatsStatus }
+
+declare interface NotificationManagerNamespaces {
+    notificationsPublishSubject: string;
+}
+
+/* Excluded from this release type: ObjectProperty */
+
+/* Excluded from this release type: ObjectSensorProperties */
+
+/* Excluded from this release type: OccupancyProperty */
+
+/* Excluded from this release type: OccupancySensorProperties */
+
+declare type PartialReturnType<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => Promise<infer R>
+    ? (...args: A) => Promise<R | undefined>
+    : T[K] extends (...args: infer A) => infer R
+    ? (...args: A) => R | undefined
+    : T[K];
+};
+
+export declare interface PluginCameraNamespaces {
+    cameraInterfacesRpc: string;
+    cameraStorageRpc: string;
+    cameraImplRpc: string;
+}
+
+export declare interface PluginNamespaces {
+    pluginDeviceManagerSubject: string;
+    pluginChildRpc: string;
+    pluginChild: string;
+    pluginStorageRpc: string;
+}
+
+export declare interface PluginSensorNamespaces {
+    sensorStorageRpc: string;
+}
+
+/* Excluded from this release type: PTZControlProperties */
+
+/* Excluded from this release type: PTZProperty */
+
+export declare interface ReactiveAudioSensor extends ReactiveSensor<AudioSensorProperties> {
+    readonly type: typeof SensorType.Audio;
+    getProperty(property: typeof AudioProperty.Detected): boolean | undefined;
+    getProperty(property: typeof AudioProperty.Detections): Detection[] | undefined;
+    getProperty(property: typeof AudioProperty.Decibels): number | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactiveBatteryInfo extends ReactiveSensor<BatteryInfoProperties> {
+    readonly type: typeof SensorType.Battery;
+    getProperty(property: typeof BatteryProperty.Level): number | undefined;
+    getProperty(property: typeof BatteryProperty.Low): boolean | undefined;
+    getProperty(property: typeof BatteryProperty.Charging): ChargingState | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactiveCameraDevice {
+    readonly id: string;
+    readonly name: Ref<string>;
+    readonly room: Ref<string>;
+    readonly nativeId: Ref<string | undefined>;
+    readonly disabled: Ref<boolean>;
+    readonly snooze: Ref<boolean>;
+    readonly isCloud: Ref<boolean>;
+    readonly connected: Ref<boolean>;
+    readonly frameWorkerConnected: Ref<boolean>;
+    readonly sources: Ref<CameraSource[]>;
+    readonly streamSource: Ref<CameraSource | undefined>;
+    readonly snapshotSource: Ref<CameraSource | undefined>;
+    readonly highResolutionSource: Ref<CameraSource | undefined>;
+    readonly midResolutionSource: Ref<CameraSource | undefined>;
+    readonly lowResolutionSource: Ref<CameraSource | undefined>;
+    readonly capabilities: Ref<SensorType[]>;
+    readonly hasLight: ComputedRef<boolean>;
+    readonly hasSiren: ComputedRef<boolean>;
+    readonly hasDoorbell: ComputedRef<boolean>;
+    readonly hasBattery: ComputedRef<boolean>;
+    readonly hasAudioSensor: ComputedRef<boolean>;
+    readonly hasMotionSensor: ComputedRef<boolean>;
+    readonly hasObjectSensor: ComputedRef<boolean>;
+    readonly hasPtz: ComputedRef<boolean>;
+    readonly camera: Ref<Camera>;
+    readonly snapshot: ShallowRef<ArrayBuffer | undefined>;
+    readonly snapshotLoading: Ref<boolean>;
+    fetchSnapshot: (sourceId?: string, forceNew?: boolean) => Promise<ArrayBuffer | undefined>;
+    probeStream: (sourceId?: string, probeConfig?: ProbeConfig, refresh?: boolean) => Promise<ProbeStream | undefined>;
+    streamUrl: (sourceId: string) => Promise<string | undefined>;
+    refreshStates: () => Promise<void>;
+    reconnect: () => Promise<void>;
+    close: () => Promise<void>;
+}
+
+declare interface ReactiveCameraDeviceContext {
+    rpc: ShallowRef<RPCClient | undefined>;
+}
+
+export declare interface ReactiveClassifierSensor extends ReactiveSensor<ClassifierSensorProperties> {
+    readonly type: typeof SensorType.Classifier;
+    getProperty(property: typeof ClassifierProperty.Detected): boolean | undefined;
+    getProperty(property: typeof ClassifierProperty.Detections): Detection[] | undefined;
+    getProperty(property: typeof ClassifierProperty.Labels): string[] | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactiveContactSensor extends ReactiveSensor<ContactSensorProperties> {
+    readonly type: typeof SensorType.Contact;
+    getProperty(property: typeof ContactProperty.Detected): boolean | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactiveCoreManager extends Omit<CoreManager, 'connectToPlugin' | 'signRequest' | 'onEvent'> {
+}
+
+export declare interface ReactiveDeviceManager {
+    getCamera: (cameraIdOrName: string) => Promise<ReactiveCameraDevice | undefined>;
+}
+
+export declare interface ReactiveDoorbellTrigger extends ReactiveSensor<DoorbellTriggerProperties> {
+    readonly type: typeof SensorType.Doorbell;
+    getProperty(property: typeof DoorbellProperty.Ring): boolean | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactiveFaceSensor extends ReactiveSensor<FaceSensorProperties> {
+    readonly type: typeof SensorType.Face;
+    getProperty(property: typeof FaceProperty.Detected): boolean | undefined;
+    getProperty(property: typeof FaceProperty.Detections): FaceDetection[] | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactiveGarageControl extends ReactiveSensor<GarageControlProperties> {
+    readonly type: typeof SensorType.Garage;
+    getProperty(property: typeof GarageProperty.CurrentState): GarageState | undefined;
+    getProperty(property: typeof GarageProperty.TargetState): GarageState | undefined;
+    getProperty(property: typeof GarageProperty.ObstructionDetected): boolean | undefined;
+    getProperty(property: string): unknown;
+    setProperty(property: typeof GarageProperty.TargetState, value: GarageState): Promise<void>;
+    setProperty(property: string, value: unknown): Promise<void>;
+}
+
+export declare interface ReactiveHumidityInfo extends ReactiveSensor<HumidityInfoProperties> {
+    readonly type: typeof SensorType.Humidity;
+    getProperty(property: typeof HumidityProperty.Current): number | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactiveLeakSensor extends ReactiveSensor<LeakSensorProperties> {
+    readonly type: typeof SensorType.Leak;
+    getProperty(property: typeof LeakProperty.Detected): boolean | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactiveLicensePlateSensor extends ReactiveSensor<LicensePlateSensorProperties> {
+    readonly type: typeof SensorType.LicensePlate;
+    getProperty(property: typeof LicensePlateProperty.Detected): boolean | undefined;
+    getProperty(property: typeof LicensePlateProperty.Detections): LicensePlateDetection[] | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactiveLightControl extends ReactiveSensor<LightControlProperties> {
+    readonly type: typeof SensorType.Light;
+    getProperty(property: typeof LightProperty.On): boolean | undefined;
+    getProperty(property: typeof LightProperty.Brightness): number | undefined;
+    getProperty(property: string): unknown;
+    setProperty(property: typeof LightProperty.On, value: boolean): Promise<void>;
+    setProperty(property: typeof LightProperty.Brightness, value: number): Promise<void>;
+    setProperty(property: string, value: unknown): Promise<void>;
+}
+
+export declare interface ReactiveLockControl extends ReactiveSensor<LockControlProperties> {
+    readonly type: typeof SensorType.Lock;
+    getProperty(property: typeof LockProperty.CurrentState): LockState | undefined;
+    getProperty(property: typeof LockProperty.TargetState): LockState | undefined;
+    getProperty(property: string): unknown;
+    setProperty(property: typeof LockProperty.CurrentState, value: LockState): Promise<void>;
+    setProperty(property: typeof LockProperty.TargetState, value: LockState): Promise<void>;
+    setProperty(property: string, value: unknown): Promise<void>;
+}
+
+export declare interface ReactiveMotionSensor extends ReactiveSensor<MotionSensorProperties> {
+    readonly type: typeof SensorType.Motion;
+    getProperty(property: typeof MotionProperty.Detected): boolean | undefined;
+    getProperty(property: typeof MotionProperty.Detections): Detection[] | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactiveObjectSensor extends ReactiveSensor<ObjectSensorProperties> {
+    readonly type: typeof SensorType.Object;
+    getProperty(property: typeof ObjectProperty.Detected): boolean | undefined;
+    getProperty(property: typeof ObjectProperty.Detections): Detection[] | undefined;
+    getProperty(property: typeof ObjectProperty.Labels): string[] | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactiveOccupancySensor extends ReactiveSensor<OccupancySensorProperties> {
+    readonly type: typeof SensorType.Occupancy;
+    getProperty(property: typeof OccupancyProperty.Detected): boolean | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactivePTZControl extends ReactiveSensor<PTZControlProperties> {
+    readonly type: typeof SensorType.PTZ;
+    getProperty(property: typeof PTZProperty.Position): PTZPosition | undefined;
+    getProperty(property: typeof PTZProperty.Moving): boolean | undefined;
+    getProperty(property: typeof PTZProperty.Presets): string[] | undefined;
+    getProperty(property: typeof PTZProperty.Velocity): PTZDirection | undefined;
+    getProperty(property: typeof PTZProperty.TargetPreset): string | undefined;
+    getProperty(property: string): unknown;
+    setProperty(property: typeof PTZProperty.Position, value: PTZPosition): Promise<void>;
+    setProperty(property: typeof PTZProperty.Moving, value: boolean): Promise<void>;
+    setProperty(property: typeof PTZProperty.Velocity, value: PTZDirection): Promise<void>;
+    setProperty(property: typeof PTZProperty.TargetPreset, value: string): Promise<void>;
+    setProperty(property: string, value: unknown): Promise<void>;
+}
+
+export declare interface ReactiveSecuritySystem extends ReactiveSensor<SecuritySystemProperties> {
+    readonly type: typeof SensorType.SecuritySystem;
+    getProperty(property: typeof SecuritySystemProperty.CurrentState): SecuritySystemState | undefined;
+    getProperty(property: typeof SecuritySystemProperty.TargetState): SecuritySystemState | undefined;
+    getProperty(property: string): unknown;
+    setProperty(property: typeof SecuritySystemProperty.CurrentState, value: SecuritySystemState): Promise<void>;
+    setProperty(property: typeof SecuritySystemProperty.TargetState, value: SecuritySystemState): Promise<void>;
+    setProperty(property: string, value: unknown): Promise<void>;
+}
+
+export declare interface ReactiveSensor<TProperties extends object = Record<string, unknown>> {
+    readonly id: string;
+    readonly type: SensorType;
+    readonly name: string;
+    readonly displayName: Ref<string>;
+    readonly pluginId: string;
+    readonly capabilities: Ref<string[]>;
+    readonly properties: TProperties;
+    getProperty<T = unknown>(property: string): T | undefined;
+    setProperty(property: string, value: unknown): Promise<void>;
+    setDisplayName(displayName: string): Promise<void>;
+    hasCapability(capability: string): boolean;
+    onCapabilitiesChanged(callback: (capabilities: string[]) => void): () => void;
+}
+
+export declare interface ReactiveSensorManager {
+    readonly sensors: ComputedRef<ReactiveSensor[]>;
+    readonly isInitialized: ComputedRef<boolean>;
+    ensureInitialized(): Promise<void>;
+    reconnect(): Promise<void>;
+    getSensor(sensorId: string): ReactiveSensor | undefined;
+    getSensorsByType(type: SensorType): ReactiveSensor[];
+    hasSensorType(type: SensorType): boolean;
+    setDisplayName(sensorId: string, displayName: string): Promise<void>;
+    close(): void;
+}
+
+export declare interface ReactiveSirenControl extends ReactiveSensor<SirenControlProperties> {
+    readonly type: typeof SensorType.Siren;
+    getProperty(property: typeof SirenProperty.Active): boolean | undefined;
+    getProperty(property: typeof SirenProperty.Volume): number | undefined;
+    getProperty(property: string): unknown;
+    setProperty(property: typeof SirenProperty.Active, value: boolean): Promise<void>;
+    setProperty(property: typeof SirenProperty.Volume, value: number): Promise<void>;
+    setProperty(property: string, value: unknown): Promise<void>;
+}
+
+export declare interface ReactiveSmokeSensor extends ReactiveSensor<SmokeSensorProperties> {
+    readonly type: typeof SensorType.Smoke;
+    getProperty(property: typeof SmokeProperty.Detected): boolean | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare interface ReactiveStorage {
+    readonly proxy: Promisify<StorageRPC>;
+    readonly config: ShallowRef<SchemaConfig | undefined>;
+    readonly isLoading: Ref<boolean>;
+    readonly error: Ref<Error | undefined>;
+    getConfig(): Promise<SchemaConfig | undefined>;
+    setValue<T = unknown>(key: string, value: T): Promise<void>;
+    setConfig(newConfig: Record<string, unknown>): Promise<void>;
+    submitValue(key: string, value: unknown): Promise<FormSubmitResponse | void>;
+}
+
+export declare interface ReactiveStream {
+    readonly status: Ref<StreamStatus>;
+    readonly activeMode: Ref<Exclude<VideoStreamingMode, 'auto'>>;
+    readonly requestedMode: Ref<VideoStreamingMode>;
+    readonly activeResolution: Ref<StreamingRole>;
+    readonly requestedResolution: Ref<StreamingRole>;
+    readonly source: Ref<CameraSource | undefined>;
+    readonly hasVideo: Ref<boolean>;
+    readonly hasAudio: Ref<boolean>;
+    readonly hasBackchannel: Ref<boolean>;
+    readonly isPlaying: Ref<boolean>;
+    readonly error: Ref<Error | undefined>;
+    readonly probeInfo: Ref<ProbeStream | undefined>;
+    readonly muted: Ref<boolean>;
+    readonly paused: Ref<boolean>;
+    readonly nativeWidth: Ref<number>;
+    readonly nativeHeight: Ref<number>;
+    start: () => Promise<void>;
+    stop: () => void;
+    restart: () => Promise<void>;
+    setMode: (mode: VideoStreamingMode) => Promise<void>;
+    setResolution: (resolution: StreamingRole) => Promise<void>;
+    setMicrophone: (track: MediaStreamTrack | null) => Promise<void>;
+    setMuted: (muted: boolean) => void;
+    play: () => Promise<void>;
+    pause: () => void;
+}
+
+export declare interface ReactiveSwitchControl extends ReactiveSensor<SwitchControlProperties> {
+    readonly type: typeof SensorType.Switch;
+    getProperty(property: typeof SwitchProperty.On): boolean | undefined;
+    getProperty(property: string): unknown;
+    setProperty(property: typeof SwitchProperty.On, value: boolean): Promise<void>;
+    setProperty(property: string, value: unknown): Promise<void>;
+}
+
+export declare interface ReactiveTemperatureInfo extends ReactiveSensor<TemperatureInfoProperties> {
+    readonly type: typeof SensorType.Temperature;
+    getProperty(property: typeof TemperatureProperty.Current): number | undefined;
+    getProperty(property: string): unknown;
+}
+
+export declare function refreshClientSubscriptions(): void;
+
+declare interface RefreshedStates {
+    camera: Camera;
+    cameraState: boolean;
+    frameWorkerState: boolean;
+    sensorStates: Record<string, SensorRefreshedState>;
+}
+
+export declare function releaseSensorManager(cameraId: string): void;
+
+export declare function resetClientState(): void;
+
+export declare function rpcCall<T>(rpcRef: Readonly<ShallowRef<RPCClient | undefined>>, fn: (rpc: RPCClient) => Promise<T>, options?: RpcCallOptions): Promise<T>;
+
+export declare interface RpcCallOptions {
+    maxRetries?: number;
+    awaitConnect?: boolean;
+    connectTimeoutMs?: number;
+    retryDelayMs?: (attempt: number) => number;
+    shouldRetry?: (err: unknown, attempt: number) => boolean;
+    signal?: AbortSignal;
+}
+
+export { RPCClient }
+
+/* Excluded from this release type: SecuritySystemProperties */
+
+/* Excluded from this release type: SecuritySystemProperty */
+
+declare interface SensorAddedEvent {
+    cameraId: string;
+    sensor: StoredSensorData;
+    state: SensorRefreshedState;
+}
+
+declare interface SensorCapabilitiesChangedEvent {
+    cameraId: string;
+    sensorId: string;
+    capabilities: string[];
+}
+
+export declare interface SensorControllerNamespaces {
+    sensorSubject: string;
+    sensorRpc: string;
+    sensorWriteSubject: string;
+}
+
+export declare interface SensorControllerRPC {
+    getSensors(): StoredSensorData[];
+    getSensor(sensorId: string): StoredSensorData | undefined;
+    getSensorByType(sensorType: SensorType): StoredSensorData | undefined;
+    getSensorsByType(sensorType: SensorType): StoredSensorData[];
+    getSensorState(sensorId: string): SensorRefreshedState;
+    getSensorStates(): Record<string, SensorRefreshedState>;
+    getPropertyValue(sensorId: string, property: string): unknown;
+    getAllPropertyValues(sensorId: string): Record<string, unknown>;
+    setDisplayName(sensorId: string, displayName: string): void;
+}
+
+declare interface SensorDisplayNameChangedEvent {
+    cameraId: string;
+    sensorId: string;
+    displayName: string;
+}
+
+export declare interface SensorEventMessage {
+    type: 'property:changed' | 'sensor:added' | 'sensor:removed' | 'sensor:displayName:changed' | 'sensor:capabilities:changed';
+    data: PropertyChangedEvent | SensorAddedEvent | SensorRemovedEvent | SensorDisplayNameChangedEvent | SensorCapabilitiesChangedEvent;
+}
+
+export declare interface SensorEventNamespaces {
+    sensorSubject: string;
+}
+
+export declare interface SensorProviderNamespaces {
+    sensorRpc: string;
+}
+
+export declare interface SensorRefreshedState {
+    type: SensorType;
+    properties: Record<string, unknown>;
+    capabilities: string[];
+    displayName?: string;
+}
+
+declare interface SensorRemovedEvent {
+    cameraId: string;
+    sensorId: string;
+    sensorType: SensorType;
+}
+
+/* Excluded from this release type: SirenControlProperties */
+
+/* Excluded from this release type: SirenProperty */
+
+/* Excluded from this release type: SmokeProperty */
+
+/* Excluded from this release type: SmokeSensorProperties */
+
+export declare interface StorageRPC {
+    getValue<T = string>(key: string, defaultValue?: T): Promise<T | undefined>;
+    setValue<T = string>(key: string, newValue: T): Promise<void>;
+    submitValue(key: string, newValue: unknown): Promise<FormSubmitResponse | void>;
+    hasValue(key: string): boolean;
+    getConfig(): Promise<SchemaConfig>;
+    setConfig(newConfig: Record<string, unknown>): Promise<void>;
+    getSchema<T>(key: string): T | undefined;
+    hasSchema(key: string): boolean;
+}
+
+export declare interface StoredSensorData {
+    id: string;
+    type: SensorType;
+    name: string;
+    displayName: string;
+    pluginId: string;
+    properties: Record<string, unknown>;
+    capabilities: string[];
+    requiresFrames?: boolean;
+    modelSpec?: ModelSpec;
+}
+
+export declare const STREAM_CONFIG: {
+    readonly WEBRTC: {
+        readonly RECONNECT_DELAY: 1000;
+        readonly CONNECT_TIMEOUT: 10000;
+        readonly WS_CONNECT_TIMEOUT: 5000;
+        readonly ICE_SERVERS: readonly [{
+            readonly urls: "stun:stun.l.google.com:19302";
+        }];
+    };
+    readonly MSE: {
+        readonly BUFFER_SIZE: number;
+        readonly BUFFER_WINDOW: 5;
+    };
+    readonly CODECS: {
+        readonly DEFAULT: readonly ["avc1.640029", "avc1.64002A", "avc1.640033", "hvc1.1.6.L153.B0", "mp4a.40.2", "mp4a.40.5", "flac", "opus"];
+        readonly WEBRTC_VIDEO: readonly ["H264", "VP8", "VP9"];
+        readonly WEBRTC_AUDIO: readonly ["opus", "G722", "PCMU", "PCMA"];
+    };
+};
+
+export declare interface StreamOptions {
+    camera: MaybeRefOrGetter<ReactiveCameraDevice | undefined>;
+    videoElement: MaybeRefOrGetter<HTMLVideoElement | undefined | null>;
+    mode?: MaybeRefOrGetter<VideoStreamingMode>;
+    resolution?: MaybeRefOrGetter<StreamingRole>;
+    autoStart?: boolean;
+    manageLifecycle?: boolean;
+    wsReconnectTimeout?: number;
+    webrtcConnectTimeout?: number;
+}
+
+export declare type StreamStatus = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'error' | 'closed';
+
+/* Excluded from this release type: SwitchControlProperties */
+
+/* Excluded from this release type: SwitchProperty */
+
+/* Excluded from this release type: TemperatureInfoProperties */
+
+/* Excluded from this release type: TemperatureProperty */
+
+export declare interface TerminalManagerInterface {
+    createSession(options?: TerminalOptions): Promise<TerminalSessionInfo>;
+    generateOutput(sessionId: string): AsyncGenerator<Uint8Array>;
+    writeInput(sessionId: string, data: string): Promise<void>;
+    resize(sessionId: string, dimensions: { cols: number; rows: number }): Promise<void>;
+    closeSession(sessionId: string): Promise<void>;
+}
+
+export declare interface TerminalManagerNamespaces {
+    terminalManagerSubject: string;
+    terminalManagerRpc: string;
+}
+
+export declare interface TerminalOptions {
+    cols?: number;
+    rows?: number;
+    cwd?: string;
+    shell?: string;
+    env?: Record<string, string>;
+}
+
+export declare interface TerminalSessionInfo {
+    sessionId: string;
+    pid: number;
+    dimensions: { cols: number; rows: number };
+}
+
+export declare function useAudioSensor(camera: CameraIdentifier): UseSensorTypedReturn<ReactiveAudioSensor>;
+
+export declare function useCameraById(cameraIdOrName: MaybeRefOrGetter<string>): UseCameraByIdReturn;
+
+export declare interface UseCameraByIdReturn {
+    camera: ShallowRef<ReactiveCameraDevice | undefined>;
+    isLoading: ComputedRef<boolean>;
+    error: Ref<Error | undefined>;
+    refresh: () => Promise<void>;
+}
+
+export declare function useCameraStorage(camera: CameraIdentifier, pluginName: MaybeRefOrGetter<string>): UseStorageReturn;
+
+export declare function useCameraStream(options: UseCameraStreamOptions): CameraStream;
+
+export declare interface UseCameraStreamOptions {
+    camera: MaybeRefOrGetter<string | ReactiveCameraDevice>;
+    mode?: MaybeRefOrGetter<VideoStreamingMode>;
+    resolution?: MaybeRefOrGetter<StreamingRole>;
+    activityMode?: MaybeRefOrGetter<CameraActivityMode>;
+    activityConfig?: ActivityModeConfig;
+    autoStart?: MaybeRefOrGetter<boolean>;
+    startDelay?: number;
+    isolated?: boolean;
+    canvasStyle?: MaybeRefOrGetter<HTMLAttributes['style']>;
+    canvasClass?: MaybeRefOrGetter<HTMLAttributes['class']>;
+    videoStyle?: MaybeRefOrGetter<HTMLAttributes['style']>;
+    videoClass?: MaybeRefOrGetter<HTMLAttributes['class']>;
+}
+
+export declare function useCameraUi(): CameraUiContext;
+
+export declare function useClassifierSensors(camera: CameraIdentifier): UseSensorsTypedReturn<ReactiveClassifierSensor>;
+
+export declare function useCoreManager(): ReactiveCoreManager;
+
+export declare function useCuiFullscreen(target: MaybeRefOrGetter<HTMLElement | null | undefined>, options?: UseCuiFullscreenOptions): UseCuiFullscreenReturn;
+
+export declare interface UseCuiFullscreenOptions {
+    mode?: FullscreenMode;
+}
+
+export declare interface UseCuiFullscreenReturn {
+    readonly isFullscreen: ComputedRef<boolean>;
+    readonly isSupported: ComputedRef<boolean>;
+    enter: () => Promise<void>;
+    exit: () => Promise<void>;
+    toggle: () => Promise<void>;
+}
+
+export declare function useDeviceManager(): ReactiveDeviceManager;
+
+export declare function useFaceSensor(camera: CameraIdentifier): UseSensorTypedReturn<ReactiveFaceSensor>;
+
+export declare function useLicensePlateSensor(camera: CameraIdentifier): UseSensorTypedReturn<ReactiveLicensePlateSensor>;
+
+export declare function useMotionSensor(camera: CameraIdentifier): UseSensorTypedReturn<ReactiveMotionSensor>;
+
+export declare function useOAuth(pluginName: string): UseOAuthReturn;
+
+export declare interface UseOAuthReturn {
+    readonly state: Ref<OAuthState>;
+    readonly metadata: Ref<OAuthMetadata | null>;
+    startDeviceFlow(scope: string[]): Promise<void>;
+    startAuthCodeFlow(scope: string[]): Promise<void>;
+    cancel(): Promise<void>;
+    disconnect(): Promise<void>;
+    refresh(): Promise<void>;
+}
+
+export declare function useObjectSensor(camera: CameraIdentifier): UseSensorTypedReturn<ReactiveObjectSensor>;
+
+export declare function usePlugin(pluginName: MaybeRefOrGetter<string>): UsePluginReturn;
+
+export declare interface UsePluginReturn {
+    plugin: ShallowRef<Promisify<BasePlugin & PluginInterfaces> | undefined>;
+    contract: Ref<PluginContract | undefined>;
+    isLoading: ComputedRef<boolean>;
+    error: Ref<Error | undefined>;
+    refresh: () => Promise<void>;
+}
+
+export declare function usePluginStorage(pluginName: MaybeRefOrGetter<string>): UseStorageReturn;
+
+export declare function usePTZControl(camera: CameraIdentifier): UseSensorTypedReturn<ReactivePTZControl>;
+
+export declare function useRpcCall<T>(fn: (rpc: RPCClient) => Promise<T>, options?: UseRpcCallOptions): UseRpcCallReturn<T>;
+
+export declare interface UseRpcCallOptions extends RpcCallOptions {
+    immediate?: boolean;
+    watch?: WatchSource[];
+    refetchOnReconnect?: boolean;
+}
+
+export declare interface UseRpcCallReturn<T> {
+    readonly data: ShallowRef<T | undefined>;
+    readonly loading: Ref<boolean>;
+    readonly error: Ref<Error | undefined>;
+    execute(): Promise<T | undefined>;
+    refresh(): Promise<T | undefined>;
+}
+
+export declare function useRpcSubscription(subscribeFn: (rpc: RPCClient) => Promise<() => void>, options?: UseRpcSubscriptionOptions): UseRpcSubscriptionReturn;
+
+export declare interface UseRpcSubscriptionOptions {
+    onError?: (err: unknown) => void;
+    maxRetries?: number;
+    retryDelayMs?: (attempt: number) => number;
+}
+
+export declare interface UseRpcSubscriptionReturn {
+    readonly isActive: Ref<boolean>;
+    resubscribe(): Promise<void>;
+}
+
+export declare function useSensorById(camera: CameraIdentifier, sensorId: MaybeRefOrGetter<string | undefined>): UseSensorReturn;
+
+export declare function useSensorByType(camera: CameraIdentifier, sensorType: MaybeRefOrGetter<SensorType>): UseSensorReturn;
+
+export declare interface UseSensorReturn {
+    sensor: ShallowRef<ReactiveSensor<any> | undefined>;
+    isLoading: ComputedRef<boolean>;
+    error: Ref<Error | undefined>;
+}
+
+export declare function useSensors(camera: CameraIdentifier): UseSensorsReturn;
+
+export declare function useSensorsByType(camera: CameraIdentifier, sensorType: MaybeRefOrGetter<SensorType>): UseSensorsReturn;
+
+export declare interface UseSensorsReturn {
+    sensors: ComputedRef<ReactiveSensor<any>[]>;
+    isLoading: ComputedRef<boolean>;
+    error: Ref<Error | undefined>;
+}
+
+export declare function useSensorStorage(camera: CameraIdentifier, sensorId: MaybeRefOrGetter<string | undefined>, pluginId: MaybeRefOrGetter<string | undefined>): UseStorageReturn;
+
+export declare interface UseSensorsTypedReturn<T extends ReactiveSensor<any> = ReactiveSensor> {
+    sensors: ComputedRef<T[]>;
+    isLoading: ComputedRef<boolean>;
+    error: Ref<Error | undefined>;
+}
+
+export declare interface UseSensorTypedReturn<T extends ReactiveSensor<any> = ReactiveSensor<any>> {
+    sensor: ShallowRef<T | undefined>;
+    isLoading: ComputedRef<boolean>;
+    error: Ref<Error | undefined>;
+}
+
+export declare function useSnapshot(cameraIdOrName: MaybeRefOrGetter<string | DBCamera>): UseSnapshotReturn;
+
+export declare interface UseSnapshotReturn {
+    snapshot: ShallowRef<ArrayBuffer | undefined>;
+    snapshotSrc: ComputedRef<string | undefined>;
+    isLoading: ComputedRef<boolean>;
+    refresh: () => Promise<void>;
+}
+
+export declare interface UseStorageReturn {
+    config: ShallowRef<SchemaConfig | undefined>;
+    isLoading: ComputedRef<boolean>;
+    error: Ref<Error | undefined>;
+    getConfig(): Promise<SchemaConfig | undefined>;
+    setValue<T = unknown>(key: string, value: T): Promise<void>;
+    setConfig(newConfig: Record<string, unknown>): Promise<void>;
+    submitValue(key: string, value: unknown): Promise<FormSubmitResponse | void>;
+    isConnected: Ref<boolean>;
+}
+
+export declare function useTabVisibility(): UseTabVisibilityReturn;
+
+export declare interface UseTabVisibilityReturn {
+    readonly isVisible: ComputedRef<boolean>;
+    onTabHidden(cb: HiddenCallback): () => void;
+    onTabPaused(cb: HiddenCallback, options?: {
+        delayMs?: number;
+    }): () => void;
+    onTabVisible(cb: VisibleCallback): () => void;
+}
+
+export declare function useTerminal(): UseTerminalReturn;
+
+export declare interface UseTerminalOptions extends TerminalOptions {
+    onData?: (data: Uint8Array) => void;
+    onClose?: () => void;
+    onError?: (error: Error) => void;
+}
+
+export declare interface UseTerminalReturn {
+    sessionId: Readonly<ShallowRef<string | undefined>>;
+    isConnected: Readonly<Ref<boolean>>;
+    isConnecting: Readonly<Ref<boolean>>;
+    isClientConnected: Readonly<Ref<boolean>>;
+    error: Readonly<Ref<Error | undefined>>;
+    dimensions: Readonly<Ref<{
+        cols: number;
+        rows: number;
+    }>>;
+    connect: (options?: UseTerminalOptions) => Promise<void>;
+    write: (data: string) => Promise<void>;
+    resize: (dimensions: {
+        cols: number;
+        rows: number;
+    }) => Promise<void>;
+    close: () => Promise<void>;
+}
+
+export declare function useTopmostFullscreenElement(): ComputedRef<HTMLElement | null>;
+
+export declare type VideoStreamingMode = 'webrtc' | 'webrtc/tcp' | 'mse' | 'auto';
+
+declare type VisibleCallback = (info: {
+    hiddenMs: number;
+}) => void;
+
+
+export * from "@camera.ui/sdk";
+export * from "@camera.ui/sdk/internal";
+
+export { }