@camera.ui/browser 0.0.77 → 0.0.80

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

@@ -1,6 +1,12 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { Observable } from 'rxjs';
 import type { CameraInformation, CameraInput, CameraInputSettings, Point, ZoneFilter, ZoneType } from '../api/database/types.js';
+import type { FrameData, FrameMetadata } from '../decoder/types.js';
+import type { CameraAudioDetectionInterface } from './interfaces/audioDetection.js';
+import type { CameraInterface } from './interfaces/camera.js';
+import type { CameraMotionDetectionInterface } from './interfaces/motionDetection.js';
+import type { CameraObjectDetectionInterface } from './interfaces/objectDetection.js';
+import type { CameraPrebufferInterface } from './interfaces/prebuffer.js';
+import type { CameraPTZInterface } from './interfaces/ptz.js';
 export interface BaseLogger {
     log: (...args: any[]) => void;
     error: (...args: any[]) => void;
@@ -35,16 +41,6 @@ export interface CameraSource extends CameraInput {
     onPrebuffering(container: Container): Observable<PrebufferState>;
     getStreamInfo(): Promise<StreamInfo | undefined>;
 }
-export interface CameraPrebufferDelegate {
-    getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;
-}
-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>;
-    reboot(): Promise<void>;
-}
 export interface StreamInfo {
     audio: AudioStreamOptions;
     video: VideoStreamOptions;
@@ -94,14 +90,15 @@ export interface BaseCameraConfig {
     disabled?: boolean;
     info?: Partial<CameraInformation>;
 }
-export type CameraConfig = (BaseCameraConfig & {
-    sources?: Omit<CameraInputSettings, '_id'>[];
-}) | (BaseCameraConfig & {
-    delegate?: CameraDelegate;
-});
+export interface CameraConfigInputSettings extends Omit<CameraInputSettings, '_id' | 'urls'> {
+    urls?: string[];
+}
+export type CameraConfig = BaseCameraConfig & {
+    sources: CameraConfigInputSettings[];
+};
 export interface Detection {
     id?: string;
-    label: ObjectClasses;
+    label: ObjectClass;
     confidence: number;
     boundingBox: [number, number, number, number];
     inputWidth: number;
@@ -114,12 +111,12 @@ export interface DetectionZone {
     points: Point[];
     type: ZoneType;
     filter: ZoneFilter;
-    classes: ObjectClasses[];
+    classes: ObjectClass[];
     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 type ObjectClass = 'person' | 'bicycle' | 'car' | 'motorcycle' | 'airplane' | 'bus' | 'train' | 'truck' | 'boat' | 'traffic light' | 'fire hydrant' | 'stop sign' | 'parking meter' | 'bench' | 'bird' | 'cat' | 'dog' | 'horse' | 'sheep' | 'cow' | 'elephant' | 'bear' | 'zebra' | 'giraffe' | 'backpack' | 'umbrella' | 'handbag' | 'tie' | 'suitcase' | 'frisbee' | 'skis' | 'snowboard' | 'sports ball' | 'kite' | 'baseball bat' | 'baseball glove' | 'skateboard' | 'surfboard' | 'tennis racket' | 'bottle' | 'wine glass' | 'cup' | 'fork' | 'knife' | 'spoon' | 'bowl' | 'banana' | 'apple' | 'sandwich' | 'orange' | 'broccoli' | 'carrot' | 'hot dog' | 'pizza' | 'donut' | 'cake' | 'chair' | 'couch' | 'potted plant' | 'bed' | 'dining table' | 'toilet' | 'tv' | 'laptop' | 'mouse' | 'remote' | 'keyboard' | 'cell phone' | 'microwave' | 'oven' | 'toaster' | 'sink' | 'refrigerator' | 'book' | 'clock' | 'vase' | 'scissors' | 'teddy bear' | 'hair drier' | 'toothbrush' | 'motion';
 export interface BaseState<T extends LightState | AudioState | MotionState | ObjectState | SirenState | BatteryState | DoorbellState> {
-    timestamp: string;
+    timestamp: number;
     lastEvent?: Omit<T, 'lastEvent'>;
 }
 export interface MotionSetEvent {
@@ -156,7 +153,8 @@ 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;
+    frameData: FrameData;
+    metadata: FrameMetadata;
 }
 export type States = LightState | MotionState | AudioState | ObjectState | DoorbellState | SirenState | BatteryState;
 export type Sets = LightSetEvent | MotionSetEvent | AudioSetEvent | ObjectSetEvent | DoorbellSetEvent | SirenSetEvent | BatterySetEvent;
@@ -184,3 +182,44 @@ export type CameraStateCallbacks = {
 export type StateValue<T extends keyof StateValues> = StateValues[T];
 export type SetValue<T extends keyof SetValues> = SetValues[T];
 export type OnChangeCallback<T extends keyof StateValues> = (newEvent: StateValues[T], oldEvent: StateValues[T]) => void;
+export declare abstract class CameraDelegate {
+    abstract snapshotRequest(requestId: string, sourceName: string): Promise<Buffer | undefined>;
+    abstract startStream(requestId: string, sourceName: string, videoPort: number, audioPort: number): Promise<void>;
+    abstract stopStream(requestId: string, sourceName: string): Promise<void>;
+    abstract onTalkbackSdp(requestId: string, sourceName: string, sdp: string, codec: 'PCMU' | 'PCMA' | 'opus'): void;
+    abstract onTalkbackRtp(requestId: string, sourceName: string, rtp: Buffer): void;
+}
+export declare abstract class CameraPrebufferDelegate {
+    abstract getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;
+}
+export declare abstract class CameraPTZDelegate {
+    abstract moveAbsolute(pan: number, tilt: number, zoom: number): Promise<void>;
+    abstract moveRelative(pan: number, tilt: number, zoom: number): Promise<void>;
+    abstract moveContinuous(pan: number, tilt: number, zoom: number): Promise<void>;
+    abstract stop(): Promise<void>;
+}
+export declare abstract class CameraMotionDetectionDelegate {
+    abstract detectImage(image: Buffer): Promise<Detection[]>;
+}
+export declare abstract class CameraObjectDetectionDelegate {
+    abstract detectImage(image: Buffer): Promise<Detection[]>;
+}
+export declare abstract class CameraAudioDetectionDelegate {
+    abstract detectAudio(audio: Buffer): Promise<boolean>;
+}
+export interface CameraInterfaces {
+    readonly cameraDelegate: CameraInterface;
+    readonly prebufferDelegate: CameraPrebufferInterface;
+    readonly ptzDelegate: CameraPTZInterface;
+    readonly motionDetectorDelegate: CameraMotionDetectionInterface;
+    readonly objectDetectorDelegate: CameraObjectDetectionInterface;
+    readonly audioDetectorDelegate: CameraAudioDetectionInterface;
+}
+export interface CameraDelegates {
+    readonly cameraDelegate: CameraDelegate;
+    readonly prebufferDelegate: CameraPrebufferDelegate;
+    readonly ptzDelegate: CameraPTZDelegate;
+    readonly motionDetectorDelegate: CameraMotionDetectionDelegate;
+    readonly objectDetectorDelegate: CameraObjectDetectionDelegate;
+    readonly audioDetectorDelegate: CameraAudioDetectionDelegate;
+}

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

@@ -1,25 +1,24 @@
-/// <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 { DecoderFormat, FrameBuffer, FrameData, 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;
+    readonly frameData: FrameData;
+    readonly metadata: FrameMetadata;
     private frameGeneratorSubject;
     private publisher;
-    private _metadata;
-    get metadata(): FrameMetadata;
+    private prebufferDuration;
     get inputWidth(): number;
     get inputHeight(): number;
-    get inputFormat(): string;
-    constructor(cameraId: string, publisher: NatsConnection, imageBuffer: Buffer, metadata: FrameMetadata);
+    get inputFormat(): DecoderFormat;
+    constructor(cameraId: string, publisher: NatsConnection, frameData: FrameData, metadata: FrameMetadata, prebufferDuration: number);
     toBuffer(options?: ImageOptions): Promise<FrameBuffer>;
     toImage(options?: ImageOptions): Promise<FrameImage>;
-    save(path: string, options?: ImageOptions | undefined): Promise<void>;
+    save(path: string, options?: ImageOptions): Promise<void>;
     private send;
-    private getImageInformation;
     private validateOptions;
+    private getImageInformation;
 }
 export declare class MotionFrame extends VideoFrame implements MotionFrameMethods {
-    motion: MotionState;
-    constructor(cameraId: string, publisher: NatsConnection, imageBuffer: Buffer, motionState: MotionState, metadata: FrameMetadata);
+    readonly motion: MotionState;
+    constructor(cameraId: string, publisher: NatsConnection, frameData: FrameData, motionState: MotionState, metadata: FrameMetadata);
 }

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

@@ -1,10 +1,9 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <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 type DecoderFormat = 'yuv' | 'rgb';
 export interface FrameMetadata {
-    format: string;
+    format: DecoderFormat;
     frameSize: number;
     width: number;
     origWidth: number;
@@ -22,24 +21,29 @@ export interface ImageResize {
     height?: number;
 }
 export interface ImageFormat {
-    to: 'rgba' | 'gray';
+    to: ImageOutputFormat;
 }
+export type ImageInputFormat = 'yuv' | 'rgb' | 'rgba' | 'gray';
+export type ImageOutputFormat = 'rgb' | 'rgba' | 'gray';
 export interface ImageOptions {
     format?: ImageFormat;
     crop?: ImageCrop;
     resize?: ImageResize;
 }
 export interface ProcessImageRequest {
+    frameData: FrameData;
+    metadata: FrameMetadata;
     options: ImageOptions;
-    data: Buffer;
+    prebufferDuration: number;
 }
 export interface ImageInformation {
     width: number;
     height: number;
-    channels: number;
+    channels: 1 | 3 | 4;
+    format: ImageInputFormat;
 }
 export interface FrameBuffer {
-    image: Buffer;
+    image: Uint8Array;
     info: ImageInformation;
 }
 export interface FrameImage {
@@ -47,11 +51,11 @@ export interface FrameImage {
     info: ImageInformation;
 }
 export interface VideoFrame {
-    readonly imageBuffer: Buffer;
-    metadata: FrameMetadata;
-    inputWidth: number;
-    inputHeight: number;
-    inputFormat: string;
+    readonly frameData: FrameData;
+    readonly metadata: FrameMetadata;
+    readonly inputWidth: number;
+    readonly inputHeight: number;
+    readonly inputFormat: DecoderFormat;
     toBuffer: (options?: ImageOptions) => Promise<FrameBuffer>;
     toImage: (options?: ImageOptions) => Promise<FrameImage>;
     save: (path: string, options?: ImageOptions) => Promise<void>;
@@ -75,10 +79,11 @@ export interface BaseFrameWorkerConfig {
         user: string;
         pass: string;
     };
-    proxyPort: number;
-    useWasm: boolean;
+    proxyEndpoints: string[];
+    fps: number;
+    resolution: number;
 }
-export type WorkerMessage = 'started' | 'getFFmpegArgs' | 'updateClient' | 'removeClient' | 'clearClients';
+export type WorkerMessage = 'started' | 'getFFmpegArgs' | 'updateClient' | 'removeClient';
 export type MainMessage = 'setCameraName' | 'recoverClients';
 export interface MainToWorkerMessage {
     message: MainMessage;
@@ -94,14 +99,15 @@ export interface WorkerToMainMessage {
 export interface MainToWorkerResponse {
     response?: Record<string, any>;
 }
+export type SignalingMessageType = 'connect' | 'disconnect' | 'metadata';
 export interface SignalingRequest {
-    type: 'connect' | 'disconnect' | 'metadata';
-    requestId: string;
-    cameraId: string;
+    type: SignalingMessageType;
     pluginId: string;
+    cameraId: string;
+    requestId: string;
 }
 export interface SignalingResponse {
-    type: 'connected' | 'disconnected' | 'metadata';
+    type: SignalingMessageType;
     requestId: string;
     metadata?: FrameMetadata;
 }
@@ -130,11 +136,14 @@ export interface FrameWorkerClient {
     pluginId: string;
     requestIds: string[];
 }
-export interface RecoveredClient {
-    pluginId: string;
-    requestIds: string[];
+export interface RecoveredClient extends FrameWorkerClient {
 }
 export interface PrebufferContainer {
+    frameId: string;
     time: number;
     frame: Buffer;
 }
+export interface FrameData {
+    frameId: string;
+    timestamp: number;
+}

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

@@ -1,6 +1,6 @@
+import { PLUGIN_STATUS } from '../plugins/types.js';
 import { Subscribed } from '../utils/subscribed.js';
 import type { CameraController } from '../camera/controller.js';
-import { PLUGIN_STATUS } from '../plugins/types.js';
 export declare class FrameWorker extends Subscribed {
     token: string;
     name: string;
@@ -13,18 +13,18 @@ export declare class FrameWorker extends Subscribed {
     private logger;
     private configService;
     private socketService;
-    private camera;
+    private cameraDevice;
     private frameWorker?;
     private initialized;
     private stopped;
     private restarting;
     private auth;
-    private proxyPort;
+    private proxyEndpoints;
     private ffmpegArgs;
     private py;
     private _status;
     get status(): PLUGIN_STATUS;
-    constructor(camera: CameraController, proxyPort: number, auth: {
+    constructor(cameraDevice: CameraController, proxyEndpoints: string[], auth: {
         user: string;
         pass: string;
     });

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

@@ -1,7 +1,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 { NatsConnection, Subscription } from 'nats';
 import type { StateValues } from '../camera/types.js';
 import type { CameraDeviceListenerMessagePayload, DeviceManagerProxyEvents, PluginsManagerProxyEvents, ProxyAuth, SystemManagerProxyEvents } from './types.js';
 import type { WebsocketProxy } from './websocket.js';

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

@@ -1,7 +1,13 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { Camera } from '../../api/database/types.js';
-import type { CameraDelegate, CameraPrebufferDelegate, Container, FfmpegOptions, PrebufferState, SetValues, StateValues, StreamInfo } from '../../camera/types.js';
+import type { CameraAudioDetectionInterface } from '../../camera/interfaces/audioDetection.js';
+import type { CameraInterface } from '../../camera/interfaces/camera.js';
+import type { CameraMotionDetectionInterface } from '../../camera/interfaces/motionDetection.js';
+import type { CameraObjectDetectionInterface } from '../../camera/interfaces/objectDetection.js';
+import type { CameraPrebufferInterface } from '../../camera/interfaces/prebuffer.js';
+import type { CameraPTZInterface } from '../../camera/interfaces/ptz.js';
+import type { CameraConfigInputSettings, Container, PrebufferState, SetValues, StateValues } from '../../camera/types.js';
 import type { IceServer } from '../../services/config/types.js';
+import type { MethodKeys, MethodType } from '../../types.js';
 import type { MessageQueue } from '../queue.js';
 import type { CameraDeviceProxyMethods, ProxyMessageStructure } from '../types.js';
 export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
@@ -9,7 +15,6 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     private configService;
     private camerasService;
     private pluginsService;
-    private socketService;
     private messageQueue;
     constructor(messageQueue: MessageQueue);
     connect(data: {
@@ -20,45 +25,34 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): void;
-    reboot(data: {
-        cameraId: string;
-        pluginId: string;
-    }): Promise<void>;
-    getStreamInfo(data: {
-        sourceName: string;
-        cameraId: string;
-        pluginId: string;
-    }): Promise<StreamInfo | undefined>;
     getFfmpegPath(): string;
     getIceServers(): IceServer[];
-    snapshot(data: {
-        forceNew?: boolean;
+    updateState<T extends keyof SetValues>(data: {
+        stateName: T;
+        eventData: SetValues[T];
         cameraId: string;
         pluginId: string;
-    }): Promise<ArrayBuffer>;
-    streamVideo(data: {
-        sourceName: string;
-        options: FfmpegOptions;
+    }): Promise<void>;
+    updatePrebufferState(data: {
+        sourceId: string;
+        container: Container;
+        state: PrebufferState;
         cameraId: string;
         pluginId: string;
     }): Promise<void>;
-    recordToFile(data: {
-        sourceName: string;
-        outputPath: string;
-        duration?: number;
+    addCameraSource(data: {
+        source: CameraConfigInputSettings;
         cameraId: string;
         pluginId: string;
     }): Promise<void>;
-    updateState<T extends keyof SetValues>(data: {
-        stateName: T;
-        eventData: SetValues[T];
+    updateCameraSource(data: {
+        id: string;
+        source: Partial<CameraConfigInputSettings>;
         cameraId: string;
         pluginId: string;
     }): Promise<void>;
-    updatePrebufferState(data: {
-        sourceId: string;
-        container: Container;
-        state: PrebufferState;
+    removeCameraSource(data: {
+        id: string;
         cameraId: string;
         pluginId: string;
     }): Promise<void>;
@@ -70,11 +64,11 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
         states: StateValues;
         cameraState: boolean;
     };
-    onRequestReboot(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['reboot']>): Promise<Buffer>;
-    onRequestGetStreamInfo(pluginId: string, cameraId: string, ...args: Parameters<CameraPrebufferDelegate['getStreamInfo']>): Promise<StreamInfo | undefined>;
-    onRequestSnapshotRequest(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['snapshotRequest']>): Promise<Buffer>;
-    onRequestPrepareStream(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['prepareStream']>): Promise<void>;
-    onRequestWebRTCOffer(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['onOffer']>): Promise<string>;
-    onRequestWebRTCIceCandidates(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['onCandidates']>): Promise<void>;
-    handleMessage(message: ProxyMessageStructure): Promise<void>;
+    onRequest<T extends MethodKeys<CameraInterface>>(delegateType: 'cameraDelegate', cameraId: string, fn: T, ...args: Parameters<MethodType<CameraInterface, T>>): Promise<ReturnType<MethodType<CameraInterface, T>>>;
+    onRequest<T extends MethodKeys<CameraPrebufferInterface>>(delegateType: 'prebufferDelegate', cameraId: string, fn: T, ...args: Parameters<MethodType<CameraPrebufferInterface, T>>): Promise<ReturnType<MethodType<CameraPrebufferInterface, T>>>;
+    onRequest<T extends MethodKeys<CameraPTZInterface>>(delegateType: 'ptzDelegate', cameraId: string, fn: T, ...args: Parameters<MethodType<CameraPTZInterface, T>>): Promise<ReturnType<MethodType<CameraPTZInterface, T>>>;
+    onRequest<T extends MethodKeys<CameraMotionDetectionInterface>>(delegateType: 'motionDetectorDelegate', cameraId: string, fn: T, ...args: Parameters<MethodType<CameraMotionDetectionInterface, T>>): Promise<ReturnType<MethodType<CameraMotionDetectionInterface, T>>>;
+    onRequest<T extends MethodKeys<CameraObjectDetectionInterface>>(delegateType: 'objectDetectorDelegate', cameraId: string, fn: T, ...args: Parameters<MethodType<CameraObjectDetectionInterface, T>>): Promise<ReturnType<MethodType<CameraObjectDetectionInterface, T>>>;
+    onRequest<T extends MethodKeys<CameraAudioDetectionInterface>>(delegateType: 'audioDetectorDelegate', cameraId: string, fn: T, ...args: Parameters<MethodType<CameraAudioDetectionInterface, T>>): Promise<ReturnType<MethodType<CameraAudioDetectionInterface, T>>>;
+    handleMessage(message: ProxyMessageStructure): Promise<void | ProxyMessageStructure>;
 }

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

@@ -27,5 +27,5 @@ export declare class DeviceManagerProxy implements DeviceManagerServerProxyMetho
         id: string;
         pluginId: string;
     }): Promise<void>;
-    handleMessage(message: ProxyMessageStructure): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void | ProxyMessageStructure>;
 }

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

@@ -8,5 +8,5 @@ export declare class PluginsManagerProxy implements PluginsManagerServerProxyMet
     constructor(messageQueue: MessageQueue);
     onRequestPluginFn<K extends keyof CallablePluginMethods>(pluginId: string, fn: K, ...args: Parameters<BasePlugin[K]>): Promise<ReturnType<BasePlugin[K]>>;
     onRequestStorageFn<K extends keyof CallablePluginStorageMethods>(pluginId: string, cameraId: string, fn: K, ...args: Parameters<CameraStorage[K]>): Promise<Awaited<ReturnType<CameraStorage[K]>>>;
-    handleMessage(message: ProxyMessageStructure): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void | ProxyMessageStructure>;
 }

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

@@ -4,5 +4,5 @@ export declare class SystemManagerProxy implements SystemManagerServerProxyMetho
     private pluginsService;
     private messageQueue;
     constructor(messageQueue: MessageQueue);
-    handleMessage(message: ProxyMessageStructure): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void | ProxyMessageStructure>;
 }

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

@@ -3,28 +3,31 @@ import type { ProxyAuth } from './types.js';
 export declare class NatsServer {
     private readonly clusterAmount;
     private readonly auth;
-    private _serverPort;
-    private _clusterPort;
+    private serverPort;
+    private clusterPort;
+    private _endpoints;
     private serverProcess?;
     private clusterProcesses;
     private logger;
     private configService;
     private process;
     private tmpDir;
+    private config;
     private manuallyKilled;
     private shuttingDown;
     private _status;
     get status(): RUNTIME_STATUS;
-    get serverPort(): number;
-    get clusterPort(): number;
+    get endpoints(): string[];
     constructor(auth: ProxyAuth);
     start(): Promise<void>;
-    private startServer;
-    private startClusterServer;
-    private setupProcess;
+    private configServer;
+    private configClusters;
     stop(): Promise<void>;
     restart(): Promise<void>;
     getPID(): number;
+    private startServer;
+    private startClusterServer;
+    private setupProcess;
     private writeConfigFile;
     private stringifyConfig;
     private kill;

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

@@ -1,13 +1,11 @@
-import type { Camera } from '../api/database/types.js';
+import type { Camera, VideoStreamingMode } from '../api/database/types.js';
 import type { CameraDevice } from '../camera/device.js';
-import type { CameraConfig, Container, FfmpegOptions, PrebufferState, SetValues, StateValues, StreamInfo } from '../camera/types.js';
+import type { CameraConfig, CameraConfigInputSettings, CameraDelegates, Container, PrebufferState, SetValues, StateValues } 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';
 import type { IceServer } from '../services/config/types.js';
-export type MethodKeys<T> = {
-    [K in keyof T]: T[K] extends Function ? K : never;
-}[keyof T];
+import type { MethodKeys } from '../types.js';
 export interface QueueItem {
     message: ProxyMessageStructure;
     resolve: (response: any) => void;
@@ -21,11 +19,11 @@ export interface ProxyMessageStructure {
     pluginId: string;
     type: 'request' | 'reply';
     proxy: 'system' | 'device' | 'plugins' | 'camera';
-    client: 'pluginFn' | 'pluginStorage' | 'cameraFn' | 'cameraDelegate' | 'cameraPrebufferDelegate' | 'device' | 'system';
+    client: 'cameraFn' | 'pluginFn' | 'pluginStorage' | 'device' | 'system' | keyof CameraDelegates;
     fn: string;
-    args: any;
+    args: any[] | Record<string, any>;
     timeout: number;
-    timestamp: string;
+    timestamp: number;
     response?: any;
     error?: any;
 }
@@ -39,19 +37,11 @@ export interface ProxyAuth {
         pass: string;
     };
 }
-export interface MethodNamesByManager {
-    systemManager: SystemManagerProxyMethodNames;
-    deviceManager: DeviceManagerProxyMethodNames;
-    pluginsManager: PluginsManagerProxyMethodNames;
-    cameraDevice: CameraDeviceProxyMethodNames;
-}
-export type ManagerNames = keyof MethodNamesByManager;
-export interface WebsocketClientRequest<T extends keyof MethodNamesByManager> {
-    name: T;
-    method: MethodNamesByManager[T];
-    args: any[];
-}
 export type WebsocketClientProxyEvent = 'updateDevice' | 'updateState';
+export interface StreamPayload {
+    type: Exclude<VideoStreamingMode, 'webrtc' | 'webrtc/tcp'> | 'webrtc/offer' | 'webrtc/candidate';
+    value: string;
+}
 export interface DeviceManagerServerProxyMethods {
     createCamera(data: {
         camera: CameraConfig;
@@ -87,15 +77,6 @@ export interface CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): void;
-    reboot(data: {
-        cameraId: string;
-        pluginId: string;
-    }): Promise<void>;
-    getStreamInfo(data: {
-        sourceName: string;
-        cameraId: string;
-        pluginId: string;
-    }): Promise<StreamInfo | undefined>;
     getFfmpegPath(data: {
         cameraId: string;
         pluginId: string;
@@ -104,24 +85,6 @@ export interface CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): IceServer[];
-    snapshot(data: {
-        forceNew?: boolean;
-        cameraId: string;
-        pluginId: string;
-    }): Promise<ArrayBuffer>;
-    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>;
     updateState<T extends keyof SetValues>(data: {
         stateName: T;
         eventData: SetValues[T];
@@ -143,11 +106,27 @@ export interface CameraDeviceProxyMethods {
         states: StateValues;
         cameraState: boolean;
     };
+    addCameraSource(data: {
+        source: CameraConfigInputSettings;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    updateCameraSource(data: {
+        id: string;
+        source: Partial<CameraConfigInputSettings>;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    removeCameraSource(data: {
+        id: string;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
 }
 export type CameraDeviceProxyMethodNames = MethodKeys<CameraDeviceProxyMethods>;
 export interface DeviceManagerListenerMessagePayload {
     type: keyof DeviceManagerProxyEventCallbacks;
-    data: DeviceManagerProxyEvents['cameraSelected'] | DeviceManagerProxyEvents['cameraDeselected'] | DeviceManagerProxyEvents['cameraUpdated'];
+    data: DeviceManagerProxyEvents['cameraSelected'] | DeviceManagerProxyEvents['cameraDeselected'];
 }
 export interface DeviceManagerProxyMethods {
     getCameraByName(name: string): Promise<CameraDevice | undefined>;
@@ -166,15 +145,10 @@ export interface DeviceManagerProxyEvents {
         camera: Camera;
         extension: CameraExtension;
     };
-    cameraUpdated: {
-        camera: Camera;
-        extension: CameraExtension;
-    };
 }
 export interface DeviceManagerProxyEventCallbacks {
     cameraSelected: (camera: CameraDevice, extension: CameraExtension) => void;
     cameraDeselected: (cameraId: string, extension: CameraExtension) => 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

@@ -5,8 +5,11 @@ import type { CameraDeviceListenerMessagePayload } from './types.js';
 export declare class WebsocketProxy {
     nsp: Namespace;
     nspName: SocketNsp;
-    private proxy;
+    private logger;
+    private proxyServer;
+    private configService;
     private camerasService;
+    private bridges;
     constructor(io: Server);
     init(): void;
     publishCameraEvent<K extends keyof StateValues>(cameraId: string, stateName: K, data: {
@@ -15,9 +18,10 @@ export declare class WebsocketProxy {
     }): void;
     publishCameraEvent(cameraId: string, type: CameraDeviceListenerMessagePayload['type'], data?: any): void;
     private setupEventListeners;
-    private isSystemManagerMethod;
-    private isDeviceManagerMethod;
-    private isPluginsManagerMethod;
-    private isCameraProxyMethod;
+    private connectBridge;
+    private closeBridge;
+    private sendMessage;
+    private onEnd;
+    private onDestroy;
     private isCameraState;
 }