@camera.ui/browser 0.0.74 → 0.0.76

package/dist/types/server/src/camera/{controller/types.d.ts → types.d.ts}

@@ -1,12 +1,13 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { Observable } from 'rxjs';
-import type { CameraInformation, CameraInput, CameraInputSettings } from '../../api/database/types.js';
+import type { CameraInformation, CameraInput, CameraInputSettings, Point, ZoneFilter, ZoneType } from '../api/database/types.js';
 export interface BaseLogger {
     log: (...args: any[]) => void;
     error: (...args: any[]) => void;
     warn: (...args: any[]) => void;
     debug: (...args: any[]) => void;
     trace: (...args: any[]) => void;
+    attention: (...args: any[]) => void;
 }
 export type SpawnInput = string | number;
 export interface FfmpegOptions {
@@ -15,7 +16,7 @@ export interface FfmpegOptions {
     audio?: SpawnInput[];
     output: SpawnInput[];
 }
-export type PrebufferContainer = 'mp4' | 'mpegts';
+export type Container = 'mp4' | 'mpegts';
 export interface BasePrebufferState {
     maxDuration: number;
     availableDuration: number;
@@ -29,9 +30,9 @@ export interface PrebufferStateFalse extends BasePrebufferState {
 }
 export type PrebufferState = PrebufferStateTrue | PrebufferStateFalse;
 export interface CameraSource extends CameraInput {
-    updatePrebufferingState(container: PrebufferContainer, state: PrebufferState): Promise<void>;
-    getPrebufferingState(container: PrebufferContainer): PrebufferState;
-    onPrebuffering(container: PrebufferContainer): Observable<PrebufferState>;
+    updatePrebufferingState(container: Container, state: PrebufferState): Promise<void>;
+    getPrebufferingState(container: Container): PrebufferState;
+    onPrebuffering(container: Container): Observable<PrebufferState>;
     getStreamInfo(): Promise<StreamInfo | undefined>;
 }
 export interface CameraPrebufferDelegate {
@@ -98,9 +99,9 @@ export type CameraConfig = (BaseCameraConfig & {
 }) | (BaseCameraConfig & {
     delegate?: CameraDelegate;
 });
-export interface BaseDetection {
+export interface Detection {
     id?: string;
-    label: string;
+    label: ObjectClasses;
     confidence: number;
     boundingBox: [number, number, number, number];
     inputWidth: number;
@@ -108,24 +109,29 @@ export interface BaseDetection {
     origWidth: number;
     origHeight: number;
 }
-export interface MotionDetection extends BaseDetection {
-}
-export interface ObjectDetection extends BaseDetection {
+export interface DetectionZone {
+    name: string;
+    points: Point[];
+    type: ZoneType;
+    filter: ZoneFilter;
+    classes: ObjectClasses[];
+    isPrivacyMask: boolean;
 }
+export type ObjectClasses = '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 interface BaseState<T extends LightState | AudioState | MotionState | ObjectState | SirenState | BatteryState | DoorbellState> {
     timestamp: string;
     lastEvent?: Omit<T, 'lastEvent'>;
 }
 export interface MotionSetEvent {
-    state: boolean;
-    detections: MotionDetection[];
+    state?: boolean;
+    detections: Detection[];
 }
 export interface AudioSetEvent {
     state: boolean;
     db?: number;
 }
 export interface ObjectSetEvent {
-    detections: ObjectDetection[];
+    detections: Detection[];
 }
 export interface LightSetEvent {
     state: boolean;
@@ -149,6 +155,9 @@ 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 FrameState extends MotionState {
+    frame: Buffer;
+}
 export type States = LightState | MotionState | AudioState | ObjectState | DoorbellState | SirenState | BatteryState;
 export type Sets = LightSetEvent | MotionSetEvent | AudioSetEvent | ObjectSetEvent | DoorbellSetEvent | SirenSetEvent | BatterySetEvent;
 export interface StateValues {

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

@@ -0,0 +1,25 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { NatsConnection } from 'nats';
+import type { FrameBuffer, FrameImage, FrameMetadata, ImageOptions, MotionFrame as MotionFrameMethods, VideoFrame as VideoFrameMethods } from '../decoder/types.js';
+import type { MotionState } from './types.js';
+export declare class VideoFrame implements VideoFrameMethods {
+    readonly imageBuffer: Buffer;
+    private frameGeneratorSubject;
+    private publisher;
+    private _metadata;
+    get metadata(): FrameMetadata;
+    get inputWidth(): number;
+    get inputHeight(): number;
+    get inputFormat(): string;
+    constructor(cameraId: string, publisher: NatsConnection, imageBuffer: Buffer, metadata: FrameMetadata);
+    toBuffer(options?: ImageOptions): Promise<FrameBuffer>;
+    toImage(options?: ImageOptions): Promise<FrameImage>;
+    save(path: string, options?: ImageOptions | undefined): Promise<void>;
+    private send;
+    private getImageInformation;
+    private validateOptions;
+}
+export declare class MotionFrame extends VideoFrame implements MotionFrameMethods {
+    motion: MotionState;
+    constructor(cameraId: string, publisher: NatsConnection, imageBuffer: Buffer, motionState: MotionState, metadata: FrameMetadata);
+}

package/dist/types/server/src/decoder/index.d.ts

@@ -1,22 +1,11 @@
 import { FrameWorker } from './worker.js';
-import type { CameraController } from '../camera/controller/index.js';
+import type { CameraController } from '../camera/controller.js';
 export declare class FrameManager {
     frameWorkers: Map<string, FrameWorker>;
-    private initialized;
     private api;
     private proxyServer;
     private logger;
-    private publisher?;
-    private subscriber?;
-    private subject;
     constructor();
-    init(): Promise<void>;
     addCamera(camera: CameraController): Promise<FrameWorker>;
     removeCamera(camera: CameraController): Promise<void>;
-    private handleConnectMessage;
-    private handleDisconnectMessage;
-    private disconnectClient;
-    private disconnectAllClients;
-    private startPingPongForClient;
-    private listenToMessages;
 }

package/dist/types/server/src/decoder/types.d.ts

@@ -2,6 +2,7 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { ChildProcess } from 'node:child_process';
 import type { Sharp } from 'sharp';
+import type { MotionState } from '../camera/types.js';
 export interface FrameMetadata {
     format: string;
     frameSize: number;
@@ -20,9 +21,6 @@ export interface ImageResize {
     width?: number;
     height?: number;
 }
-export interface ImageRotate {
-    angle: number;
-}
 export interface ImageFormat {
     to: 'rgba' | 'gray';
 }
@@ -30,19 +28,36 @@ export interface ImageOptions {
     format?: ImageFormat;
     crop?: ImageCrop;
     resize?: ImageResize;
-    rotate?: ImageRotate;
 }
 export interface ProcessImageRequest {
     options: ImageOptions;
     data: Buffer;
 }
+export interface ImageInformation {
+    width: number;
+    height: number;
+    channels: number;
+}
+export interface FrameBuffer {
+    image: Buffer;
+    info: ImageInformation;
+}
+export interface FrameImage {
+    image: Sharp;
+    info: ImageInformation;
+}
 export interface VideoFrame {
+    readonly imageBuffer: Buffer;
     metadata: FrameMetadata;
     inputWidth: number;
     inputHeight: number;
     inputFormat: string;
-    toBuffer: (options?: ImageOptions) => Promise<Buffer>;
-    toImage: (options?: ImageOptions) => Promise<Sharp>;
+    toBuffer: (options?: ImageOptions) => Promise<FrameBuffer>;
+    toImage: (options?: ImageOptions) => Promise<FrameImage>;
+    save: (path: string, options?: ImageOptions) => Promise<void>;
+}
+export interface MotionFrame extends VideoFrame {
+    motion: MotionState;
 }
 export interface VideoSession {
     isActive(): boolean;
@@ -60,9 +75,11 @@ export interface BaseFrameWorkerConfig {
         user: string;
         pass: string;
     };
+    proxyPort: number;
+    useWasm: boolean;
 }
-export type WorkerMessage = 'started' | 'getFFmpegArgs';
-export type MainMessage = 'getMetadata' | 'startVideoSession' | 'stopVideoSession' | 'setCameraName';
+export type WorkerMessage = 'started' | 'getFFmpegArgs' | 'updateClient' | 'removeClient' | 'clearClients';
+export type MainMessage = 'setCameraName' | 'recoverClients';
 export interface MainToWorkerMessage {
     message: MainMessage;
     data: Record<string, any>;
@@ -78,15 +95,15 @@ export interface MainToWorkerResponse {
     response?: Record<string, any>;
 }
 export interface SignalingRequest {
-    type: 'connect' | 'disconnect';
+    type: 'connect' | 'disconnect' | 'metadata';
     requestId: string;
     cameraId: string;
     pluginId: string;
 }
 export interface SignalingResponse {
-    type: 'connected' | 'disconnected' | 'error';
+    type: 'connected' | 'disconnected' | 'metadata';
     requestId: string;
-    message?: string;
+    metadata?: FrameMetadata;
 }
 export interface PingMessage {
     type: 'ping';
@@ -109,3 +126,15 @@ export interface FfmpegArgs {
     hwaccelFilter: string;
     threads: string;
 }
+export interface FrameWorkerClient {
+    pluginId: string;
+    requestIds: string[];
+}
+export interface RecoveredClient {
+    pluginId: string;
+    requestIds: string[];
+}
+export interface PrebufferContainer {
+    time: number;
+    frame: Buffer;
+}

package/dist/types/server/src/decoder/worker.d.ts

@@ -1,13 +1,10 @@
 import { Subscribed } from '../utils/subscribed.js';
-import type { CameraController } from '../camera/controller/index.js';
-import type { FrameMetadata } from './types.js';
-interface FrameWorkerClient {
-    pluginId: string;
-    requestIds: string[];
-}
+import type { CameraController } from '../camera/controller.js';
+import { PLUGIN_STATUS } from '../plugins/types.js';
 export declare class FrameWorker extends Subscribed {
     token: string;
-    readonly clients: Map<string, FrameWorkerClient>;
+    name: string;
+    private readonly clients;
     private subject;
     private ipcSubject;
     private frameWorkerId;
@@ -15,28 +12,31 @@ export declare class FrameWorker extends Subscribed {
     private subscriber?;
     private logger;
     private configService;
+    private socketService;
     private camera;
     private frameWorker?;
     private initialized;
     private stopped;
+    private restarting;
     private auth;
+    private proxyPort;
     private ffmpegArgs;
     private py;
-    constructor(camera: CameraController, auth: {
+    private _status;
+    get status(): PLUGIN_STATUS;
+    constructor(camera: CameraController, proxyPort: number, auth: {
         user: string;
         pass: string;
     });
-    init(): Promise<void>;
+    start(): Promise<void>;
     close(): Promise<void>;
-    workerPID(): number;
-    getMetadata(): Promise<FrameMetadata>;
-    addClient(pluginId: string, requestId: string): Promise<void>;
-    removeClient(pluginId: string, requestId: string): Promise<void>;
-    private startVideoSession;
-    private stopVideoSession;
+    restart(): Promise<void>;
+    getPID(): number;
     private startWorker;
+    private restartWorker;
+    private killWorker;
     private sendMessage;
     private listenToMessages;
+    private setStatus;
     private getLogPrefix;
 }
-export {};

package/dist/types/server/src/nats/constants.d.ts

@@ -1,2 +1 @@
 export declare const NATS_SERVER_SUBJECT = "camera.ui-server";
-export declare const NATS_SIGNALING_SUBJECT = "camera.ui-signaling";

package/dist/types/server/src/nats/index.d.ts

@@ -2,7 +2,7 @@ import { type NatsConnection, type Subscription } from 'nats';
 import { CameraDeviceProxy } from './proxy/cameraDevice.js';
 import { DeviceManagerProxy, PluginsManagerProxy, SystemManagerProxy } from './proxy/index.js';
 import { NatsServer } from './server.js';
-import type { StateValues } from '../camera/controller/types.js';
+import type { StateValues } from '../camera/types.js';
 import type { CameraDeviceListenerMessagePayload, DeviceManagerProxyEvents, PluginsManagerProxyEvents, ProxyAuth, SystemManagerProxyEvents } from './types.js';
 import type { WebsocketProxy } from './websocket.js';
 export declare class ProxyServer {
@@ -16,7 +16,7 @@ export declare class ProxyServer {
     server: NatsServer;
     publisher?: NatsConnection;
     subscriber?: Subscription;
-    private messageQueue;
+    private messageQueue?;
     private initialized;
     auth: ProxyAuth;
     constructor();

package/dist/types/server/src/nats/proxy/cameraDevice.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { Camera } from '../../api/database/types.js';
-import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions, PrebufferContainer, PrebufferState, SetValues, StateValues, StreamInfo } from '../../camera/controller/types.js';
-import type { FrameMetadata } from '../../decoder/types.js';
+import type { CameraDelegate, CameraPrebufferDelegate, Container, FfmpegOptions, PrebufferState, SetValues, StateValues, StreamInfo } from '../../camera/types.js';
 import type { IceServer } from '../../services/config/types.js';
 import type { MessageQueue } from '../queue.js';
 import type { CameraDeviceProxyMethods, ProxyMessageStructure } from '../types.js';
@@ -30,10 +29,6 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): Promise<StreamInfo | undefined>;
-    getFrameMetadata(data: {
-        cameraId: string;
-        pluginId: string;
-    }): Promise<FrameMetadata>;
     getFfmpegPath(): string;
     getIceServers(): IceServer[];
     snapshot(data: {
@@ -62,7 +57,7 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     }): Promise<void>;
     updatePrebufferState(data: {
         sourceId: string;
-        container: PrebufferContainer;
+        container: Container;
         state: PrebufferState;
         cameraId: string;
         pluginId: string;

package/dist/types/server/src/nats/proxy/deviceManager.d.ts

@@ -1,5 +1,5 @@
 import type { Camera } from '../../api/database/types.js';
-import type { CameraConfig } from '../../camera/controller/types.js';
+import type { CameraConfig } from '../../camera/types.js';
 import type { MessageQueue } from '../queue.js';
 import type { DeviceManagerServerProxyMethods, ProxyMessageStructure } from '../types.js';
 export declare class DeviceManagerProxy implements DeviceManagerServerProxyMethods {

package/dist/types/server/src/nats/server.d.ts

@@ -1,10 +1,10 @@
 import { RUNTIME_STATUS } from '../services/config/types.js';
 import type { ProxyAuth } from './types.js';
 export declare class NatsServer {
-    readonly serverPort = 4222;
     private readonly clusterAmount;
     private readonly auth;
-    private clusterPort?;
+    private _serverPort;
+    private _clusterPort;
     private serverProcess?;
     private clusterProcesses;
     private logger;
@@ -15,6 +15,8 @@ export declare class NatsServer {
     private shuttingDown;
     private _status;
     get status(): RUNTIME_STATUS;
+    get serverPort(): number;
+    get clusterPort(): number;
     constructor(auth: ProxyAuth);
     start(): Promise<void>;
     private startServer;

package/dist/types/server/src/nats/types.d.ts

@@ -1,7 +1,6 @@
 import type { Camera } from '../api/database/types.js';
-import type { CameraDevice } from '../camera/cameraDevice.js';
-import type { CameraConfig, FfmpegOptions, PrebufferContainer, PrebufferState, SetValues, StateValues, StreamInfo } from '../camera/controller/types.js';
-import type { FrameMetadata } from '../decoder/types.js';
+import type { CameraDevice } from '../camera/device.js';
+import type { CameraConfig, Container, FfmpegOptions, PrebufferState, SetValues, StateValues, StreamInfo } from '../camera/types.js';
 import type { BasePlugin } from '../plugins/base.js';
 import type { CameraExtension } from '../plugins/types.js';
 import type { CameraStorage } from '../polyglot/node/plugins/cameraStorage.js';
@@ -97,10 +96,6 @@ export interface CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): Promise<StreamInfo | undefined>;
-    getFrameMetadata(data: {
-        cameraId: string;
-        pluginId: string;
-    }): Promise<FrameMetadata>;
     getFfmpegPath(data: {
         cameraId: string;
         pluginId: string;
@@ -135,7 +130,7 @@ export interface CameraDeviceProxyMethods {
     }): void;
     updatePrebufferState(data: {
         sourceId: string;
-        container: PrebufferContainer;
+        container: Container;
         state: PrebufferState;
         cameraId: string;
         pluginId: string;
@@ -152,7 +147,7 @@ export interface CameraDeviceProxyMethods {
 export type CameraDeviceProxyMethodNames = MethodKeys<CameraDeviceProxyMethods>;
 export interface DeviceManagerListenerMessagePayload {
     type: keyof DeviceManagerProxyEventCallbacks;
-    data: any;
+    data: DeviceManagerProxyEvents['cameraSelected'] | DeviceManagerProxyEvents['cameraDeselected'] | DeviceManagerProxyEvents['cameraUpdated'];
 }
 export interface DeviceManagerProxyMethods {
     getCameraByName(name: string): Promise<CameraDevice | undefined>;
@@ -173,12 +168,13 @@ export interface DeviceManagerProxyEvents {
     };
     cameraUpdated: {
         camera: Camera;
+        extension: CameraExtension;
     };
 }
 export interface DeviceManagerProxyEventCallbacks {
     cameraSelected: (camera: CameraDevice, extension: CameraExtension) => void;
     cameraDeselected: (cameraId: string, extension: CameraExtension) => void;
-    cameraUpdated: (cameraId: string, camera: CameraDevice) => void;
+    cameraUpdated: (cameraId: string, extension: CameraExtension) => void;
 }
 export interface DeviceManagerProxyGenericEvent<K extends keyof DeviceManagerProxyEvents> {
     type: K;

package/dist/types/server/src/nats/websocket.d.ts

@@ -1,6 +1,6 @@
 import type { Namespace, Server } from 'socket.io';
 import type { SocketNsp } from '../api/websocket/types.js';
-import type { StateValues } from '../camera/controller/types.js';
+import type { StateValues } from '../camera/types.js';
 import type { CameraDeviceListenerMessagePayload } from './types.js';
 export declare class WebsocketProxy {
     nsp: Namespace;

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

@@ -1,4 +1,4 @@
-import type { CameraDevice } from '../camera/cameraDevice.js';
+import type { CameraDevice } from '../camera/device.js';
 export declare abstract class BasePlugin {
     abstract onFormSubmit(actionId: string, payload: any): Promise<{
         toast?: string;

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

@@ -91,11 +91,13 @@ export interface JsonSchemaNumber extends JsonBaseSchema<number> {
     type: 'number';
     minimum?: number;
     maximum?: number;
+    step?: number;
 }
 export interface PluginJsonSchemaNumber extends PluginJsonBaseSchema<number> {
     type: 'number';
     minimum?: number;
     maximum?: number;
+    step?: number;
 }
 export interface JsonSchemaBoolean extends JsonBaseSchema<boolean> {
     type: 'boolean';

package/dist/types/server/src/polyglot/node/plugins/api.d.ts

@@ -34,7 +34,7 @@ export declare class PluginAPI extends EventEmitter implements API {
     readonly storagePath: string;
     readonly configFile: string;
     readonly plugin: BasePlugin;
-    constructor(plugin: Plugin, logger: PluginLogger, auth: {
+    constructor(plugin: Plugin, logger: PluginLogger, proxyPort: number, auth: {
         user: string;
         pass: string;
     });

package/dist/types/server/src/polyglot/node/plugins/proxy/cameraDevice.d.ts

@@ -1,32 +1,41 @@
-import { CameraDevice } from '../../../../camera/cameraDevice.js';
+/// <reference types="node" resolution-mode="require"/>
+import { CameraDevice } from '../../../../camera/device.js';
+import { MotionFrame, VideoFrame } from '../../../../camera/videoFrame.js';
 import type { Camera } from '../../../../api/database/types.js';
-import type { CameraSource, SetValues } from '../../../../camera/controller/types.js';
-import type { VideoFrame } from '../../../../decoder/types.js';
+import type { CameraSource, SetValues } from '../../../../camera/types.js';
 import type { IceServer } from '../../../../services/config/types.js';
 import type { PluginAPI } from '../api.js';
 import type { PluginLogger } from '../logger.js';
 export declare class CameraDeviceProxy extends CameraDevice {
     private api;
     private initialized;
-    private publisher;
-    private client;
-    private cameraSubscriber;
-    private cameraPluginSubscriber;
-    private signalingSubscriber;
-    private frameSubscriber?;
-    private activeRequests;
-    private messageQueue;
-    private auth;
-    private pluginID;
-    private pluginName;
-    private clientSubject;
+    private subject;
+    private subjectMotionFrame;
     private cameraSubscriberSubject;
     private cameraPluginSubscriberSubject;
     private frameSubject;
+    private framePrebufferSubject;
+    private motionFrameSubject;
     private signalingSubject;
     private signalingTargetSubject;
+    private publisher?;
+    private framePublisher?;
+    private subscriber?;
+    private cameraSubscriber?;
+    private cameraPluginSubscriber?;
+    private signalingSubscriber?;
+    private frameSubscriber?;
+    private prebufferFrameSubsciber?;
+    private motionFrameSubscriber?;
+    private messageQueue?;
+    private activeRequests;
+    private activeMotionRequests;
+    private auth;
+    private proxyPort;
+    private pluginID;
+    private pluginName;
     get sources(): CameraSource[];
-    constructor(api: PluginAPI, logger: PluginLogger, camera: Camera, pluginId: string, pluginName: string, auth: {
+    constructor(api: PluginAPI, logger: PluginLogger, camera: Camera, pluginId: string, pluginName: string, proxyPort: number, auth: {
         user: string;
         pass: string;
     });
@@ -34,14 +43,20 @@ export declare class CameraDeviceProxy extends CameraDevice {
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     reboot(): Promise<void>;
-    generateFrames(): AsyncIterableIterator<VideoFrame>;
+    getFrames(): AsyncIterableIterator<VideoFrame>;
+    getMotionFrames(): AsyncIterableIterator<MotionFrame>;
+    getPrebufferedFrames(): AsyncIterableIterator<VideoFrame>;
     getFfmpegPath(): Promise<string>;
     getIceServers(): Promise<IceServer[]>;
-    updateState<T extends keyof SetValues>(stateName: T, eventData: SetValues[T]): Promise<void>;
+    updateState<T extends keyof SetValues>(stateName: T, eventData: SetValues[T], frame?: Buffer): Promise<void>;
     refreshStates(): Promise<void>;
     cleanup(): Promise<void>;
-    private signalDecoder;
+    private onMotionFrame;
+    private connectToDecoder;
+    private getMetadata;
+    private disconnectFromDecoder;
     private closeFrameSubscriber;
+    private closeMotionFrameSubsciber;
     private requestHandler;
     private listenToMessages;
     private listenToSignalingMessages;

package/dist/types/server/src/polyglot/node/plugins/proxy/deviceManager.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 import { EventEmitter } from 'node:events';
 import { CameraDeviceProxy } from './cameraDevice.js';
-import type { CameraDevice } from '../../../../camera/cameraDevice.js';
-import type { CameraConfig } from '../../../../camera/controller/types.js';
+import type { CameraDevice } from '../../../../camera/device.js';
+import type { CameraConfig } from '../../../../camera/types.js';
 import type { DeviceManagerProxyEventCallbacks, DeviceManagerProxyMethods } from '../../../../nats/types.js';
 import type { PluginAPI } from '../api.js';
 import type { PluginLogger } from '../logger.js';
@@ -17,17 +17,18 @@ export declare class DeviceManager extends EventEmitter implements DeviceManager
     private api;
     private logger;
     private initialized;
-    private publisher;
-    private client;
-    private subscriber;
-    private messageQueue;
+    private subject;
+    private dmSubject;
+    private publisher?;
+    private subscriber?;
+    private dmSubscriber?;
+    private messageQueue?;
     private auth;
+    private proxyPort;
     private pluginId;
     private pluginName;
-    private clientSubject;
-    private subscriberSubject;
     private devices;
-    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, auth: {
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, proxyPort: number, auth: {
         user: string;
         pass: string;
     });
@@ -40,6 +41,7 @@ export declare class DeviceManager extends EventEmitter implements DeviceManager
     emit(): boolean;
     configureCameras(cameraDevices: CameraDeviceProxy[]): void;
     private requestHandler;
+    private emitEvent;
     private listenToMessages;
     private onRequest;
     private addOrGetCamera;

package/dist/types/server/src/polyglot/node/plugins/proxy/pluginsManager.d.ts

@@ -14,16 +14,17 @@ export declare class PluginsManager extends EventEmitter implements PluginsManag
     private api;
     private logger;
     private initialized;
-    private publisher;
-    private client;
-    private subscriber;
-    private messageQueue;
+    private subject;
+    private pmSubject;
+    private publisher?;
+    private subscriber?;
+    private pmSubscriber?;
+    private messageQueue?;
     private auth;
+    private proxyPort;
     private pluginId;
     private pluginName;
-    private clientSubject;
-    private subscriberSubject;
-    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, auth: {
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, proxyPort: number, auth: {
         user: string;
         pass: string;
     });

package/dist/types/server/src/polyglot/node/plugins/proxy/queue.d.ts

@@ -1,16 +1,18 @@
 import type { NatsConnection, Subscription } from 'nats';
-import type { BaseLogger } from '../../../../camera/controller/types.js';
+import type { BaseLogger } from '../../../../camera/types.js';
 import type { ProxyMessageStructure } from '../../../../nats/types.js';
 export declare class ClientMessageQueue {
     private logger;
     private publisher;
     private subscriber;
     private requestHandler;
+    private started;
     private aborted;
     private isProcessing;
     private queue;
     private pendingResponses;
     constructor(logger: BaseLogger, publisher: NatsConnection, subscriber: Subscription, requestHandler: (message: ProxyMessageStructure) => void);
+    start(): Promise<void>;
     abortQueue(): void;
     enqueue(message: ProxyMessageStructure): Promise<any>;
     private processQueue;