@camera.ui/browser 0.0.34 → 0.0.35

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

@@ -1,6 +1,8 @@
+/// <reference types="pouchdb-core" />
+/// <reference types="node" />
 import type { Observable, Subject } from 'rxjs';
 import type { ConnectionState, RTCIceCandidate } from 'werift';
-import type { CameraInput, Camera, CameraPublicProperties, CameraInputSettings } from '../api/database/types';
+import type { Camera, CameraPublicProperties, CameraInputSettings, CameraZone, CameraSource } from '../api/database/types';
 import type { StreamingSession } from './streaming/streaming-session';
 export type SpawnInput = string | number;
 export type PrebufferType = 'recording' | 'stream';
@@ -35,9 +37,16 @@ export interface BasicPeerConnection {
 }
 export interface CameraDevice {
     id: string;
+    pluginId: string;
+    nativeId?: string;
     disabled: boolean;
     name: string;
-    nativeId?: string;
+    type: string;
+    model: string;
+    sources: CameraSource[];
+    motionZones: CameraZone[];
+    objectZones: CameraZone[];
+    logger: BaseLogger;
     isCloud: boolean;
     hasLight: boolean;
     hasSiren: boolean;
@@ -45,37 +54,44 @@ export interface CameraDevice {
     hasAudioDetector: boolean;
     hasObjectDetector: boolean;
     hasPtz: boolean;
-    type: string;
-    model: string;
-    sources: CameraInput[];
-    logger: BaseLogger;
     onLightDetected: Observable<LightState>;
     onMotionDetected: Observable<MotionState>;
     onAudioDetected: Observable<AudioState>;
     onObjectDetected: Observable<ObjectState>;
     onDoorbellPressed: Observable<DoorbellState>;
     onSirenDetected: Observable<SirenState>;
-    snapshot(sourceName?: string, prebuffer?: boolean): Promise<ArrayBuffer>;
+    getStreamSource(): CameraSource;
+    getSnapshotSource(): CameraSource;
+    getRecordingSource(): CameraSource;
+    getDetectionSource(): CameraSource;
+    configureDelegate(delegate: CameraDelegate): void;
+    snapshot(prebuffer?: boolean): Promise<ArrayBuffer>;
     setPrebufferSource(sourceName: string, address: string, type: 'recording' | 'stream'): Promise<void>;
     removePrebufferSource(sourceName: string, type: 'recording' | 'stream'): Promise<void>;
     removePrebufferSources(): Promise<void>;
     getFfmpegPath(): Promise<string>;
     getIceServers(): Promise<RTCIceServer[]>;
-    getValue<T extends keyof StateValues>(stateName: T): StateValue<T>;
     createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<StreamingSession>;
     streamVideo(sourceName: string, options: FfmpegOptions): Promise<StreamingSession>;
     recordToFile(sourceName: string, outputPath: string, duration?: number): Promise<void>;
+    getValue<T extends keyof StateValues>(stateName: T): StateValue<T>;
     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 CameraPublicProperties>(property: T): Observable<{
-        oldState: Camera[T];
-        newState: Camera[T];
+        oldData: Camera[T];
+        newData: Camera[T];
     }>;
     removeAllListeners(): void;
 }
+export interface CameraDelegate {
+    snapshotRequest(requestId: string): Promise<Buffer>;
+    prepareStream(requestId: string): Promise<void>;
+    onOffer(requestId: string, sdp: string): Promise<string>;
+    onCandidates(requestId: string, candidates: string): Promise<void>;
+}
 export type Sdp = string;
 export type IceCandiate = string;
 export interface Go2RtcOfferMessage {
@@ -96,7 +112,7 @@ export interface ErrorMessage {
 }
 export type Go2RtcIncomingMessage = Go2RtcAnswerMessage | Go2RtcIceCandidateMessage | ErrorMessage;
 export type Go2RtcOutgoingMessage = Go2RtcOfferMessage | Go2RtcIceCandidateMessage;
-export interface CameraConfig {
+export interface BaseCameraConfig {
     name: string;
     nativeId?: string;
     isCloud?: boolean;
@@ -104,8 +120,12 @@ export interface CameraConfig {
     hasSiren?: boolean;
     disabled?: boolean;
     model?: string;
-    sources: CameraInputSettings[];
 }
+export type CameraConfig = (BaseCameraConfig & {
+    sources?: Omit<CameraInputSettings, '_id'>[];
+}) | (BaseCameraConfig & {
+    delegate?: CameraDelegate;
+});
 export interface BaseState {
     timestamp: number;
     lastTriggered: number;

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

@@ -22,7 +22,8 @@ export declare class CameraStorage implements CameraStorageMethods {
      * @param path - The path to the configuration value.
      * @returns The value from the configuration.
      */
-    getValue<T = string>(path: string): Promise<T> | undefined;
+    getValue<T = string>(path: string, defaultValue: T): Promise<T> | T;
+    getValue<T = string>(path: string, defaultValue?: T): Promise<T> | T | undefined;
     /**
      * Set a new value for a given key/path in the configuration.
      * If the schema of the value has an onSet function, and the value has changed, the onSet function will be called.
@@ -101,4 +102,5 @@ export declare class CameraStorage implements CameraStorageMethods {
     private filterStorableValues;
     private containsStorableSchema;
     private saveDb;
+    private removeDb;
 }

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

@@ -31,9 +31,6 @@ export declare class PluginManager {
     stopPluginChild(pluginName: string): Promise<void>;
     private loadInstalledPlugins;
     private removeOrphanedPlugins;
-    private buildDependencyGraph;
-    private groupPlugins;
-    private topologicalSort;
     private handlePluginRegistration;
     private loadDefaultPaths;
     private addNpmPrefixToSearchPaths;

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;
+    private _disabled;
     private logger;
     private configService;
     private _info;

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

@@ -26,14 +26,21 @@ export interface JSONObject {
 }
 export type JSONArray = JSONValue[];
 export type PluginConfig = Record<string, any>;
-export type CameraExtension = 'hub' | 'prebuffer' | 'motionDetection' | 'objectDetection' | 'audioDetection' | 'ptz';
 export declare const CAMERA_EXTENSIONS: CameraExtension[];
-export interface PluginContract {
+export type CameraExtension = 'hub' | 'prebuffer' | 'motionDetection' | 'objectDetection' | 'audioDetection' | 'ptz';
+type ExtensionOrSupport = {
+    extension: CameraExtension;
+    supportAdditionalCameras?: never;
+} | {
+    extension?: never;
+    supportAdditionalCameras?: boolean;
+};
+export interface PluginContractBase {
     pluginName: string;
-    builtIns?: CameraExtension[];
-    extension?: CameraExtension;
+    builtIns?: Exclude<CameraExtension, 'hub'>[];
     dependencies?: string[];
 }
+export type PluginContract = PluginContractBase & ExtensionOrSupport;
 export declare const enum PLUGIN_STATUS {
     READY = "ready",
     STARTING = "starting",
@@ -54,7 +61,6 @@ export interface PluginStorage {
 }
 export interface ZmqInfo {
     zmqRouterAddress: string;
-    zmqReqAddress: string;
     zmqPubAddress: string;
     zmqPublicKey: string;
 }
@@ -87,7 +93,7 @@ export interface JsonBaseSchema<T = any> {
 }
 export interface PluginJsonBaseSchema<T = any> extends JsonBaseSchema<T> {
     store?: boolean;
-    onSet?: (newValue: any, oldValue: any) => void | Promise<void>;
+    onSet?: (newValue: any, oldValue: any) => Promise<void> | void;
     onGet?: () => any | Promise<any>;
 }
 export interface JsonSchemaString extends JsonBaseSchema<string> {
@@ -130,10 +136,12 @@ export interface PluginJsonSchemaEnum extends PluginJsonBaseSchema<string | numb
 }
 export interface JsonSchemaObject extends JsonBaseSchema {
     type: 'object';
+    opened?: boolean;
     properties?: JsonSchemaForm;
 }
 export interface PluginJsonSchemaObject extends PluginJsonBaseSchema {
     type: 'object';
+    opened?: boolean;
     properties?: PluginJsonSchemaForm;
 }
 export interface JsonSchemaObjectWithButtons extends JsonSchemaObject {
@@ -144,6 +152,7 @@ export interface JsonSchemaAnyOf {
 }
 export interface JsonSchemaArray extends JsonBaseSchema {
     type: 'array';
+    opened?: boolean;
     items?: JsonSchema | JsonSchemaAnyOf;
 }
 export interface JsonSchemaButton {
@@ -164,3 +173,4 @@ export interface RootSchema {
 export interface PluginRootSchema {
     schema: PluginJsonSchemaForm;
 }
+export {};

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

@@ -1,19 +1,19 @@
 import { CameraDeviceHub } from '../../camera';
 import type { Camera } from '../../api/database/types';
-import type { StateValues, OnSetEvent, BaseLogger, PrebufferType } from '../../camera/types';
+import type { StateValues, OnSetEvent, PrebufferType, CameraDelegate } 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 removed;
     private api;
-    private client;
+    private dealer;
     private subscriber;
     private messageQueue;
+    private dealerId;
+    private subscriberId;
+    private pluginID;
     private close?;
-    constructor(camera: Camera, logger: BaseLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, serverPublicKey: string);
+    constructor(camera: Camera, pluginId: string, pluginName: string, routerAddress: string, publisherAddress: string, serverPublicKey: string);
+    configureDelegate(delegate: CameraDelegate): void;
     setPrebufferSource(sourceName: string, address: string | null, type: PrebufferType): Promise<void>;
     removePrebufferSource(sourceName: string, type: 'recording' | 'stream'): Promise<void>;
     removePrebufferSources(): Promise<void>;
@@ -21,6 +21,7 @@ export declare class CameraDeviceClientProxy extends CameraDeviceHub {
     getIceServers(): Promise<IceServer[]>;
     updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): Promise<void>;
     refreshStates(): Promise<void>;
+    private handleRouterRequest;
     private listenToSubscriberEvents;
     private onRequest;
 }

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

@@ -1,23 +1,23 @@
 import { CameraDeviceClientProxy } from '../client/cameraDevice';
-import type { CameraConfig, CameraDevice, BaseLogger } from '../../camera/types';
-import type { DeviceManagerProxyMethods, DeviceManagerProxyEventCallbacks } from '../types';
-export declare class DeviceManager implements DeviceManagerProxyMethods {
-    private pluginId;
-    private pluginName;
-    private clientTargetId;
-    private subTargetId;
+import type { CameraConfig, CameraDevice } from '../../camera/types';
+import type { DeviceManagerProxyMethods, DeviceManagerProxyEventCallbacks, DeviceManagerProxyMethodsListener } from '../types';
+export declare class DeviceManager implements DeviceManagerProxyMethods, DeviceManagerProxyMethodsListener {
     private api;
     private logger;
-    private client;
+    private dealer;
     private subscriber;
     private messageQueue;
-    private reqServerAddress;
-    private pubServerAddress;
+    private routerAddress;
+    private publisherAddress;
     private serverPublicKey;
+    private pluginId;
+    private pluginName;
+    private dealerId;
+    private subscriberId;
     private MAX_LISTENERS_PER_EVENT;
     private devices;
     private eventListeners;
-    constructor(logger: BaseLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, serverPublicKey: string, cameraDevices?: CameraDeviceClientProxy[]);
+    constructor(pluginId: string, pluginName: string, routerAddress: string, publisherAddress: string, serverPublicKey: string, cameraDevices?: CameraDeviceClientProxy[]);
     getCameraById(id: string): Promise<CameraDevice | undefined>;
     getCameraByName(name: string): Promise<CameraDevice | undefined>;
     createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
@@ -26,7 +26,8 @@ export declare class DeviceManager implements DeviceManagerProxyMethods {
     listen<E extends keyof DeviceManagerProxyEventCallbacks>(eventType: E, callback: DeviceManagerProxyEventCallbacks[E]): void;
     removeListener<E extends keyof DeviceManagerProxyEventCallbacks>(eventType: E, callbackToRemove: DeviceManagerProxyEventCallbacks[E]): void;
     removeAllListeners<E extends keyof DeviceManagerProxyEventCallbacks>(eventType?: E): void;
+    private handleRouterRequest;
     private listenToSubscriberEvents;
     private onRequest;
-    private addCamera;
+    private addOrGetCamera;
 }

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

@@ -1,26 +1,23 @@
-import type { BaseLogger } from '../../camera/types';
-import type { PluginsManagerProxyMethods, PluginsManagerProxyEventCallbacks } from '../types';
-export declare class PluginsManager implements PluginsManagerProxyMethods {
-    private pluginId;
-    private pluginName;
-    private clientTargetId;
-    private subTargetId;
-    private dealerTargetId;
+import type { PluginsManagerProxyMethods, PluginsManagerProxyMethodsListener, PluginsManagerProxyEventCallbacks } from '../types';
+export declare class PluginsManager implements PluginsManagerProxyMethods, PluginsManagerProxyMethodsListener {
     private api;
     private logger;
     private plugin?;
-    private client;
-    private subscriber;
     private dealer;
+    private subscriber;
     private messageQueue;
+    private pluginId;
+    private pluginName;
+    private dealerId;
+    private subscriberId;
     private MAX_LISTENERS_PER_EVENT;
     private eventListeners;
-    constructor(logger: BaseLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, routerAddress: string, serverPublicKey: string);
+    constructor(pluginId: string, pluginName: string, routerAddress: string, publisherAddress: 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 handleRouterRequest;
     private listenToSubscriberEvents;
-    private listenToRouterRequests;
     private onRequest;
     private isPluginMessage;
     private isStorageMessage;

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

@@ -1,13 +1,14 @@
-import { Request } from 'zeromq';
-import type { BaseLogger } from '../../camera/types';
+import { Dealer } from 'zeromq';
+import type { ProxyMessageStructure } from '../types';
 export declare class ClientMessageQueue {
     private logger;
-    private requestClient;
-    private queue;
+    private dealer;
+    private requestHandler;
     private isProcessing;
+    private queue;
     private pendingResponses;
-    constructor(requestClient: Request, logger: BaseLogger);
-    enqueue(message: any, timeout?: number): Promise<any>;
+    constructor(requestHandler: (message: ProxyMessageStructure) => void, dealer: Dealer);
+    enqueue(message: ProxyMessageStructure): Promise<any>;
     private processQueue;
-    private listenToReplies;
+    private listenToRouter;
 }

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

@@ -1,21 +1,21 @@
-import type { BaseLogger } from '../../camera/types';
-import type { SystemManagerProxyMethods, SystemManagerProxyEventCallbacks } from '../types';
-export declare class SystemManager implements SystemManagerProxyMethods {
-    private pluginId;
-    private pluginName;
-    private clientTargetId;
-    private subTargetId;
+import type { SystemManagerProxyMethods, SystemManagerProxyMethodsListener, SystemManagerProxyEventCallbacks } from '../types';
+export declare class SystemManager implements SystemManagerProxyMethods, SystemManagerProxyMethodsListener {
     private api;
     private logger;
-    private client;
+    private dealer;
     private subscriber;
     private messageQueue;
+    private pluginId;
+    private pluginName;
+    private dealerId;
+    private subscriberId;
     private MAX_LISTENERS_PER_EVENT;
     private eventListeners;
-    constructor(logger: BaseLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, serverPublicKey: string);
+    constructor(pluginId: string, pluginName: string, routerAddress: string, publisherAddress: 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 handleRouterRequest;
     private listenToSubscriberEvents;
     private onRequest;
 }

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

@@ -1,23 +1,29 @@
-import { Reply, Router, Publisher } from 'zeromq';
+import { Router, Publisher } from 'zeromq';
 import { ServerProxy } from './proxies/server';
 import { CameraDeviceProxy } from './proxies/camera';
 import { PluginProxy } from './proxies/plugin';
 import type { ProxyBridge } from './ws';
-import type { ProxyEvents, TargetID, QueueItem } from './types';
+import type { StateValues } from '../camera/types';
+import type { DeviceManagerProxyEvents, SystemManagerProxyEvents, PluginsManagerProxyEvents, CameraDeviceListenerMessagePayload } from './types';
 export declare class ProxyServer {
     server?: ServerProxy;
     camera?: CameraDeviceProxy;
     plugin?: PluginProxy;
-    private logger;
     private configService;
     router: Router;
-    reqServer: Reply;
-    pubServer: Publisher;
+    publisher: 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>;
+    publishDeviceManagerEvent<K extends keyof DeviceManagerProxyEvents>(targetId: string, type: K, data: DeviceManagerProxyEvents[K]): Promise<void>;
+    publishSystemManagerEvent<K extends keyof SystemManagerProxyEvents>(targetId: string, type: K, data: SystemManagerProxyEvents[K]): Promise<void>;
+    publishPluginsManagerEvent<K extends keyof PluginsManagerProxyEvents>(targetId: string, type: K, data: PluginsManagerProxyEvents[K]): Promise<void>;
+    publishCameraEvent<K extends keyof StateValues>(cameraId: string, stateName: K, data: {
+        newEvent: StateValues[K];
+        oldEvent: StateValues[K];
+    }): Promise<void>;
+    publishCameraEvent(cameraId: string, type: CameraDeviceListenerMessagePayload['type'], data?: any): Promise<void>;
+    private isCameraState;
 }

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

@@ -1,21 +1,24 @@
-import type { CameraInput } from '../../api/database/types';
+/// <reference types="pouchdb-core" />
+/// <reference types="node" />
 import type { OnSetEvent, StateValues } from '../../camera/types';
 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';
+import type { FfmpegOptions, PrebufferType, CameraDelegate } from '../../camera/types';
+import type { CameraDeviceProxyMethods, ProxyMessageStructure } from '../types';
+import type { MessageQueue } from '../queue';
+import type { CameraDeviceHub } from '../../camera';
+import type { Camera } from '../../api/database/types';
 export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     private api;
     private configService;
     private camerasService;
     private pluginsService;
-    private proxyServer;
-    constructor(proxyServer: ProxyServer);
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
     snapshot(data: {
-        sourceName: string;
         prebuffer?: boolean;
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
     }): Promise<ArrayBuffer>;
     setPrebufferSource(data: {
         sourceName: string;
@@ -23,46 +26,63 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
         type: PrebufferType;
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
     }): Promise<void>;
     removePrebufferSource(data: {
         sourceName: string;
         type: PrebufferType;
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
     }): Promise<void>;
     removePrebufferSources(data: {
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
     }): Promise<void>;
-    getFffmpegPath(): string;
-    getIceServers(): IceServer[];
+    getFffmpegPath(data: {
+        cameraId: string;
+        pluginId: string;
+        ws?: boolean;
+    }): string;
+    getIceServers(data: {
+        cameraId: string;
+        pluginId: string;
+        ws?: boolean;
+    }): IceServer[];
     updateState<T extends keyof StateValues>(data: {
         stateName: T;
         eventData: OnSetEvent<T>;
         cameraId: string;
-    }): void;
+        pluginId: string;
+        ws?: boolean;
+    }): Promise<void>;
     refreshStates(data: {
         cameraId: string;
-    }): {
-        sources: CameraInput[];
+        pluginId: string;
+        ws?: boolean;
+    }): Promise<{
+        camera: Camera;
         states: StateValues;
-    } | undefined;
+    }>;
     streamVideo(data: {
         sourceName: string;
         options: FfmpegOptions;
         cameraId: string;
+        pluginId: string;
+        ws?: boolean;
     }): Promise<void>;
     recordToFile(data: {
         sourceName: string;
         outputPath: string;
         duration?: number;
         cameraId: string;
+        pluginId: string;
+        ws?: boolean;
     }): Promise<void>;
-    handleMessage(msg: CameraDeviceProxyMessageStructure): Promise<void>;
-    publishCameraMessage<K extends keyof StateValues>(cameraId: CameraId, stateName: K, data: {
-        newEvent: StateValues[K];
-        oldEvent: StateValues[K];
-    }): Promise<void>;
-    publishCameraMessage(cameraId: CameraId, type: CameraDeviceListenerMessagePayload['type'], data?: any): Promise<void>;
-    private isCameraState;
+    onRequestSnapshotRequest(cameraDevice: CameraDeviceHub, ...args: Parameters<CameraDelegate['snapshotRequest']>): Promise<Buffer>;
+    onRequestPrepareStream(cameraDevice: CameraDeviceHub, ...args: Parameters<CameraDelegate['prepareStream']>): Promise<void>;
+    onRequestWebRTCOffer(cameraDevice: CameraDeviceHub, ...args: Parameters<CameraDelegate['onOffer']>): Promise<string>;
+    onRequestWebRTCIceCandidates(cameraDevice: CameraDeviceHub, ...args: Parameters<CameraDelegate['onCandidates']>): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
 }

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

@@ -1,10 +1,11 @@
 import { type CameraStorage, type BasePlugin } from '../../plugins/types';
-import type { ProxyServer } from '..';
-import type { MethodKeys } from '../types';
+import type { MethodKeys, ProxyMessageStructure } from '../types';
+import type { MessageQueue } from '../queue';
 export declare class PluginProxy {
     private pluginsService;
-    private proxyServer;
-    constructor(proxyServer: ProxyServer);
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
     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]>>;
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
 }

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

@@ -1,17 +1,12 @@
-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 {
-    listen(): any;
-    removeListener(): any;
-    removeAllListeners(): any;
-}
+import type { MessageQueue } from '../queue';
 export declare class ServerProxy implements ApiProxyMethods {
     private camerasService;
     private pluginsService;
-    private proxyServer;
-    constructor(proxyServer: ProxyServer);
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
     getCameraByName(data: {
         name: string;
     }): Promise<Camera | undefined>;
@@ -30,5 +25,5 @@ export declare class ServerProxy implements ApiProxyMethods {
         id: string;
         pluginId: string;
     }): Promise<void>;
-    handleMessage(msg: ProxyMessageStructure): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
 }

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

@@ -1,17 +1,14 @@
-import type { QueueItem } from './types';
+import type { ProxyMessageStructure } from './types';
 import type { ProxyServer } from '.';
 export declare class MessageQueue {
     private logger;
-    private queue;
-    private isProcessing;
-    private pendingResponses;
     private proxyServer;
-    private reqServer;
     private router;
+    private isProcessing;
+    private queue;
+    private pendingResponses;
     constructor(proxyServer: ProxyServer);
-    addToQueue(item: QueueItem): Promise<void>;
+    enqueue(message: ProxyMessageStructure): Promise<any>;
     private processQueue;
-    private listenToRouterMessages;
-    private listenToRequestMessages;
-    private isProxyMessage;
+    private listenToDealer;
 }