@camera.ui/browser 0.0.6 → 0.0.30

package/dist/src/camera/streaming/webrtc-connection.d.ts

@@ -1,8 +1,8 @@
 import { ReplaySubject, Subject, type Observable } from 'rxjs';
 import { Subscribed } from '../subscribed';
 import type { RtpPacket } from 'werift';
-import type { CameraInput } from '../../api/database/types';
-import type { StreamingConnectionOptions, BaseLogger } from '../types';
+import type { StreamingConnectionOptions, CameraDevice } from '../types';
+import type { IceServer } from '../../services/config/types';
 export declare class WebrtcConnection extends Subscribed {
     readonly onCameraConnected: ReplaySubject<void>;
     readonly onCallAnswered: ReplaySubject<string>;
@@ -19,14 +19,13 @@ export declare class WebrtcConnection extends Subscribed {
     private readonly onOfferSent;
     private hasEnded;
     private logger;
-    private cameraName;
-    private cameraInput;
-    constructor(cameraName: string, cameraInput: CameraInput, options: StreamingConnectionOptions, logger: BaseLogger);
+    private cameraDevice;
+    constructor(cameraDevice: CameraDevice, sourceName: string, iceServers: IceServer[], options: StreamingConnectionOptions);
+    sendAudioPacket(rtp: RtpPacket): void;
+    stop(): void;
+    requestKeyFrame(): void;
     private initiateCall;
     private handleMessage;
     private sendMessage;
-    sendAudioPacket(rtp: RtpPacket): void;
     private callEnded;
-    stop(): void;
-    requestKeyFrame(): void;
 }

package/dist/src/camera/types.d.ts

@@ -1,8 +1,9 @@
 import type { Observable, Subject } from 'rxjs';
 import type { ConnectionState, RTCIceCandidate } from 'werift';
-import type { CameraInputSettings, CameraInput, Camera } from '../api/database/types';
+import type { CameraInput, Camera, CameraPublicProperties, CameraInputSettings } from '../api/database/types';
 import type { StreamingSession } from './streaming/streaming-session';
 export type SpawnInput = string | number;
+export type PrebufferType = 'recording' | 'stream';
 export interface BaseLogger {
     log: (...args: any[]) => void;
     error: (...args: any[]) => void;
@@ -34,28 +35,40 @@ export interface BasicPeerConnection {
 }
 export interface CameraDevice {
     id: string;
+    disabled: boolean;
     name: string;
-    pluginId: string;
     nativeId?: string;
+    isCloud: boolean;
+    hasLight: boolean;
+    hasSiren: boolean;
+    hasMotionDetector: boolean;
+    hasAudioDetector: boolean;
+    hasObjectDetector: boolean;
+    hasPtz: boolean;
     type: string;
     model: string;
-    sources: CameraInput[];
+    sources: Input[];
+    logger: BaseLogger;
     onLightDetected: Observable<LightState>;
     onMotionDetected: Observable<MotionState>;
     onAudioDetected: Observable<AudioState>;
     onObjectDetected: Observable<ObjectState>;
     onDoorbellPressed: Observable<DoorbellState>;
     onSirenDetected: Observable<SirenState>;
+    snapshot(): Promise<ArrayBuffer>;
+    setPrebufferSource(sourceName: string, address: string | null, type: 'recording' | 'stream'): Promise<void>;
+    getFfmpegPath(): Promise<string>;
+    getIceServers(): Promise<RTCIceServer[]>;
     getValue<T extends keyof StateValues>(stateName: T): StateValue<T>;
-    createSession(cameraInput: CameraInput, options?: StreamingConnectionOptions): Promise<StreamingSession>;
-    streamVideo(cameraInput: CameraInput, options: FfmpegOptions): Promise<StreamingSession>;
-    recordToFile(cameraInput: CameraInput, outputPath: string, duration?: number): Promise<void>;
-    updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): void;
+    createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<StreamingSession>;
+    streamVideo(sourceName: string, options: FfmpegOptions): Promise<StreamingSession>;
+    recordToFile(sourceName: string, outputPath: string, duration?: number): Promise<void>;
+    updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): Promise<void>;
     onStateChange<T extends keyof StateValues>(stateName: T): Observable<{
         newState: StateValues[T];
         oldState: StateValues[T];
     }>;
-    onPropertyChange<T extends keyof Camera>(property: T): Observable<{
+    onPropertyChange<T extends keyof CameraPublicProperties>(property: T): Observable<{
         oldState: Camera[T];
         newState: Camera[T];
     }>;
@@ -84,10 +97,17 @@ export type Go2RtcOutgoingMessage = Go2RtcOfferMessage | Go2RtcIceCandidateMessa
 export interface CameraConfig {
     name: string;
     nativeId?: string;
+    isCloud?: boolean;
+    hasLight?: boolean;
+    hasSiren?: boolean;
     disabled?: boolean;
     model?: string;
     sources: CameraInputSettings[];
 }
+export interface Input extends CameraInput {
+    readonly isStreamPrebuffering?: boolean;
+    readonly isRecordingPrebuffering?: boolean;
+}
 export interface BaseState {
     timestamp: number;
     lastTriggered: number;

package/dist/src/plugins/base.d.ts

@@ -3,7 +3,7 @@ import type { CameraDevice } from '../camera/types';
 import type { PluginLogger } from '../services/logger';
 import type { PluginConfigService } from './config';
 import type { BasePlugin as BasePluginMethods } from './types';
-import type { Storage } from './storage';
+import type { Storage } from './storageController';
 export declare class BasePlugin implements BasePluginMethods {
     id: string;
     api: API;

package/dist/src/plugins/index.d.ts

@@ -26,11 +26,16 @@ export declare class PluginManager {
     initializePlugin(plugin: Plugin, pluginName: string): Promise<void>;
     loadPlugin(absolutePath: string, pluginId?: string, storagePath?: string): Promise<Plugin>;
     removePlugin(plugin: Plugin, removeFromDb?: boolean, removeStorage?: boolean): Promise<void>;
-    startPluginChild(pluginName: string): Promise<void>;
     startPluginChilds(): Promise<void>;
+    startPluginChild(pluginName: string): Promise<void>;
+    stopPluginChild(pluginName: string): Promise<void>;
     private loadInstalledPlugins;
-    private loadDefaultPaths;
     private removeOrphanedPlugins;
+    private buildDependencyGraph;
+    private groupPlugins;
+    private topologicalSort;
     private handlePluginRegistration;
+    private loadDefaultPaths;
     private addNpmPrefixToSearchPaths;
+    private isDependencyForOthers;
 }

package/dist/src/plugins/plugin.d.ts

@@ -16,7 +16,7 @@ export interface Context {
  * Represents a loaded camera.ui plugin.
  */
 export declare class Plugin {
-    disabled: boolean;
+    _disabled: boolean;
     private logger;
     private configService;
     private _info;
@@ -35,8 +35,11 @@ export declare class Plugin {
     private loadContext?;
     private pluginInitializer?;
     private pluginConstructor;
-    get info(): CameraUiPlugin;
     get contract(): PluginContract;
+    get info(): CameraUiPlugin;
+    set info(value: CameraUiPlugin);
+    get disabled(): boolean;
+    set disabled(value: boolean);
     constructor(pluginName: string, installPath: string, packageJSON: IPackageJson, pluginId: string, scope?: string, storagePath?: string);
     getPluginConstructor(pluginName: string): PluginConstructor;
     initialize(api: CameraUiAPI): void | Promise<void>;

package/dist/src/plugins/types.d.ts

@@ -1,5 +1,8 @@
 import type { Camera } from '../api/database/types';
 import type { CameraDevice } from '../camera/types';
+export type PluginGraph = Map<string, string[]>;
+export type PluginCycles = Map<string, string[]>;
+export type PluginGroups = Map<string, string[]>;
 export interface SchemaConfig {
     rootSchema: PluginRootSchema;
     config: Record<string, any>;
@@ -23,12 +26,13 @@ export interface JSONObject {
 }
 export type JSONArray = JSONValue[];
 export type PluginConfig = Record<string, any>;
-export type CameraExtension = 'hub' | 'prebuffer' | 'motionDetection' | 'objectDetection' | 'soundDetection' | 'intercom' | 'ptz';
+export type CameraExtension = 'hub' | 'prebuffer' | 'motionDetection' | 'objectDetection' | 'audioDetection' | 'ptz';
 export declare const CAMERA_EXTENSIONS: CameraExtension[];
 export interface PluginContract {
     pluginName: string;
     builtIns?: CameraExtension[];
     extension?: CameraExtension;
+    dependencies?: string[];
 }
 export declare const enum PLUGIN_STATUS {
     READY = "ready",

package/dist/src/plugins/worker.d.ts

@@ -18,6 +18,7 @@ export declare class PluginWorker {
     teardown(): Promise<void>;
     restart(): Promise<void>;
     getPID(): number;
+    isRunning(): boolean;
     private gatherDevices;
     private kill;
     private setStatus;

package/dist/src/proxy/client/cameraDevice.d.ts

@@ -1,29 +1,24 @@
 import { CameraDeviceHub } from '../../camera';
 import type { Camera } from '../../api/database/types';
-import type { StateValues, OnSetEvent } from '../../camera/types';
-import type { Logger, PluginLogger } from '../../services/logger';
-export declare class CameraDeviceProxy extends CameraDeviceHub {
+import type { StateValues, OnSetEvent, BaseLogger, PrebufferType } from '../../camera/types';
+import type { IceServer } from '../../services/config/types';
+export declare class CameraDeviceClientProxy extends CameraDeviceHub {
     private targetId;
     private targetName;
     private clientTargetId;
     private subTargetId;
+    private pluginId;
     private api;
-    private log;
     private client;
     private subscriber;
-    private timeout;
-    private requestIdCounter;
-    private pendingRequests;
-    private requestQueue;
-    private isProcessing;
+    private messageQueue;
     private close?;
-    constructor(camera: Camera, logger: Logger | PluginLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, serverPublicKey: string);
+    constructor(camera: Camera, logger: BaseLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, serverPublicKey: string);
+    setPrebufferSource(sourceName: string, address: string | null, type: PrebufferType): Promise<void>;
+    getFfmpegPath(): Promise<string>;
+    getIceServers(): Promise<IceServer[]>;
     updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): Promise<void>;
     refreshStates(): Promise<void>;
     private listenToSubscriberEvents;
     private onRequest;
-    private enqueueAndProcessRequest;
-    private processNextRequest;
-    private onReply;
-    private resolveRequest;
 }

package/dist/src/proxy/client/deviceManager.d.ts

@@ -1,6 +1,6 @@
+import { CameraDeviceClientProxy } from '../client/cameraDevice';
+import type { CameraConfig, CameraDevice, BaseLogger } from '../../camera/types';
 import type { DeviceManagerProxyMethods, DeviceManagerProxyEventCallbacks } from '../types';
-import type { Logger, PluginLogger } from '../../services/logger';
-import type { CameraConfig, CameraDevice } from '../../camera/types';
 export declare class DeviceManager implements DeviceManagerProxyMethods {
     private pluginId;
     private pluginName;
@@ -10,18 +10,14 @@ export declare class DeviceManager implements DeviceManagerProxyMethods {
     private logger;
     private client;
     private subscriber;
+    private messageQueue;
     private reqServerAddress;
     private pubServerAddress;
     private serverPublicKey;
     private MAX_LISTENERS_PER_EVENT;
-    private timeout;
-    private requestIdCounter;
-    private pendingRequests;
-    private requestQueue;
-    private isProcessing;
     private devices;
     private eventListeners;
-    constructor(logger: Logger | PluginLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, serverPublicKey: string);
+    constructor(logger: BaseLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, serverPublicKey: string, cameraDevices?: CameraDeviceClientProxy[]);
     getCameraById(id: string): Promise<CameraDevice | undefined>;
     getCameraByName(name: string): Promise<CameraDevice | undefined>;
     createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
@@ -32,9 +28,5 @@ export declare class DeviceManager implements DeviceManagerProxyMethods {
     removeAllListeners<E extends keyof DeviceManagerProxyEventCallbacks>(eventType?: E): void;
     private listenToSubscriberEvents;
     private onRequest;
-    private enqueueAndProcessRequest;
-    private processNextRequest;
-    private onReply;
-    private resolveRequest;
     private addCamera;
 }

package/dist/src/proxy/client/pluginsManager.d.ts

@@ -1,5 +1,5 @@
+import type { BaseLogger } from '../../camera/types';
 import type { PluginsManagerProxyMethods, PluginsManagerProxyEventCallbacks } from '../types';
-import type { Logger, PluginLogger } from '../../services/logger';
 export declare class PluginsManager implements PluginsManagerProxyMethods {
     private pluginId;
     private pluginName;
@@ -12,24 +12,16 @@ export declare class PluginsManager implements PluginsManagerProxyMethods {
     private client;
     private subscriber;
     private dealer;
+    private messageQueue;
     private MAX_LISTENERS_PER_EVENT;
-    private timeout;
-    private requestIdCounter;
-    private pendingRequests;
-    private requestQueue;
-    private isProcessing;
     private eventListeners;
-    constructor(logger: Logger | PluginLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, routerAddress: string, serverPublicKey: string);
+    constructor(logger: BaseLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, routerAddress: string, serverPublicKey: string);
     listen<E extends keyof PluginsManagerProxyEventCallbacks>(eventType: E, callback: PluginsManagerProxyEventCallbacks[E]): void;
     removeListener<E extends keyof PluginsManagerProxyEventCallbacks>(eventType: E, callbackToRemove: PluginsManagerProxyEventCallbacks[E]): void;
     removeAllListeners<E extends keyof PluginsManagerProxyEventCallbacks>(eventType?: E): void;
     private listenToSubscriberEvents;
     private listenToRouterRequests;
     private onRequest;
-    private enqueueAndProcessRequest;
-    private processNextRequest;
-    private onReply;
-    private resolveRequest;
     private isPluginMessage;
     private isStorageMessage;
 }

package/dist/src/proxy/client/queue.d.ts

@@ -0,0 +1,11 @@
+import { Request } from 'zeromq';
+export declare class ClientMessageQueue {
+    private requestClient;
+    private queue;
+    private isProcessing;
+    private pendingResponses;
+    constructor(requestClient: Request);
+    enqueue(message: any, timeout?: number): Promise<any>;
+    private processQueue;
+    private listenToReplies;
+}

package/dist/src/proxy/client/systemManager.d.ts

@@ -1,5 +1,5 @@
+import type { BaseLogger } from '../../camera/types';
 import type { SystemManagerProxyMethods, SystemManagerProxyEventCallbacks } from '../types';
-import type { Logger, PluginLogger } from '../../services/logger';
 export declare class SystemManager implements SystemManagerProxyMethods {
     private pluginId;
     private pluginName;
@@ -9,21 +9,13 @@ export declare class SystemManager implements SystemManagerProxyMethods {
     private logger;
     private client;
     private subscriber;
+    private messageQueue;
     private MAX_LISTENERS_PER_EVENT;
-    private timeout;
-    private requestIdCounter;
-    private pendingRequests;
-    private requestQueue;
-    private isProcessing;
     private eventListeners;
-    constructor(logger: Logger | PluginLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, serverPublicKey: string);
+    constructor(logger: BaseLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, serverPublicKey: string);
     listen<E extends keyof SystemManagerProxyEventCallbacks>(eventType: E, callback: SystemManagerProxyEventCallbacks[E]): void;
     removeListener<E extends keyof SystemManagerProxyEventCallbacks>(eventType: E, callbackToRemove: SystemManagerProxyEventCallbacks[E]): void;
     removeAllListeners<E extends keyof SystemManagerProxyEventCallbacks>(eventType?: E): void;
     private listenToSubscriberEvents;
     private onRequest;
-    private enqueueAndProcessRequest;
-    private processNextRequest;
-    private onReply;
-    private resolveRequest;
 }

package/dist/src/proxy/constants.d.ts

@@ -0,0 +1,7 @@
+import type { SocketOptions, Router, Reply, Publisher, Request, Dealer, Subscriber } from 'zeromq';
+export declare const ROUTER_OPTIONS: SocketOptions<Router>;
+export declare const REPLY_OPTIONS: SocketOptions<Reply>;
+export declare const PUBLISHER_OPTIONS: SocketOptions<Publisher>;
+export declare const REQUEST_OPTIONS: SocketOptions<Request>;
+export declare const SUBSCRIBER_OPTIONS: SocketOptions<Subscriber>;
+export declare const DEALER_OPTIONS: SocketOptions<Dealer>;

package/dist/src/proxy/index.d.ts

@@ -1,20 +1,26 @@
+import { Reply, Router, Publisher } from 'zeromq';
 import { ServerProxy } from './proxies/server';
 import { CameraDeviceProxy } from './proxies/camera';
 import { PluginProxy } from './proxies/plugin';
-import type { ProxyEvents, TargetID } from './types';
+import type { ProxyBridge } from './ws';
+import type { ProxyEvents, TargetID, QueueItem } from './types';
 export declare class ProxyServer {
     server?: ServerProxy;
     camera?: CameraDeviceProxy;
     plugin?: PluginProxy;
     private logger;
     private configService;
-    private router;
-    private reqServer;
-    private pubServer;
-    private socketBridge?;
+    router: Router;
+    reqServer: Reply;
+    pubServer: Publisher;
+    socketBridge?: ProxyBridge;
+    private messageQueue;
     constructor();
     initialize(): Promise<void>;
     close(): Promise<void>;
+    sendMessage(item: QueueItem): Promise<void>;
     publishEvent<K extends keyof ProxyEvents>(targetId: TargetID, type: K, data: ProxyEvents[K]): Promise<void>;
-    private reqMessages;
+    private listenToRequestMessages;
+    private listenToRouterMessages;
+    private isProxyMessage;
 }

package/dist/src/proxy/proxies/camera.d.ts

@@ -1,13 +1,25 @@
-import type { Publisher, Reply } from 'zeromq';
-import type { CameraDeviceProxyMessageStructure, CameraDeviceProxyMethods, CameraDeviceListenerMessagePayload, CameraId } from '../types';
+import type { CameraInput } from '../../api/database/types';
 import type { OnSetEvent, StateValues } from '../../camera/types';
-import type { ProxyBridge } from '../ws';
+import type { IceServer } from '../../services/config/types';
+import type { FfmpegOptions, PrebufferType } from '../../camera/types';
+import type { ProxyServer } from '..';
+import type { CameraDeviceProxyMessageStructure, CameraDeviceProxyMethods, CameraDeviceListenerMessagePayload, CameraId } from '../types';
 export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     private api;
-    private reqServer;
-    private pubServer;
-    private socketBridge;
-    constructor(reqServer: Reply, pubServer: Publisher, socketBridge: ProxyBridge);
+    private configService;
+    private camerasService;
+    private pluginsService;
+    private proxyServer;
+    constructor(proxyServer: ProxyServer);
+    setPrebufferSource(data: {
+        sourceName: string;
+        address: string | null;
+        type: PrebufferType;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    getFffmpegPath(): string;
+    getIceServers(): IceServer[];
     updateState<T extends keyof StateValues>(data: {
         stateName: T;
         eventData: OnSetEvent<T>;
@@ -15,8 +27,22 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     }): void;
     refreshStates(data: {
         cameraId: string;
-    }): StateValues | undefined;
-    reqMessages(msg: CameraDeviceProxyMessageStructure): Promise<void>;
+    }): {
+        sources: CameraInput[];
+        states: StateValues;
+    } | undefined;
+    streamVideo(data: {
+        sourceName: string;
+        options: FfmpegOptions;
+        cameraId: string;
+    }): Promise<void>;
+    recordToFile(data: {
+        sourceName: string;
+        outputPath: string;
+        duration?: number;
+        cameraId: string;
+    }): Promise<void>;
+    handleMessage(msg: CameraDeviceProxyMessageStructure): Promise<void>;
     publishCameraMessage<K extends keyof StateValues>(cameraId: CameraId, stateName: K, data: {
         newEvent: StateValues[K];
         oldEvent: StateValues[K];

package/dist/src/proxy/proxies/plugin.d.ts

@@ -1,30 +1,10 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Router } from 'zeromq';
 import { type CameraStorage, type BasePlugin } from '../../plugins/types';
+import type { ProxyServer } from '..';
 import type { MethodKeys } from '../types';
 export declare class PluginProxy {
-    private logger;
     private pluginsService;
-    private router;
-    private timeout;
-    private pluginRequestIdCounter;
-    private storageRequestIdCounter;
-    pendingRequests: Map<string, {
-        resolve: (value: unknown) => void;
-        reject: (reason?: any) => void;
-        timeout: NodeJS.Timeout;
-    }>;
-    private requestQueue;
-    private isProcessing;
-    constructor(router: Router);
+    private proxyServer;
+    constructor(proxyServer: ProxyServer);
     onRequestPluginFn<K extends Exclude<MethodKeys<BasePlugin>, 'configureCameras'>>(pluginId: string, fn: K, ...args: Parameters<BasePlugin[K]>): Promise<ReturnType<BasePlugin[K]>>;
     onRequestStorageFn<K extends MethodKeys<CameraStorage>>(pluginId: string, cameraId: string, fn: K, ...args: Parameters<CameraStorage[K]>): Promise<ReturnType<CameraStorage[K]>>;
-    private enqueueAndProcessRequest;
-    private processNextRequest;
-    private onReply;
-    private resolveRequest;
 }

package/dist/src/proxy/proxies/server.d.ts

@@ -1,5 +1,5 @@
-import type { Reply } from 'zeromq';
-import type { ApiProxyMethods, SystemProxyMethods, ProxyMessageStructure } from '../types';
+import type { ProxyServer } from '..';
+import type { ApiProxyMethods, ProxyMessageStructure } from '../types';
 import type { Camera } from '../../api/database/types';
 import type { CameraConfig } from '../../camera/types';
 export declare interface ServerProxy {
@@ -7,11 +7,11 @@ export declare interface ServerProxy {
     removeListener(): any;
     removeAllListeners(): any;
 }
-export declare class ServerProxy implements ApiProxyMethods, SystemProxyMethods {
+export declare class ServerProxy implements ApiProxyMethods {
     private camerasService;
     private pluginsService;
-    private reqServer;
-    constructor(reqServer: Reply);
+    private proxyServer;
+    constructor(proxyServer: ProxyServer);
     getCameraByName(data: {
         name: string;
     }): Promise<Camera | undefined>;
@@ -30,5 +30,5 @@ export declare class ServerProxy implements ApiProxyMethods, SystemProxyMethods
         id: string;
         pluginId: string;
     }): Promise<void>;
-    reqMessages(msg: ProxyMessageStructure): Promise<void>;
+    handleMessage(msg: ProxyMessageStructure): Promise<void>;
 }

package/dist/src/proxy/queue.d.ts

@@ -0,0 +1,15 @@
+import type { Reply, Router } from 'zeromq';
+import type { QueueItem } from './types';
+export declare class MessageQueue {
+    private queue;
+    private isProcessing;
+    private pendingResponses;
+    private reqServer;
+    private router;
+    constructor(reqServer: Reply, router: Router);
+    addToQueue(item: QueueItem): Promise<void>;
+    receiveResponse(requestId: string, response: any): void;
+    receiveError(requestId: string, error: Error): void;
+    private processQueue;
+    private sendMessage;
+}

package/dist/src/proxy/types.d.ts

@@ -1,17 +1,34 @@
 /// <reference types="node" />
-import type { Camera } from '../api/database/types';
+import type { Camera, CameraInput } from '../api/database/types';
 import type { BasePlugin, CameraStorage } from '../plugins/types';
-import type { CameraConfig, OnSetEvent, StateValues, CameraDevice } from '../camera/types';
+import type { CameraConfig, OnSetEvent, StateValues, CameraDevice, FfmpegOptions, PrebufferType } from '../camera/types';
+import type { IceServer } from '../services/config/types';
 export type MethodKeys<T> = {
     [K in keyof T]: T[K] extends Function ? K : never;
 }[keyof T];
+export interface ClientQueueItem {
+    requestId: string;
+    message: any;
+    resolve: (response: any) => void;
+    reject: (error: Error) => void;
+    timeout: number;
+}
+export interface QueueItem {
+    requestType: 'router' | 'request';
+    targetId: string;
+    requestId: string;
+    message: any;
+    timeout?: number;
+    onResponse?: (response: any) => void;
+    onError?: (error: Error) => void;
+}
 export interface RequestPayload {
     fn: string;
     data: Record<string, any>;
     requestId: string;
 }
 export interface QueueRequestItem {
-    payload: RequestPayload;
+    payload: CameraDeviceProxyMessageStructure | ProxyMessageStructure;
     resolve: (value: any) => void;
     reject: (reason?: any) => void;
     timeout: NodeJS.Timeout;
@@ -40,7 +57,7 @@ export type CameraId = string;
 export type PluginId = string;
 export type TargetID = CameraId | PluginId | 'all';
 export interface PendingMessagePayload {
-    replyTo: string;
+    requestId: string;
     response?: any;
 }
 export interface ListenerMessagePayload {
@@ -82,7 +99,9 @@ export interface ApiProxyMethods {
         pluginId: string;
     }): Promise<void>;
 }
-export interface SystemProxyMethods {
+export interface WsManagerClientMessage {
+    method: ProxyMethodNames;
+    args: any[];
 }
 export interface DeviceManagerListenerMessagePayload {
     type: keyof DeviceManagerProxyEventCallbacks;
@@ -170,14 +189,47 @@ export interface CameraDeviceProxyMessageStructure {
     timestamp: number;
 }
 export interface CameraDeviceProxyMethods {
+    setPrebufferSource(data: {
+        sourceName: string;
+        address: string | null;
+        type: PrebufferType;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    getFffmpegPath(data: {
+        cameraId: string;
+        pluginId: string;
+    }): string;
+    getIceServers(data: {
+        cameraId: string;
+        pluginId: string;
+    }): IceServer[];
     updateState<T extends keyof StateValues>(data: {
         stateName: T;
         eventData: OnSetEvent<T>;
         cameraId: string;
+        pluginId: string;
     }): void;
     refreshStates(data: {
         cameraId: string;
-    }): StateValues | undefined;
+        pluginId: string;
+    }): {
+        sources: CameraInput[];
+        states: StateValues;
+    } | undefined;
+    streamVideo(data: {
+        sourceName: string;
+        options: FfmpegOptions;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    recordToFile(data: {
+        sourceName: string;
+        outputPath: string;
+        duration?: number;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
 }
 export type CameraDeviceProxyMethodNames = MethodKeys<CameraDeviceProxyMethods>;
 export type CameraDeviceProxyEventCallbacks = {
@@ -187,3 +239,7 @@ export interface CameraDeviceProxyGenericEvent<K extends keyof StateValues> {
     type: K;
     data: StateValues[K];
 }
+export interface WsCameraDeviceClientMessage {
+    method: CameraDeviceProxyMethodNames;
+    args: any[];
+}