@camera.ui/browser 0.0.111 → 0.0.113

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

@@ -1,812 +0,0 @@
-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 {
-    [key: string]: string | number | boolean | JSONValue | JSONValue[];
-}
-export type JSONArray = JSONValue[];
-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' | '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' | '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;
-    hardware?: string;
-    serialNumber?: string;
-    firmwareVersion?: string;
-    supportUrl?: string;
-}
-export type Point = [number, number];
-export type BoundingBox = [number, number, number, number];
-export interface Detection {
-    id?: string;
-    label: ObjectClass;
-    confidence: number;
-    boundingBox: BoundingBox;
-    inputWidth: number;
-    inputHeight: number;
-    origWidth: number;
-    origHeight: number;
-}
-export interface DetectionZone {
-    name: string;
-    points: Point[];
-    type: ZoneType;
-    filter: ZoneFilter;
-    classes: ObjectClass[];
-    isPrivacyMask: boolean;
-    color: string;
-}
-export interface MotionDetectionSettings {
-    timeout: number;
-}
-export interface ObjectDetectionSettings {
-    confidence: number;
-}
-export interface CameraDetectionSettings {
-    motion: MotionDetectionSettings;
-    object: ObjectDetectionSettings;
-}
-export interface CameraFrameWorkerSettings {
-    decoder: CameraFrameWorkerDecoder;
-    fps: number;
-    resolution: CameraFrameWorkerResolution;
-}
-export interface CameraInput {
-    readonly _id: string;
-    name: string;
-    role: CameraRole;
-    useForSnapshot: boolean;
-    hotMode: boolean;
-    urls: StreamUrls;
-}
-export interface RTPInfo {
-    payload?: number;
-    codec: string;
-    profile?: string;
-    rate?: number;
-    encoding?: number;
-    level?: number;
-}
-export interface FMTPInfo {
-    payload: number;
-    config: string;
-}
-export interface AudioCodecProperties {
-    sampleRate: number;
-    channels: number;
-    payloadType: number;
-    fmtpInfo?: FMTPInfo;
-}
-export interface VideoCodecProperties {
-    clockRate: number;
-    payloadType: number;
-    fmtpInfo?: FMTPInfo;
-}
-export interface AudioStreamInfo {
-    codec: AudioCodec;
-    ffmpegCodec: AudioFFmpegCodec;
-    properties: AudioCodecProperties;
-    direction: 'sendonly' | 'recvonly' | 'sendrecv' | 'inactive';
-}
-export interface VideoStreamInfo {
-    codec: VideoCodec;
-    ffmpegCodec: VideoFFmpegCodec;
-    properties: VideoCodecProperties;
-    direction: 'sendonly' | 'recvonly' | 'sendrecv' | 'inactive';
-}
-export interface ProbeConfig {
-    video?: boolean;
-    audio?: boolean | 'all' | ProbeAudioCodec[];
-    microphone?: boolean;
-}
-export interface ProbeStream {
-    sdp: string;
-    audio: AudioStreamInfo[];
-    video: VideoStreamInfo[];
-}
-export interface StreamUrls {
-    ws: Go2RtcWSSource;
-    rtsp: Go2RtcRTSPSource;
-    snapshot: Go2RtcSnapshotSource;
-}
-export interface Go2RtcWSSource {
-    webrtc: string;
-    mse: string;
-}
-export interface Go2RtcRTSPSource {
-    base: string;
-    default: string;
-    muted: string;
-    aac: string;
-    opus: string;
-    pcma: string;
-    onvif: string;
-}
-export interface Go2RtcSnapshotSource {
-    mp4: string;
-    jpeg: string;
-    mjpeg: string;
-}
-export interface BaseState<T extends LightState | AudioState | MotionState | ObjectState | SirenState | BatteryState | DoorbellState> {
-    timestamp: number;
-    lastEvent?: Omit<T, 'lastEvent'>;
-}
-export interface MotionSetEvent {
-    state: boolean;
-    detections?: Detection[];
-}
-export interface AudioSetEvent {
-    state: boolean;
-    db?: number;
-}
-export interface ObjectSetEvent {
-    detections: Detection[];
-}
-export interface LightSetEvent {
-    state: boolean;
-}
-export interface DoorbellSetEvent {
-    state: boolean;
-}
-export interface SirenSetEvent {
-    state: boolean;
-    level?: number;
-}
-export interface BatterySetEvent {
-    level: number;
-    lowBattery?: boolean;
-    charging?: boolean;
-}
-export type LightState = BaseState<LightState> & LightSetEvent;
-export type MotionState = BaseState<MotionState> & MotionSetEvent;
-export type AudioState = BaseState<AudioState> & AudioSetEvent;
-export type DoorbellState = BaseState<DoorbellState> & DoorbellSetEvent;
-export type SirenState = BaseState<SirenState> & SirenSetEvent;
-export type ObjectState = BaseState<ObjectState> & ObjectSetEvent;
-export type BatteryState = BaseState<BatteryState> & BatterySetEvent;
-export interface StateValues {
-    light: LightState;
-    motion: MotionState;
-    audio: AudioState;
-    object: ObjectState;
-    doorbell: DoorbellState;
-    siren: SirenState;
-    battery: BatteryState;
-}
-export interface SetValues {
-    light: LightSetEvent;
-    motion: MotionSetEvent;
-    audio: AudioSetEvent;
-    object: ObjectSetEvent;
-    doorbell: DoorbellSetEvent;
-    siren: SirenSetEvent;
-    battery: BatterySetEvent;
-}
-export interface FrameData {
-    data: Uint8Array;
-    timestamp: number;
-    metadata: FrameMetadata;
-    info: ImageInformation;
-}
-export interface FrameMetadata {
-    format: DecoderFormat;
-    frameSize: number;
-    width: number;
-    origWidth: number;
-    height: number;
-    origHeight: number;
-}
-export interface ImageInformation {
-    width: number;
-    height: number;
-    channels: number;
-    format: ImageInputFormat;
-}
-export interface ImageCrop {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-}
-export interface ImageResize {
-    width: number;
-    height: number;
-}
-export interface ImageFormat {
-    to: ImageOutputFormat;
-}
-export interface ImageOptions {
-    format?: ImageFormat;
-    crop?: ImageCrop;
-    resize?: ImageResize;
-}
-export interface FrameImage {
-    image: sharp.Sharp;
-    info: ImageInformation;
-}
-export interface FrameBuffer {
-    image: Uint8Array;
-    info: ImageInformation;
-}
-export interface MotionDetectionFrame {
-    frame: FrameData;
-    state: MotionSetEvent;
-}
-export interface VideoFrame {
-    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 type FrameType = 'stream' | 'motion';
-export interface CameraInputSettings {
-    readonly _id: string;
-    name: string;
-    role: CameraRole;
-    useForSnapshot: boolean;
-    hotMode: boolean;
-    urls: string[];
-}
-export interface CameraConfigInputSettings extends Omit<CameraInputSettings, '_id' | 'urls'> {
-    urls?: string[];
-}
-export interface BaseCameraConfig {
-    name: string;
-    nativeId?: string;
-    isCloud?: boolean;
-    disabled?: boolean;
-    info?: Partial<CameraInformation>;
-}
-export type CameraConfig = BaseCameraConfig & {
-    sources: CameraConfigInputSettings[];
-};
-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 CameraDeviceSource extends CameraSource {
-    generateRTSPUrl(options?: RTSPUrlOptions): string;
-    createWebRTCSession(options?: WebRTCConnectionOptions): WeriftSession;
-    createRTSPSession(options?: RTSPConnectionOptions): RTSPSession;
-    createFMP4Session(options?: FMP4ConnectionOptions): FMP4Session;
-}
-export interface WebRTCConnectionOptions {
-    createPeerConnection?: () => BasicPeerConnection;
-    iceServers?: IceServer[];
-}
-export interface RTSPConnectionOptions {
-    url?: string;
-}
-export interface FMP4ConnectionOptions {
-    url?: string;
-}
-export interface Subscribed {
-    addSubscriptions(...subscriptions: Subscription[]): void;
-    addAdditionalSubscriptions(...subscriptions: Subscription[]): void;
-    unsubscribe(): void;
-    unsubscribeAdditional(): void;
-}
-export interface WeriftSession extends Subscribed {
-    readonly onStarted: ReplaySubject<void>;
-    readonly onError: ReplaySubject<Error>;
-    readonly onCallEnded: ReplaySubject<void>;
-    readonly onVideoRtp: Subject<RtpPacket>;
-    readonly onAudioRtp: Subject<RtpPacket>;
-    startTranscoding(ffmpegOptions: FfmpegOptions, streamProbe?: ProbeStream): Promise<void>;
-    transcodeReturnAudio(ffmpegOptions: ReturnAudioFFmpegOptions, streamProbe?: ProbeStream): Promise<void>;
-    stop(): void;
-    sendAudioPacket(rtp: RtpPacket | Buffer): void;
-    requestKeyFrame(): void;
-}
-export interface RTSPSession extends Subscribed {
-    readonly onStarted: ReplaySubject<void>;
-    readonly onError: ReplaySubject<Error>;
-    readonly onCallEnded: ReplaySubject<void>;
-    readonly onVideoRtp: Subject<RtpPacket>;
-    readonly onAudioRtp: Subject<RtpPacket>;
-    startStream(): Promise<void>;
-    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
-    transcodeReturnAudio(ffmpegOptions: ReturnAudioFFmpegOptions): Promise<void>;
-    stop(): void;
-    sendAudioPacket(rtp: RtpPacket): void;
-}
-export interface FMP4Session extends Subscribed {
-    readonly onStarted: ReplaySubject<void>;
-    readonly onError: ReplaySubject<Error>;
-    readonly onCallEnded: ReplaySubject<void>;
-    readonly onFragment: Subject<Fragment>;
-    readonly initSegment: Promise<Buffer>;
-    startStream(): void;
-    startTranscoding(ffmpegOptions: FragmentedFfmpegOptions): Promise<void>;
-    stop(): void;
-    fragments(abortSignal?: AbortSignal): AsyncGenerator<Fragment>;
-}
-export interface Fragment {
-    data: Buffer;
-    info: FragmentInfo;
-}
-export interface FragmentInfo {
-    isFtyp: boolean;
-    isMoov: boolean;
-    isKeyframe: boolean;
-}
-export type SpawnInput = string | number;
-export interface FfmpegOptions {
-    ffmpegPath: string;
-    input?: SpawnInput[];
-    video?: SpawnInput[];
-    audio?: SpawnInput[];
-    output: SpawnInput[];
-    logPrefix?: string;
-}
-export interface ReturnAudioFFmpegOptions {
-    ffmpegPath: string;
-    input: SpawnInput[];
-    logPrefix?: string;
-}
-export interface FragmentedFfmpegOptions {
-    ffmpegPath: string;
-    input?: SpawnInput[];
-    video?: SpawnInput[];
-    audio?: SpawnInput[];
-    logPrefix?: string;
-}
-export interface BasicPeerConnection {
-    createOffer(): Promise<RTCSessionDescription>;
-    acceptAnswer(answer: {
-        type: 'answer';
-        sdp: string;
-    }): Promise<void>;
-    addIceCandidate(candidate: Partial<RTCIceCandidate>): Promise<void>;
-    onIceCandidate: Subject<RTCIceCandidate>;
-    onConnectionState: Observable<ConnectionState>;
-    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;
-    pluginId: string;
-    name: string;
-    disabled: boolean;
-    isCloud: boolean;
-    info: CameraInformation;
-    type: CameraType;
-    snapshotTTL: number;
-    detectionZones: DetectionZone[];
-    detectionSettings: CameraDetectionSettings;
-    frameWorkerSettings: CameraFrameWorkerSettings;
-    interface: CameraUiSettings;
-    recording: CameraRecordingSettings;
-    extensions: CameraExtensions;
-}
-export interface Camera extends BaseCamera {
-    sources: CameraInput[];
-}
-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 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 hasDoorbell: boolean;
-    readonly hasBattery: boolean;
-    readonly hasMotionDetector: boolean;
-    readonly hasAudioDetector: boolean;
-    readonly hasObjectDetector: boolean;
-    readonly hasPtz: boolean;
-    readonly sources: CameraDeviceSource[];
-    readonly streamSource: CameraDeviceSource;
-    readonly highResolutionSource: CameraDeviceSource | undefined;
-    readonly midResolutionSource: CameraDeviceSource | undefined;
-    readonly lowResolutionSource: CameraDeviceSource | undefined;
-    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>;
-    readonly onObjectDetected: Observable<ObjectState>;
-    readonly onDoorbellPressed: Observable<DoorbellState>;
-    readonly onSirenDetected: Observable<SirenState>;
-    readonly onBatteryChanged: Observable<BatteryState>;
-    readonly logger: LoggerService;
-    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];
-    }>;
-    onPropertyChange<T extends keyof Camera>(property: T | T[]): Observable<{
-        property: T;
-        oldData: Camera[T];
-        newData: Camera[T];
-    }>;
-    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>;
-    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;
-    once(event: 'cameraDeselected', listener: (cameraId: string, extension: CameraExtension) => void): this;
-    off(event: 'cameraSelected', listener: (camera: CameraDevice, extension: CameraExtension) => void): this;
-    off(event: 'cameraDeselected', listener: (cameraId: string, extension: CameraExtension) => void): this;
-    removeListener(event: 'cameraSelected', listener: (camera: CameraDevice, extension: CameraExtension) => void): this;
-    removeListener(event: 'cameraDeselected', listener: (cameraId: string, extension: CameraExtension) => void): this;
-    removeAllListeners(event?: 'cameraSelected' | 'cameraDeselected'): this;
-}
-export interface CoreManager {
-    connectToPlugin(pluginName: string): Promise<CuiPlugin | undefined>;
-    getFFmpegPath(): Promise<string>;
-    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: HwAccelMethod;
-    hwaccelArgs: string[];
-    hwaccelFilters: string[];
-    hwDeviceArgs: string[];
-    supported: boolean;
-}
-export interface IceServer {
-    urls: string[];
-    username?: string;
-    credential?: string;
-}
-export type PluginConfig<T = Record<string, any>> = T;
-export type JsonSchemaType = 'string' | 'number' | 'boolean' | 'array' | 'button' | 'submit';
-export interface JsonFactorySchema {
-    type: JsonSchemaType;
-    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;
-    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 JsonStringSchema {
-    type: 'string';
-    format?: 'date-time' | 'date' | 'time' | 'email' | 'uuid' | 'ipv4' | 'ipv6' | 'password' | 'qrCode' | 'image';
-    minLength?: number;
-    maxLength?: number;
-}
-export interface JsonNumberSchema {
-    type: 'number';
-    minimum?: number;
-    maximum?: number;
-    step?: number;
-}
-export interface JsonBooleanSchema {
-    type: 'boolean';
-}
-export interface JsonEnumSchema {
-    type: 'string';
-    enum: string[];
-    multiple?: boolean;
-}
-export interface JsonArraySchema {
-    type: 'array';
-    opened?: boolean;
-    items: Omit<JsonSchemaWithoutCallbacks, 'key'>;
-}
-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 JsonSchemaNumberWithoutCallbacks extends JsonBaseSchmaWithoutCallbacks<number>, JsonNumberSchema {
-    type: 'number';
-}
-export interface JsonSchemaBoolean extends JsonBaseSchema<boolean>, JsonBooleanSchema {
-    type: 'boolean';
-}
-export interface JsonSchemaBooleanWithoutCallbacks extends JsonBaseSchmaWithoutCallbacks<boolean>, JsonBooleanSchema {
-    type: 'boolean';
-}
-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: Record<string, any>;
-}
-export interface FormSubmitResponse {
-    toast?: ToastMessage;
-    schema?: JsonSchemaWithoutCallbacks[];
-}
-export interface SchemaConfig {
-    schema: JsonSchema[];
-    config: Record<string, any>;
-}
-export interface ImageMetadata {
-    width: number;
-    height: number;
-}
-export interface AudioMetadata {
-    mimeType: 'audio/mpeg' | 'audio/wav' | 'audio/ogg';
-}
-export interface MotionDetectionPluginResponse {
-    videoData: Buffer | Uint8Array;
-}
-export interface ObjectDetectionPluginResponse {
-    detections: Detection[];
-}
-export interface AudioDetectionPluginResponse {
-    detected: boolean;
-}
-export declare enum CuiPluginCapability {
-    MotionDetector = "MotionDetector",
-    ObjectDetector = "ObjectDetector",
-    AudioDetector = "AudioDetector"
-}
-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;
-    error: (...args: any[]) => void;
-    warn: (...args: any[]) => void;
-    success: (...args: any[]) => void;
-    debug: (...args: any[]) => void;
-    trace: (...args: any[]) => void;
-    attention: (...args: any[]) => void;
-}
-export interface PluginAPI {
-    readonly coreManager: CoreManager;
-    readonly deviceManager: DeviceManager;
-    readonly storageController: StorageController;
-    readonly storagePath: string;
-    on(event: 'finishLaunching', listener: () => void): this;
-    on(event: 'shutdown', listener: () => void): this;
-    once(event: 'finishLaunching', listener: () => void): this;
-    once(event: 'shutdown', listener: () => void): this;
-    off(event: 'finishLaunching', listener: () => void): this;
-    off(event: 'shutdown', listener: () => void): this;
-    removeListener(event: 'finishLaunching', listener: () => void): this;
-    removeListener(event: 'shutdown', listener: () => void): this;
-    removeAllListeners(event?: 'shutdown' | 'finishLaunching'): this;
-}
-export interface DeviceStorage<T extends Record<string, any> = Record<string, any>> {
-    schemas: JsonSchema[];
-    values: T;
-    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: 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, 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;
-}