@camera.ui/browser 0.0.109 → 0.0.111

package/dist/types/packages/types/src/index.d.ts

@@ -1,6 +1,7 @@
 import type { Observable, ReplaySubject, Subject, Subscription } from 'rxjs';
 import type sharp from 'sharp';
 import type { ConnectionState, RTCIceCandidate, RTCSessionDescription, RtpPacket } from 'werift';
+export type { Observable, ReplaySubject, Subject, Subscription } from 'rxjs';
 export type { ConnectionState, RTCIceCandidate, RTCSessionDescription, RtpPacket, sharp };
 export type JSONObject = Record<string, JSONValue>;
 export interface JSONValue {
@@ -11,19 +12,23 @@ export type Path = (number | string)[] | number | string;
 export type CameraType = 'camera' | 'doorbell';
 export type ZoneType = 'intersect' | 'contain';
 export type ZoneFilter = 'include' | 'exclude';
-export type ObjectClass = 'person' | 'bicycle' | 'car' | 'motorcycle' | 'airplane' | 'bus' | 'train' | 'truck' | 'boat' | 'traffic light' | 'fire hydrant' | 'stop sign' | 'parking meter' | 'bench' | 'bird' | 'cat' | 'dog' | 'horse' | 'sheep' | 'cow' | 'elephant' | 'bear' | 'zebra' | 'giraffe' | 'backpack' | 'umbrella' | 'handbag' | 'tie' | 'suitcase' | 'frisbee' | 'skis' | 'snowboard' | 'sports ball' | 'kite' | 'baseball bat' | 'baseball glove' | 'skateboard' | 'surfboard' | 'tennis racket' | 'bottle' | 'wine glass' | 'cup' | 'fork' | 'knife' | 'spoon' | 'bowl' | 'banana' | 'apple' | 'sandwich' | 'orange' | 'broccoli' | 'carrot' | 'hot dog' | 'pizza' | 'donut' | 'cake' | 'chair' | 'couch' | 'potted plant' | 'bed' | 'dining table' | 'toilet' | 'tv' | 'laptop' | 'mouse' | 'remote' | 'keyboard' | 'cell phone' | 'microwave' | 'oven' | 'toaster' | 'sink' | 'refrigerator' | 'book' | 'clock' | 'vase' | 'scissors' | 'teddy bear' | 'hair drier' | 'toothbrush' | 'motion';
-export type CameraRoles = 'high-resolution' | 'mid-resolution' | 'low-resolution' | 'snapshot';
-export type DecoderFormat = 'yuv' | 'rgb';
-export type ImageInputFormat = 'yuv' | 'rgb' | 'rgba' | 'gray';
+export type ObjectClass = 'person' | 'vehicle' | 'animal' | 'other' | 'motion';
+export type CameraRole = 'high-resolution' | 'mid-resolution' | 'low-resolution' | 'snapshot';
+export type StreamingRole = Exclude<CameraRole, 'snapshot'>;
+export type DecoderFormat = 'yuv420p' | 'rgb24' | 'nv12';
+export type ImageInputFormat = 'yuv420p' | 'nv12' | 'rgb' | 'rgba' | 'gray';
 export type ImageOutputFormat = 'rgb' | 'rgba' | 'gray';
 export type CameraExtension = 'cameraController' | 'hub' | 'motionDetection' | 'objectDetection' | 'audioDetection' | 'ptz';
-export type CameraFrameWorkerDecoder = 'pillow' | 'wasm' | 'rust';
-export type CameraFrameWorkerResolution = '3840x2160' | '3072x1728' | '2560x1440' | '1920x1080' | '1440x1080' | '1280x720' | '960x540' | '640x480' | '640x360' | '320x240' | '320x180';
-export type AudioCodec = 'PCMU' | 'PCMA' | 'MPEG4-GENERIC' | 'opus' | 'G722' | 'MPA' | 'PCM' | 'FLAC';
+export type CameraFrameWorkerDecoder = 'pillow' | 'wasm' | 'rust' | 'gpu';
+export type CameraFrameWorkerResolution = '640x480' | '640x360' | '320x240' | '320x180';
+export type AudioCodec = 'PCMU' | 'PCMA' | 'MPEG4-GENERIC' | 'opus' | 'G722' | 'MPA' | 'PCM' | 'FLAC' | 'ELD' | 'PCML' | 'L16';
 export type AudioFFmpegCodec = 'pcm_mulaw' | 'pcm_alaw' | 'aac' | 'libopus' | 'g722' | 'mp3' | 'pcm_s16be' | 'pcm_s16le' | 'flac';
 export type VideoCodec = 'H264' | 'H265' | 'VP8' | 'VP9' | 'AV1' | 'JPEG' | 'RAW';
 export type VideoFFmpegCodec = 'h264' | 'hevc' | 'vp8' | 'vp9' | 'av1' | 'mjpeg' | 'rawvideo';
 export type PythonVersion = '3.9' | '3.10' | '3.11' | '3.12';
+export type RTSPAudioCodec = 'aac' | 'opus' | 'pcma';
+export type ProbeAudioCodec = 'aac' | 'opus' | 'pcma';
+export type HwAccelMethod = 'auto' | 'cuda' | 'vaapi' | 'videotoolbox' | 'qsv' | 'rkmpp' | 'v4l2m2m' | 'opencl' | 'vulkan' | 'amf' | 'jetson';
 export interface CameraInformation {
     model?: string;
     manufacturer?: string;
@@ -44,22 +49,6 @@ export interface Detection {
     origWidth: number;
     origHeight: number;
 }
-export interface ZoneCoord {
-    _id: string;
-    points: Point;
-}
-export interface ZoneRegion {
-    _id: string;
-    coords: ZoneCoord[];
-    type: ZoneType;
-    filter: ZoneFilter;
-    classes: ObjectClass[];
-    isPrivacyMask: boolean;
-}
-export interface CameraZone {
-    name: string;
-    regions: ZoneRegion[];
-}
 export interface DetectionZone {
     name: string;
     points: Point[];
@@ -67,6 +56,7 @@ export interface DetectionZone {
     filter: ZoneFilter;
     classes: ObjectClass[];
     isPrivacyMask: boolean;
+    color: string;
 }
 export interface MotionDetectionSettings {
     timeout: number;
@@ -74,7 +64,7 @@ export interface MotionDetectionSettings {
 export interface ObjectDetectionSettings {
     confidence: number;
 }
-export interface CameraActivitySettings {
+export interface CameraDetectionSettings {
     motion: MotionDetectionSettings;
     object: ObjectDetectionSettings;
 }
@@ -86,15 +76,18 @@ export interface CameraFrameWorkerSettings {
 export interface CameraInput {
     readonly _id: string;
     name: string;
-    roles: CameraRoles[];
+    role: CameraRole;
+    useForSnapshot: boolean;
+    hotMode: boolean;
     urls: StreamUrls;
-    internal: boolean;
 }
 export interface RTPInfo {
     payload?: number;
     codec: string;
-    rate?: number | undefined;
-    encoding?: number | undefined;
+    profile?: string;
+    rate?: number;
+    encoding?: number;
+    level?: number;
 }
 export interface FMTPInfo {
     payload: number;
@@ -124,9 +117,9 @@ export interface VideoStreamInfo {
     direction: 'sendonly' | 'recvonly' | 'sendrecv' | 'inactive';
 }
 export interface ProbeConfig {
-    video?: VideoCodec;
-    audio?: AudioCodec;
-    microphone?: AudioCodec;
+    video?: boolean;
+    audio?: boolean | 'all' | ProbeAudioCodec[];
+    microphone?: boolean;
 }
 export interface ProbeStream {
     sdp: string;
@@ -136,40 +129,25 @@ export interface ProbeStream {
 export interface StreamUrls {
     ws: Go2RtcWSSource;
     rtsp: Go2RtcRTSPSource;
-    www: Go2RtcEndpoint;
+    snapshot: Go2RtcSnapshotSource;
+}
+export interface Go2RtcWSSource {
+    webrtc: string;
+    mse: string;
 }
 export interface Go2RtcRTSPSource {
+    base: string;
     default: string;
-    defaultMicrophone: string;
-    h264: string;
-    h265: string;
+    muted: string;
     aac: string;
     opus: string;
     pcma: string;
-    mp4: string;
+    onvif: string;
 }
-export interface Go2RtcEndpoint {
-    webrtc: string;
-    mse: string;
-    lmp4: string;
-    mmp4: string;
+export interface Go2RtcSnapshotSource {
     mp4: string;
-    mp4Snapshot: string;
-    jpegSnapshot: string;
-    lHlsTs: string;
-    lHlsFmp4: string;
-    mHlsFmp4: string;
+    jpeg: string;
     mjpeg: string;
-    mjpegHtml: string;
-}
-export interface Go2RtcSource {
-    name: string;
-    src: string;
-    ws: string;
-}
-export interface Go2RtcWSSource {
-    webrtc: string;
-    mse: string;
 }
 export interface BaseState<T extends LightState | AudioState | MotionState | ObjectState | SirenState | BatteryState | DoorbellState> {
     timestamp: number;
@@ -227,8 +205,10 @@ export interface SetValues {
     battery: BatterySetEvent;
 }
 export interface FrameData {
-    frameId: string;
+    data: Uint8Array;
     timestamp: number;
+    metadata: FrameMetadata;
+    info: ImageInformation;
 }
 export interface FrameMetadata {
     format: DecoderFormat;
@@ -241,7 +221,7 @@ export interface FrameMetadata {
 export interface ImageInformation {
     width: number;
     height: number;
-    channels: 1 | 3 | 4;
+    channels: number;
     format: ImageInputFormat;
 }
 export interface ImageCrop {
@@ -270,83 +250,71 @@ export interface FrameBuffer {
     image: Uint8Array;
     info: ImageInformation;
 }
+export interface MotionDetectionFrame {
+    frame: FrameData;
+    state: MotionSetEvent;
+}
 export interface VideoFrame {
-    readonly frameData: FrameData;
+    readonly data: Uint8Array;
     readonly metadata: FrameMetadata;
+    readonly info: ImageInformation;
+    readonly timestamp: number;
     readonly inputWidth: number;
     readonly inputHeight: number;
     readonly inputFormat: DecoderFormat;
+    readonly motion?: MotionSetEvent;
     toBuffer(options?: ImageOptions): Promise<FrameBuffer>;
     toImage(options?: ImageOptions): Promise<FrameImage>;
     save(path: string, options?: ImageOptions): Promise<void>;
 }
-export interface MotionFrame extends VideoFrame {
-    readonly motion: MotionState;
-}
+export type FrameType = 'stream' | 'motion';
 export interface CameraInputSettings {
     readonly _id: string;
     name: string;
-    roles: CameraRoles[];
+    role: CameraRole;
+    useForSnapshot: boolean;
+    hotMode: boolean;
     urls: string[];
-    internal: boolean;
 }
-export interface CameraConfigInputSettings extends Omit<CameraInputSettings, '_id' | 'internal'> {
+export interface CameraConfigInputSettings extends Omit<CameraInputSettings, '_id' | 'urls'> {
+    urls?: string[];
 }
 export interface BaseCameraConfig {
     name: string;
     nativeId?: string;
     isCloud?: boolean;
-    hasLight?: boolean;
-    hasSiren?: boolean;
-    hasBinarySensor?: boolean;
-    hasBattery?: boolean;
     disabled?: boolean;
     info?: Partial<CameraInformation>;
 }
 export type CameraConfig = BaseCameraConfig & {
     sources: CameraConfigInputSettings[];
 };
-export interface CameraDelegate {
-    snapshot(): Promise<ArrayBuffer | undefined>;
-}
-export interface CameraPTZDelegate {
-    moveAbsolute(pan: number, tilt: number, zoom: number): Promise<void>;
-    moveRelative(pan: number, tilt: number, zoom: number): Promise<void>;
-    moveContinuous(pan: number, tilt: number, zoom: number): Promise<void>;
-    stop(): Promise<void>;
-}
-export interface CameraDelegates {
-    cameraDelegate: CameraDelegate;
-    ptzDelegate: CameraPTZDelegate;
-}
-export type InternalSourceType = 'aac' | 'opus' | 'pcma';
-export interface CameraBaseSource extends CameraInput {
+export interface RTSPUrlOptions {
+    video?: boolean;
+    audio?: boolean | RTSPAudioCodec | RTSPAudioCodec[];
+    audioSingleTrack?: boolean;
+    backchannel?: boolean;
+    timeout?: number;
+}
+export interface CameraSource extends CameraInput {
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer | undefined>;
     probeStream(probeConfig?: ProbeConfig, refresh?: boolean): Promise<ProbeStream | undefined>;
 }
-export interface CameraSource extends CameraBaseSource {
-    getInternalSource(type: InternalSourceType): CameraInternalSource;
-}
-export interface CameraInternalSource extends CameraBaseSource {
-    type: InternalSourceType;
-}
 export interface CameraDeviceSource extends CameraSource {
-    getInternalSource(type: InternalSourceType): CameraDeviceInternalSource;
-    createWebRTCSession(options?: WebRTCConnectionOptions): WeriftSession;
-    createRTSPSession(options?: RTSPConnectionOptions): RTSPSession;
-    createFMP4Session(): FMP4Session;
-}
-export interface CameraDeviceInternalSource extends CameraBaseSource {
+    generateRTSPUrl(options?: RTSPUrlOptions): string;
     createWebRTCSession(options?: WebRTCConnectionOptions): WeriftSession;
     createRTSPSession(options?: RTSPConnectionOptions): RTSPSession;
-    createFMP4Session(): FMP4Session;
-    type: InternalSourceType;
+    createFMP4Session(options?: FMP4ConnectionOptions): FMP4Session;
 }
 export interface WebRTCConnectionOptions {
     createPeerConnection?: () => BasicPeerConnection;
     iceServers?: IceServer[];
 }
 export interface RTSPConnectionOptions {
-    target?: keyof Go2RtcRTSPSource;
+    url?: string;
+}
+export interface FMP4ConnectionOptions {
+    url?: string;
 }
 export interface Subscribed {
     addSubscriptions(...subscriptions: Subscription[]): void;
@@ -431,6 +399,29 @@ export interface BasicPeerConnection {
     close(): void;
     requestKeyFrame?: () => void;
 }
+export type VideoStreamingMode = 'auto' | 'webrtc' | 'mse' | 'webrtc/tcp';
+export type CameraAspectRatio = '16:9' | '8:3' | '4:3' | 'auto';
+export interface CameraUiSettings {
+    streamingMode: VideoStreamingMode;
+    streamingSource: StreamingRole | 'auto';
+    aspectRatio: CameraAspectRatio;
+}
+export interface CameraRecordingSettings {
+    enabled: boolean;
+}
+export interface Extension {
+    id: string;
+    name: string;
+}
+export interface CameraExtensions {
+    hub?: Extension[];
+    cameraController?: Extension;
+    motionDetection?: Extension;
+    audioDetection?: Extension;
+    objectDetection?: Extension;
+    ptz?: Extension;
+    plugins: Extension[];
+}
 export interface BaseCamera {
     readonly _id: string;
     nativeId?: string;
@@ -438,58 +429,111 @@ export interface BaseCamera {
     name: string;
     disabled: boolean;
     isCloud: boolean;
-    hasLight: boolean;
-    hasSiren: boolean;
-    hasBinarySensor: boolean;
-    hasBattery: boolean;
     info: CameraInformation;
     type: CameraType;
     snapshotTTL: number;
-    activityZones: CameraZone[];
-    activitySettings: CameraActivitySettings;
+    detectionZones: DetectionZone[];
+    detectionSettings: CameraDetectionSettings;
     frameWorkerSettings: CameraFrameWorkerSettings;
+    interface: CameraUiSettings;
+    recording: CameraRecordingSettings;
+    extensions: CameraExtensions;
 }
-export interface Camera extends Omit<BaseCamera, 'activityZones'> {
-    hasAudioDetector: boolean;
-    hasMotionDetector: boolean;
-    hasObjectDetector: boolean;
-    extendedMotionDetector: boolean;
-    hasPtz: boolean;
+export interface Camera extends BaseCamera {
     sources: CameraInput[];
-    activityZones: DetectionZone[];
+}
+export declare enum CameraDeviceCapability {
+    MotionSensor = "MotionSensor",
+    MotionDetector = "MotionDetector",
+    AudioSensor = "AudioSensor",
+    ObjectSensor = "ObjectSensor",
+    ObjectDetector = "ObjectDetector",
+    Light = "Light",
+    Siren = "Siren",
+    Doorbell = "Doorbell",
+    Battery = "Battery",
+    PTZ = "PTZ",
+    PTZZoom = "PTZZoom",
+    PTZHome = "PTZHome",
+    PTZPresets = "PTZPresets",
+    Snapshot = "Snapshot",
+    StreamUrl = "StreamUrl",
+    Reboot = "Reboot"
+}
+export type PTZMovementType = 'absolute' | 'relative' | 'continuous' | 'home' | 'preset' | 'stop';
+export interface PTZSpeed {
+    pan?: number;
+    tilt?: number;
+    zoom?: number;
+}
+export interface PTZBaseCommand {
+    type: PTZMovementType;
+    speed?: PTZSpeed;
+}
+export interface PTZStopCommand extends PTZBaseCommand {
+    type: 'stop';
+}
+export interface PTZHomeCommand extends PTZBaseCommand {
+    type: 'home';
+}
+export interface PTZPresetCommand extends PTZBaseCommand {
+    type: 'preset';
+    preset: string;
+}
+export interface PTZMoveCommand extends PTZBaseCommand {
+    type: 'absolute' | 'relative';
+    pan?: number;
+    tilt?: number;
+    zoom?: number;
+}
+export interface PTZContinuousMoveCommand extends PTZBaseCommand {
+    type: 'continuous';
+    pan?: number;
+    tilt?: number;
+    zoom?: number;
+    timeout?: number;
+}
+export type PTZCommand = PTZHomeCommand | PTZPresetCommand | PTZMoveCommand | PTZContinuousMoveCommand | PTZStopCommand;
+export interface PTZInterface {
+    ptzCommand(command: PTZCommand): Promise<void>;
+}
+export interface SnapshotInterface {
+    snapshot(sourceId: string, forceNew?: boolean): Promise<ArrayBuffer | undefined>;
+}
+export interface StreamingInterface {
+    streamUrl(sourceName: string): Promise<string>;
 }
 export interface CameraDevice {
     readonly id: string;
     readonly nativeId: string | undefined;
     readonly pluginId: string;
-    readonly connected: boolean;
     readonly disabled: boolean;
     readonly name: string;
     readonly type: CameraType;
     readonly snapshotTTL: number;
     readonly info: CameraInformation;
     readonly isCloud: boolean;
+    readonly detectionZones: DetectionZone[];
+    readonly detectionSettings: CameraDetectionSettings;
+    readonly frameWorkerSettings: CameraFrameWorkerSettings;
     readonly hasLight: boolean;
     readonly hasSiren: boolean;
-    readonly hasBinarySensor: boolean;
+    readonly hasDoorbell: boolean;
     readonly hasBattery: boolean;
     readonly hasMotionDetector: boolean;
-    readonly extendedMotionDetector: boolean;
     readonly hasAudioDetector: boolean;
     readonly hasObjectDetector: boolean;
     readonly hasPtz: boolean;
-    readonly activityZones: DetectionZone[];
-    readonly activitySettings: CameraActivitySettings;
-    readonly frameWorkerSettings: CameraFrameWorkerSettings;
-    readonly ptz: CameraPTZDelegate;
+    readonly sources: CameraDeviceSource[];
     readonly streamSource: CameraDeviceSource;
     readonly highResolutionSource: CameraDeviceSource | undefined;
     readonly midResolutionSource: CameraDeviceSource | undefined;
     readonly lowResolutionSource: CameraDeviceSource | undefined;
-    readonly snapshotSource: CameraInput | undefined;
-    readonly sources: CameraDeviceSource[];
-    readonly internalSources: CameraDeviceInternalSource[];
+    readonly snapshotSource: CameraSource | undefined;
+    readonly connected: boolean;
+    readonly frameWorkerConnected: boolean;
     readonly onConnected: Observable<boolean>;
+    readonly onFrameWorkerConnected: Observable<boolean>;
     readonly onLightSwitched: Observable<LightState>;
     readonly onMotionDetected: Observable<MotionState>;
     readonly onAudioDetected: Observable<AudioState>;
@@ -498,7 +542,14 @@ export interface CameraDevice {
     readonly onSirenDetected: Observable<SirenState>;
     readonly onBatteryChanged: Observable<BatteryState>;
     readonly logger: LoggerService;
-    snapshot(forceNew?: boolean): Promise<ArrayBuffer | undefined>;
+    extend(interfaces: PTZInterface | SnapshotInterface | StreamingInterface): void;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getFrames(type: 'stream', options?: ImageOptions): AsyncIterableIterator<VideoFrame>;
+    getFrames(type: 'motion', options?: ImageOptions): AsyncIterableIterator<VideoFrame>;
+    getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
+    updateState<T extends keyof Omit<SetValues, 'motion'>>(stateName: T, eventData: SetValues[T]): Promise<void>;
+    updateState(stateName: 'motion', eventData: MotionSetEvent, frame?: VideoFrame): Promise<void>;
     onStateChange<T extends keyof StateValues>(stateName: T): Observable<{
         newState: StateValues[T];
         oldState: StateValues[T];
@@ -508,24 +559,38 @@ export interface CameraDevice {
         oldData: Camera[T];
         newData: Camera[T];
     }>;
-    getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
-    setDelegate<T extends keyof CameraDelegates>(delegateName: T, delegate: CameraDelegates[T]): void;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    getFrames(prebufferDuration?: number): AsyncIterableIterator<VideoFrame>;
-    getMotionFrames(): AsyncIterableIterator<MotionFrame>;
-    updateState<T extends keyof Omit<SetValues, 'motion'>>(stateName: T, eventData: SetValues[T]): Promise<void>;
-    updateState(stateName: 'motion', eventData: MotionSetEvent, frame?: VideoFrame): Promise<void>;
-    addCameraSource(source: CameraConfigInputSettings): Promise<void>;
-    updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>): Promise<void>;
-    removeCameraSource(sourceId: string): Promise<void>;
+    onCapabilitiesChange(): Observable<{
+        oldCapabilities: CameraDeviceCapability[];
+        newCapabilities: CameraDeviceCapability[];
+    }>;
+    getCapabilities(): CameraDeviceCapability[];
+    hasCapability(capability: CameraDeviceCapability): boolean;
+    addCapabilities(capabilities: CameraDeviceCapability[]): void;
+    removeCapabilities(capabilities: CameraDeviceCapability[]): void;
+}
+export type SensorType = 'door' | 'window' | 'garage';
+export declare enum SensorState {
+    Opened = "Opened",
+    Closed = "Closed",
+    Jammed = "Jammed",
+    Unknown = "Unknown"
+}
+export interface CameraDeviceSensor {
+    readonly id: string;
+    readonly type: SensorType;
+    readonly state: SensorState;
+    onStateChange(): Observable<{
+        newState: SensorState;
+        oldState: SensorState;
+    }>;
+    open(): Promise<void>;
+    close(): Promise<void>;
 }
 export interface DeviceManager {
     createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
-    getCameraByName(cameraName: string): Promise<CameraDevice | undefined>;
-    getCameraById(cameraId: string): Promise<CameraDevice | undefined>;
-    removeCameraByName(cameraName: string): Promise<void>;
-    removeCameraById(cameraId: string): Promise<void>;
+    updateCamera(cameraIdOrName: string, cameraConfig: Partial<CameraConfig>): Promise<CameraDevice>;
+    getCamera(cameraIdOrName: string): Promise<CameraDevice | undefined>;
+    removeCamera(cameraIdOrName: string): Promise<void>;
     on(event: 'cameraSelected', listener: (camera: CameraDevice, extension: CameraExtension) => void): this;
     on(event: 'cameraDeselected', listener: (cameraId: string, extension: CameraExtension) => void): this;
     once(event: 'cameraSelected', listener: (camera: CameraDevice, extension: CameraExtension) => void): this;
@@ -537,18 +602,28 @@ export interface DeviceManager {
     removeAllListeners(event?: 'cameraSelected' | 'cameraDeselected'): this;
 }
 export interface CoreManager {
+    connectToPlugin(pluginName: string): Promise<CuiPlugin | undefined>;
     getFFmpegPath(): Promise<string>;
-    getHwaccelInfo(targetCodec: 'h264' | 'h265'): Promise<FfmpegArgs>;
+    getHwaccelInfo(options: HWAccelOptions): Promise<FfmpegArgs[]>;
     getServerAddresses(): Promise<string[]>;
     getIceServers(): Promise<IceServer[]>;
 }
+export interface HWAccelOptions {
+    targetCodec: 'h264' | 'h265';
+    keepOnHardware?: boolean;
+    pixelFormat?: string;
+    scale?: {
+        width: number;
+        height: number;
+    };
+}
 export interface FfmpegArgs {
     codec: string;
-    hwaccel: string;
+    hwaccel: HwAccelMethod;
     hwaccelArgs: string[];
     hwaccelFilters: string[];
     hwDeviceArgs: string[];
-    threads: string;
+    supported: boolean;
 }
 export interface IceServer {
     urls: string[];
@@ -556,82 +631,107 @@ export interface IceServer {
     credential?: string;
 }
 export type PluginConfig<T = Record<string, any>> = T;
-export type JsonSchemaType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'button';
-export interface JsonBaseSchema<T = any> {
+export type JsonSchemaType = 'string' | 'number' | 'boolean' | 'array' | 'button' | 'submit';
+export interface JsonFactorySchema {
     type: JsonSchemaType;
-    key?: string;
-    title?: string;
-    description?: string;
+    key: string;
+    title: string;
+    description: string;
+    group?: string;
+}
+export interface JsonBaseSchmaWithoutCallbacks<T extends string | string[] | number | number[] | boolean | boolean[] = any> extends JsonFactorySchema {
+    hidden?: boolean;
     required?: boolean;
     readonly?: boolean;
     placeholder?: string;
-    hidden?: boolean;
-    group?: string;
     defaultValue?: T;
+}
+export interface JsonBaseSchema<T extends string | string[] | number | number[] | boolean | boolean[] = any> extends JsonBaseSchmaWithoutCallbacks<T> {
     store?: boolean;
     onSet?: (newValue: any, oldValue: any) => Promise<void>;
     onGet?: () => Promise<any>;
 }
-export interface JsonSchemaString extends JsonBaseSchema<string> {
+export interface JsonStringSchema {
     type: 'string';
     format?: 'date-time' | 'date' | 'time' | 'email' | 'uuid' | 'ipv4' | 'ipv6' | 'password' | 'qrCode' | 'image';
     minLength?: number;
     maxLength?: number;
 }
-export interface JsonSchemaNumber extends JsonBaseSchema<number> {
+export interface JsonNumberSchema {
     type: 'number';
     minimum?: number;
     maximum?: number;
     step?: number;
 }
-export interface JsonSchemaBoolean extends JsonBaseSchema<boolean> {
+export interface JsonBooleanSchema {
     type: 'boolean';
 }
-export interface JsonSchemaEnum extends JsonBaseSchema<string> {
+export interface JsonEnumSchema {
     type: 'string';
     enum: string[];
     multiple?: boolean;
 }
-export interface JsonSchemaObject extends JsonBaseSchema {
-    type: 'object';
-    opened?: boolean;
-    properties?: JsonSchemaForm;
-}
-export interface JsonSchemaArray extends JsonBaseSchema {
+export interface JsonArraySchema {
     type: 'array';
     opened?: boolean;
-    items?: JsonSchema;
+    items: Omit<JsonSchemaWithoutCallbacks, 'key'>;
 }
-export interface JsonSchemaButton extends JsonBaseSchema {
-    type: 'button';
-    color?: string;
+export interface JsonSchemaString extends JsonBaseSchema<string>, JsonStringSchema {
+    type: 'string';
+}
+export interface JsonSchemaStringWithoutCallbacks extends JsonBaseSchmaWithoutCallbacks<string>, JsonStringSchema {
+    type: 'string';
+}
+export interface JsonSchemaNumber extends JsonBaseSchema<number>, JsonNumberSchema {
+    type: 'number';
 }
-export interface JsonSchemaObjectButton {
-    label: string;
-    onSubmit: string;
-    color?: string;
+export interface JsonSchemaNumberWithoutCallbacks extends JsonBaseSchmaWithoutCallbacks<number>, JsonNumberSchema {
+    type: 'number';
+}
+export interface JsonSchemaBoolean extends JsonBaseSchema<boolean>, JsonBooleanSchema {
+    type: 'boolean';
 }
-export interface JsonSchemaObjectWithButtons extends JsonSchemaObject {
-    buttons: JsonSchemaObjectButton[];
+export interface JsonSchemaBooleanWithoutCallbacks extends JsonBaseSchmaWithoutCallbacks<boolean>, JsonBooleanSchema {
+    type: 'boolean';
 }
-export type JsonSchema = JsonSchemaString | JsonSchemaNumber | JsonSchemaBoolean | JsonSchemaEnum | JsonSchemaObject | JsonSchemaObjectWithButtons | JsonSchemaArray | JsonSchemaButton;
-export type JsonSchemaForm = Record<string, JsonSchema>;
-export interface RootSchema {
-    schema: JsonSchemaForm;
+export interface JsonSchemaEnum extends JsonBaseSchema<string | string[]>, JsonEnumSchema {
+    type: 'string';
 }
+export interface JsonSchemaEnumWithoutCallbacks extends JsonBaseSchmaWithoutCallbacks<string | string[]>, JsonEnumSchema {
+    type: 'string';
+}
+export interface JsonSchemaArray extends JsonBaseSchema<string[] | number[] | boolean[]>, JsonArraySchema {
+    type: 'array';
+}
+export interface JsonSchemaArrayWithoutCallbacks extends JsonBaseSchmaWithoutCallbacks<string[] | number[] | boolean[]>, JsonArraySchema {
+    type: 'array';
+}
+export interface JsonSchemaButton extends JsonFactorySchema {
+    type: 'button';
+    color?: 'success' | 'info' | 'warn' | 'danger';
+    onSet: () => Promise<void>;
+}
+export interface JsonSchemaSubmit extends JsonFactorySchema {
+    type: 'submit';
+    color?: 'success' | 'info' | 'warn' | 'danger';
+    onClick: (value: any) => Promise<FormSubmitResponse | void>;
+}
+export type JsonSchema = JsonSchemaString | JsonSchemaNumber | JsonSchemaBoolean | JsonSchemaEnum | JsonSchemaArray | JsonSchemaButton | JsonSchemaSubmit;
+export type JsonSchemaWithoutKey = Omit<JsonSchema, 'key'>;
+export type JsonSchemaWithoutCallbacks = JsonSchemaStringWithoutCallbacks | JsonSchemaNumberWithoutCallbacks | JsonSchemaBooleanWithoutCallbacks | JsonSchemaEnumWithoutCallbacks | JsonSchemaArrayWithoutCallbacks;
 export interface ToastMessage {
     type: 'info' | 'success' | 'warning' | 'error';
     message: string;
 }
 export interface FormSubmitSchema {
-    config: JsonSchemaObjectWithButtons;
+    config: Record<string, any>;
 }
 export interface FormSubmitResponse {
     toast?: ToastMessage;
-    schema?: FormSubmitSchema;
+    schema?: JsonSchemaWithoutCallbacks[];
 }
 export interface SchemaConfig {
-    rootSchema: RootSchema;
+    schema: JsonSchema[];
     config: Record<string, any>;
 }
 export interface ImageMetadata {
@@ -642,7 +742,7 @@ export interface AudioMetadata {
     mimeType: 'audio/mpeg' | 'audio/wav' | 'audio/ogg';
 }
 export interface MotionDetectionPluginResponse {
-    filePath: string;
+    videoData: Buffer | Uint8Array;
 }
 export interface ObjectDetectionPluginResponse {
     detections: Detection[];
@@ -650,21 +750,18 @@ export interface ObjectDetectionPluginResponse {
 export interface AudioDetectionPluginResponse {
     detected: boolean;
 }
-export interface BasePlugin {
-    onFormSubmit(actionId: string, payload: any): Promise<FormSubmitResponse | void>;
-    configureCameras(cameras: CameraDevice[]): void;
-}
-export interface AudioDetectionPlugin extends BasePlugin {
-    interfaceSchema(): RootSchema | void;
-    detectAudio(audioPath: string, metadata: AudioMetadata, config: Record<string, any>): Promise<AudioDetectionPluginResponse>;
-}
-export interface MotionDetectionPlugin extends BasePlugin {
-    interfaceSchema(): RootSchema | void;
-    detectMotion(videoPath: string, config: Record<string, any>): Promise<MotionDetectionPluginResponse>;
+export declare enum CuiPluginCapability {
+    MotionDetector = "MotionDetector",
+    ObjectDetector = "ObjectDetector",
+    AudioDetector = "AudioDetector"
 }
-export interface ObjectDetectionPlugin extends BasePlugin {
-    interfaceSchema(): RootSchema | void;
-    detectObjects(imagePath: string, metadata: ImageMetadata, config: Record<string, any>): Promise<ObjectDetectionPluginResponse>;
+export interface CuiPlugin {
+    configureCameras(cameras: CameraDevice[]): Promise<void>;
+    getCapabilities(): Promise<CuiPluginCapability[]>;
+    interfaceSchema?(): Promise<JsonSchema[] | undefined>;
+    detectAudio?(audioData: Buffer | Uint8Array, metadata: AudioMetadata, config: Record<string, any>): Promise<AudioDetectionPluginResponse | undefined>;
+    detectMotion?(videoData: Buffer | Uint8Array, config: Record<string, any>): Promise<MotionDetectionPluginResponse | undefined>;
+    detectObjects?(imageData: Buffer | Uint8Array, metadata: ImageMetadata, config: Record<string, any>): Promise<ObjectDetectionPluginResponse | undefined>;
 }
 export interface LoggerService {
     log: (...args: any[]) => void;
@@ -679,9 +776,7 @@ export interface PluginAPI {
     readonly coreManager: CoreManager;
     readonly deviceManager: DeviceManager;
     readonly storageController: StorageController;
-    readonly configService: ConfigService;
     readonly storagePath: string;
-    readonly configFile: string;
     on(event: 'finishLaunching', listener: () => void): this;
     on(event: 'shutdown', listener: () => void): this;
     once(event: 'finishLaunching', listener: () => void): this;
@@ -692,39 +787,26 @@ export interface PluginAPI {
     removeListener(event: 'shutdown', listener: () => void): this;
     removeAllListeners(event?: 'shutdown' | 'finishLaunching'): this;
 }
-export interface ConfigService {
-    get(key: Path, defaultValue: JSONValue, validate: Function, refresh?: boolean, writeIfNotValid?: boolean): any;
-    get(key: Path, defaultValue?: unknown, validate?: Function, refresh?: boolean, writeIfNotValid?: boolean): any;
-    has(key: Path, refresh?: boolean): boolean;
-    ensureExists(key: Path, defaultValue: JSONValue, write?: boolean): void;
-    set(key: Path, value: any, write?: boolean): void;
-    insert(key: Path, value: any, at?: number, write?: boolean): void;
-    push(key: Path, write?: boolean, ...items: any[]): void;
-    delete(key: Path, write?: boolean): void;
-    all(refresh?: boolean): PluginConfig;
-    replace(config: PluginConfig, write?: boolean): void;
-    updateValue(path: string, searchKey: string, searchValue: any, targetKey: string, newValue: any, write?: boolean): void;
-    replaceOrAddItem(path: string, searchKey: string, searchValue: any, newItem: any, write?: boolean): void;
-}
-export interface CameraStorage<T extends Record<string, any> = Record<string, any>> {
-    schema: JsonSchemaForm;
+export interface DeviceStorage<T extends Record<string, any> = Record<string, any>> {
+    schemas: JsonSchema[];
     values: T;
-    initializeStorage(): void;
-    getValue<U = string>(path: string): Promise<U> | undefined;
-    getValue<U = string>(path: string, defaultValue: U): Promise<U>;
-    setValue<U = string>(path: string, newValue: U): Promise<void>;
-    hasValue(path: string): boolean;
+    getValue<U = string>(key: string): Promise<U> | undefined;
+    getValue<U = string>(key: string, defaultValue: U): Promise<U>;
+    setValue<U = string>(key: string, newValue: U): Promise<void>;
+    submitValue(key: string, newValue: any): Promise<FormSubmitResponse | void>;
+    hasValue(key: string): boolean;
     getConfig(): Promise<SchemaConfig>;
     setConfig(newConfig: T): Promise<void>;
-    addSchema(schema: JsonSchemaForm): Promise<void>;
-    addSchema(path: string, schema: JsonSchema): Promise<void>;
-    removeSchema(path: string): void;
-    changeSchema(path: string, newSchema: Partial<JsonSchema>): Promise<void>;
-    getSchema<U>(path: string): U | undefined;
-    hasSchema(path: string): boolean;
+    addSchema(schema: JsonSchema): Promise<void>;
+    removeSchema(key: string): Promise<void>;
+    changeSchema(key: string, newSchema: Partial<JsonSchema>): Promise<void>;
+    getSchema(key: string): JsonSchema | undefined;
+    hasSchema(key: string): boolean;
+    save(): Promise<void>;
 }
 export interface StorageController {
-    createCameraStorage<T extends Record<string, any> = Record<string, any>>(instance: any, cameraId: string, schema?: JsonSchemaForm): CameraStorage<T>;
-    getCameraStorage<T extends Record<string, any> = Record<string, any>>(cameraId: string): CameraStorage<T> | undefined;
-    removeCameraStorage(cameraId: string): void;
+    createCameraStorage<T extends Record<string, any> = Record<string, any>>(instance: any, cameraId: string, schemas?: JsonSchema[]): DeviceStorage<T>;
+    createPluginStorage<T extends Record<string, any> = Record<string, any>>(instance: any, schemas?: JsonSchema[]): DeviceStorage<T>;
+    getCameraStorage<T extends Record<string, any> = Record<string, any>>(cameraId: string): DeviceStorage<T> | undefined;
+    getPluginStorage<T extends Record<string, any> = Record<string, any>>(): DeviceStorage<T> | undefined;
 }