@camera.ui/browser 0.0.81 → 0.0.82

package/dist/types/server/src/api/services/backup.service.d.ts

@@ -1,4 +1,5 @@
-import type { BackupInfo, MultipartFile, UiLocalStorage } from '../types/index.js';
+import type { MultipartFile } from '@fastify/multipart';
+import type { BackupInfo, UiLocalStorage } from '../types/index.js';
 export declare class BackupService {
     private logger;
     private configService;

package/dist/types/server/src/api/services/cameras.service.d.ts

@@ -16,7 +16,6 @@ export declare class CamerasService {
     patchZoneByName(cameraname: string, zonename: string, zoneData: CameraZone): Promise<DBCamera | undefined>;
     removeZoneByName(cameraname: string, zonename: string): Promise<void>;
     createCameraSource(cameraname: string, sourceName: string, source: string): Promise<void>;
-    resetCameraSource(cameraname: string, sourceName: string): Promise<void>;
     list(): DBCamera[];
     listTransformed(): Camera[];
     listByPluginId(pluginId: string): DBCamera[];

package/dist/types/server/src/api/services/users.service.d.ts

@@ -1,4 +1,4 @@
-import type { DBCamviewLayout, DBUser } from '../database/types.js';
+import type { DBCameraShortcut, DBCamviewLayout, DBUser } from '../database/types.js';
 export declare class UsersService {
     private dbs;
     constructor();
@@ -9,8 +9,17 @@ export declare class UsersService {
     patchUser(username: string, userData?: Partial<DBUser>): Promise<DBUser | undefined>;
     removeByName(username: string): Promise<void>;
     removeAll(): Promise<void>;
+    createShortcut(username: string, cameraId: string, shortcutData: DBCameraShortcut): Promise<DBCameraShortcut[] | undefined>;
+    patchShortcutById(username: string, cameraId: string, shortcutId: string, shortcutData?: Partial<DBCameraShortcut>): Promise<DBCameraShortcut[] | undefined>;
+    removeShortcutById(username: string, cameraId: string, shortcutId: string): Promise<DBCameraShortcut[] | undefined>;
+    removeAllShortcuts(username: string, cameraId: string): Promise<DBCameraShortcut[] | undefined>;
     createView(username: string, viewData: DBCamviewLayout): Promise<DBCamviewLayout>;
-    patchViewById(username: string, viewId: string, viewData?: Partial<DBCamviewLayout>): Promise<DBCamviewLayout | undefined>;
-    removeViewById(username: string, viewId: string): Promise<DBCamviewLayout[] | undefined>;
+    patchViewById(username: string, viewid: string, viewData?: Partial<DBCamviewLayout>): Promise<DBCamviewLayout | undefined>;
+    removeViewById(username: string, viewid: string): Promise<DBCamviewLayout[] | undefined>;
     removeAllViews(username: string): Promise<DBCamviewLayout[] | undefined>;
+    resetPreferences(username: string): Promise<void>;
+    resetAllPreferences(): Promise<void>;
+    removeCameraFromPreferences(cameraId: string): Promise<void>;
+    removeCameraFromAllShortcuts(cameraId: string): Promise<void>;
+    removeCameraFromAllViews(cameraId: string): Promise<void>;
 }

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

@@ -7,7 +7,8 @@ import type { RestoreBackupInput } from '../schemas/backup.schema.js';
 import type { CreateCameraInput, PatchCameraInput, PreviewCameraInput } from '../schemas/cameras.schema.js';
 import type { PatchConfigInput } from '../schemas/config.schema.js';
 import type { PatchGo2RtcConfigInput } from '../schemas/go2rtc.schema.js';
-import type { CreateUserInput, CreateViewInput, LoginUserInput, PatchUserInput, PatchViewInput } from '../schemas/users.schema.js';
+import type { DetectAudioInput, DetectMotionInput, DetectObjectInput } from '../schemas/plugins.schema.js';
+import type { CreateShortcutInput, CreateUserInput, CreateViewInput, LoginUserInput, PatchShortcutInput, PatchUserInput, PatchViewInput } from '../schemas/users.schema.js';
 export interface BusboyFileStream extends Readable {
     truncated: boolean;
     bytesRead: number;
@@ -173,32 +174,6 @@ export interface PaginationQuery {
     page?: number;
     pageSize?: number;
 }
-export type Multipart = MultipartFile | MultipartValue;
-export interface MultipartFile {
-    type: 'file';
-    toBuffer: () => Promise<Buffer>;
-    file: BusboyFileStream;
-    fieldname: string;
-    filename: string;
-    encoding: string;
-    mimetype: string;
-    fields: MultipartFields;
-    _buf?: Buffer;
-    value: Buffer;
-}
-export interface MultipartValue<T = unknown> {
-    type: 'field';
-    value: T;
-    fieldname: string;
-    mimetype: string;
-    encoding: string;
-    fieldnameTruncated: boolean;
-    valueTruncated: boolean;
-    fields: MultipartFields;
-}
-export interface MultipartFields {
-    [fieldname: string]: Multipart | Multipart[] | undefined;
-}
 export type PaginationRequest = {
     Querystring: PaginationQuery;
 };
@@ -238,6 +213,11 @@ export type CamerasParamsRequest = {
         cameraname: string;
     };
 };
+export type CamerasParamsIdRequest = {
+    Params: {
+        cameraid: string;
+    };
+};
 export type CameraZonesParamsRequest = {
     Params: {
         zonename: string;
@@ -329,6 +309,23 @@ export type PluginsActionRequest = {
         payload: any;
     };
 };
+export type PluginsDetectMotionRequest = {
+    Body: DetectMotionInput;
+};
+export type PluginsDetectObjectRequest = {
+    Body: DetectObjectInput;
+};
+export type PluginsDetectAudioRequest = {
+    Body: DetectAudioInput;
+};
+export interface PluginsInterfaceQueryType {
+    type: 'objectDetection' | 'motionDetection' | 'audioDetection';
+}
+export type PluginsInterfaceQuery = {
+    Querystring: {
+        type: PluginsInterfaceQueryType;
+    };
+};
 export type UsersParamsRequest = {
     Params: {
         username: string;
@@ -346,7 +343,7 @@ export type UsersPatchRequest = {
 };
 export type ViewsParamsRequest = {
     Params: {
-        viewId: string;
+        viewid: string;
     };
 };
 export type ViewsInsertRequest = {
@@ -355,6 +352,17 @@ export type ViewsInsertRequest = {
 export type ViewsPatchRequest = {
     Body: PatchViewInput;
 };
+export type ShortcutParamsRequest = {
+    Params: {
+        shortcutid: string;
+    };
+};
+export type ShortcutInsertRequest = {
+    Body: CreateShortcutInput;
+};
+export type ShortcutPatchRequest = {
+    Body: PatchShortcutInput;
+};
 export type BackupCreateRequest = {
     Body: {
         localStorage: Partial<UiLocalStorage>;
@@ -376,7 +384,7 @@ export interface ConsoleSettings {
 export type CamviewSettingsLayoutMode = 'dnd' | 'view';
 export interface CamviewSettings {
     dragDisabled?: boolean;
-    viewId?: string;
+    viewid?: string;
 }
 export interface UiSettingsLocalStorage {
     config: ConfigSettings;
@@ -562,6 +570,9 @@ export interface CameraUiPlugin {
         'camera.ui'?: string;
         node?: string;
     };
+    'camera.ui'?: PluginContract;
+    isPython: boolean;
+    isNode: boolean;
 }
 export interface FrameWorker {
     name: string;

package/dist/types/server/src/api/utils/parse.d.ts

@@ -0,0 +1,2 @@
+import type { JwtTokenDecoded } from '../types/index.js';
+export declare const parseJwt: (access_token: string) => JwtTokenDecoded;

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

@@ -3,7 +3,7 @@ import { EventEmitter } from 'node:events';
 import { CameraController } from './camera/controller.js';
 import type { Camera, CameraExtensions } from './api/database/types.js';
 import type { FrameWorker } from './decoder/worker.js';
-import type { BasePlugin } from './plugins/base.js';
+import type { BasePlugin } from './plugins/interfaces/base.js';
 import type { CameraExtension } from './plugins/types.js';
 import type { API } from './polyglot/node/plugins/api.js';
 import type { PluginLogger } from './polyglot/node/plugins/logger.js';

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

@@ -1,7 +1,4 @@
 import { BaseCameraDevice } from './index.js';
-import { CameraAudioDetectionInterface } from './interfaces/audioDetection.js';
-import { CameraMotionDetectionInterface } from './interfaces/motionDetection.js';
-import { CameraObjectDetectionInterface } from './interfaces/objectDetection.js';
 import { CameraPrebufferInterface } from './interfaces/prebuffer.js';
 import { CameraPTZInterface } from './interfaces/ptz.js';
 import type { Camera } from '../api/database/types.js';
@@ -17,11 +14,8 @@ export declare class CameraController extends BaseCameraDevice {
     private doorbellTimeoutDuration;
     private prebufferStateSubscriptions;
     cameraDelegate: CameraDelegate;
-    prebufferDelegate: CameraPrebufferInterface;
+    protected prebufferDelegate: CameraPrebufferInterface;
     ptzDelegate: CameraPTZInterface;
-    audioDetectorDelegate: CameraAudioDetectionInterface;
-    motionDetectorDelegate: CameraMotionDetectionInterface;
-    objectDetectorDelegate: CameraObjectDetectionInterface;
     get camera(): Camera;
     get sources(): CameraSource[];
     constructor(camera: Camera, logger: BaseLogger, proxy: ProxyServer);
@@ -42,5 +36,6 @@ export declare class CameraController extends BaseCameraDevice {
     private subscribeToObjectState;
     private subscribeToDoorbellState;
     private triggerProxyEvent;
+    private proxyRequest;
     private isCameraEvent;
 }

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

@@ -4,7 +4,7 @@ import type { Observable, Subscription } from 'rxjs';
 import type { Camera, CameraActivitySettings, CameraFrameWorkerSettings, CameraInformation, CameraType } from '../api/database/types.js';
 import type { VideoFrame } from '../decoder/types.js';
 import type { IceServer } from '../services/config/types.js';
-import type { AudioSetEvent, AudioState, BaseLogger, BatterySetEvent, BatteryState, CameraAudioDetectionDelegate, CameraConfigInputSettings, CameraDelegate, CameraMotionDetectionDelegate, CameraObjectDetectionDelegate, CameraPTZDelegate, CameraPrebufferDelegate, CameraSource, Container, DetectionZone, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, PrebufferState, SetValues, Sets, SirenSetEvent, SirenState, StateValues, States } from './types.js';
+import type { AudioSetEvent, AudioState, BaseLogger, BatterySetEvent, BatteryState, CameraConfigInputSettings, CameraDelegate, CameraPTZDelegate, CameraPrebufferDelegate, CameraSource, Container, DetectionZone, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, PrebufferState, SetValues, Sets, SirenSetEvent, SirenState, StateValues, States } from './types.js';
 declare class Subscribed {
     private readonly subscriptions;
     private readonly additionalSubscriptions;
@@ -39,11 +39,8 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     readonly onSirenDetected: Observable<SirenState>;
     readonly onBatteryChanged: Observable<BatteryState>;
     abstract cameraDelegate: CameraDelegate;
-    abstract prebufferDelegate: CameraPrebufferDelegate;
+    protected abstract prebufferDelegate: CameraPrebufferDelegate;
     abstract ptzDelegate: CameraPTZDelegate;
-    abstract motionDetectorDelegate: CameraMotionDetectionDelegate;
-    abstract audioDetectorDelegate: CameraAudioDetectionDelegate;
-    abstract objectDetectorDelegate: CameraObjectDetectionDelegate;
     protected get cameraObject(): Camera;
     get id(): string;
     get nativeId(): string | undefined;
@@ -68,9 +65,10 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     get frameWorkerSettings(): CameraFrameWorkerSettings;
     get sources(): CameraSource[];
     get streamSource(): CameraSource;
-    get snapshotSource(): CameraSource;
-    get recordingSource(): CameraSource;
-    get detectionSource(): CameraSource;
+    get snapshotSource(): CameraSource | undefined;
+    get highResolutionSource(): CameraSource | undefined;
+    get midResolutionSource(): CameraSource | undefined;
+    get lowResolutionSource(): CameraSource | undefined;
     constructor(camera: Camera, logger: BaseLogger);
     getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
     snapshot(forceNew?: boolean): Promise<ArrayBuffer>;

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

@@ -5,6 +5,7 @@ export declare class CameraInterface extends CameraDelegate {
     private onRequest;
     private logger;
     constructor(onRequest: (client: any, fn: string, args?: any[], timeout?: number) => Promise<any>, logger: BaseLogger);
+    snapshot(): Promise<ArrayBuffer>;
     reboot(): Promise<void>;
     private _onRequest;
 }

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

@@ -1,10 +1,7 @@
 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 {
@@ -182,6 +179,7 @@ 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 snapshot(): Promise<ArrayBuffer>;
     abstract reboot(): Promise<void>;
 }
 export declare abstract class CameraPrebufferDelegate {
@@ -193,28 +191,13 @@ export declare abstract class CameraPTZDelegate {
     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/decoder/types.d.ts

@@ -2,6 +2,15 @@ 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 ImageMetadata {
+    width: number;
+    height: number;
+}
+export interface AudioMetadata {
+    channels: number;
+    sampleRate: number;
+    format: string;
+}
 export interface FrameMetadata {
     format: DecoderFormat;
     frameSize: number;
@@ -30,7 +39,7 @@ export interface ImageOptions {
     crop?: ImageCrop;
     resize?: ImageResize;
 }
-export interface ProcessImageRequest {
+export interface ProcessPrebufferedImageRequest {
     frameData: FrameData;
     metadata: FrameMetadata;
     options: ImageOptions;

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

@@ -1,21 +1,22 @@
 import { CameraDeviceProxy } from './proxy/cameraDevice.js';
-import { DeviceManagerProxy, PluginsManagerProxy, SystemManagerProxy } from './proxy/index.js';
+import { DeviceManagerProxy } 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 { CameraStorage } from '../polyglot/node/plugins/cameraStorage.js';
+import type { MethodKeys, MethodType } from '../types.js';
+import type { CameraDeviceListenerMessagePayload, DeviceManagerProxyEvents, PluginMap, ProxyAuth } from './types.js';
 import type { WebsocketProxy } from './websocket.js';
 export declare class ProxyServer {
     private api;
     private logger;
     deviceManagerProxy?: DeviceManagerProxy;
-    pluginsManagerProxy?: PluginsManagerProxy;
-    systemManagerProxy?: SystemManagerProxy;
     cameraDeviceProxy?: CameraDeviceProxy;
     websocketProxy?: WebsocketProxy;
     server: NatsServer;
     publisher?: NatsConnection;
     subscriber?: Subscription;
+    private pluginsService?;
     private messageQueue?;
     private initialized;
     auth: ProxyAuth;
@@ -23,12 +24,12 @@ export declare class ProxyServer {
     initialize(): Promise<void>;
     close(): Promise<void>;
     publishDeviceManagerEvent<K extends keyof DeviceManagerProxyEvents>(targetId: string, type: K, data: DeviceManagerProxyEvents[K]): void;
-    publishSystemManagerEvent<K extends keyof SystemManagerProxyEvents>(targetId: string, type: K, data: SystemManagerProxyEvents[K]): void;
-    publishPluginsManagerEvent<K extends keyof PluginsManagerProxyEvents>(targetId: string, type: K, data: PluginsManagerProxyEvents[K]): void;
     publishCameraEvent<K extends keyof StateValues>(cameraId: string, stateName: K, data: {
         newEvent: StateValues[K];
         oldEvent: StateValues[K];
     }, targetId?: string): void;
     publishCameraEvent(cameraId: string, type: CameraDeviceListenerMessagePayload['type'], data?: any, targetId?: string): void;
+    requestPluginFn<T extends keyof PluginMap, K extends MethodKeys<PluginMap[T]>>(pluginType: T, pluginId: string, fn: K, args: Parameters<MethodType<PluginMap[T], K>>, timeout?: number): Promise<Awaited<ReturnType<MethodType<PluginMap[T], K>>>>;
+    requestStorageFn<T extends MethodKeys<CameraStorage>>(pluginId: string, cameraId: string, fn: T, args: Parameters<MethodType<CameraStorage, T>>, timeout?: number): Promise<Awaited<ReturnType<MethodType<CameraStorage, T>>>>;
     private isCameraState;
 }

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

@@ -1,14 +1,8 @@
 import type { Camera } from '../../api/database/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 { CameraConfigInputSettings, CameraInterfaces, 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 { MessageQueue } from '../messageQueue.js';
 import type { CameraDeviceProxyMethods, ProxyMessageStructure } from '../types.js';
 export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     private api;
@@ -17,25 +11,20 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     private pluginsService;
     private messageQueue;
     constructor(messageQueue: MessageQueue);
-    connect(cameraId: string): void;
-    disconnect(cameraId: string): void;
+    connect(cameraId: string, pluginId: string): void;
+    disconnect(cameraId: string, pluginId: string): void;
     getFfmpegPath(): string;
     getIceServers(): IceServer[];
-    updateState<T extends keyof SetValues>(stateName: T, eventData: SetValues[T], cameraId: string): Promise<void>;
+    updateState<T extends keyof SetValues>(stateName: T, eventData: SetValues[T], cameraId: string, pluginId: string): Promise<void>;
     updatePrebufferState(sourceId: string, container: Container, state: PrebufferState, cameraId: string, pluginId: string): Promise<void>;
     addCameraSource(source: CameraConfigInputSettings, cameraId: string, pluginId: string): Promise<void>;
-    updateCameraSource(id: string, source: Partial<CameraConfigInputSettings>, cameraId: string, pluginId: string): Promise<void>;
-    removeCameraSource(id: string, cameraId: string, pluginId: string): Promise<void>;
+    updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>, cameraId: string, pluginId: string): Promise<void>;
+    removeCameraSource(sourceId: string, cameraId: string, pluginId: string): Promise<void>;
     refreshStates(cameraId: string): {
         camera: Camera;
         states: StateValues;
         cameraState: boolean;
     };
-    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>>>;
+    onRequest<T extends keyof CameraInterfaces, K extends MethodKeys<CameraInterfaces[T]>>(cameraId: string, client: T, fn: K, ...args: Parameters<MethodType<CameraInterfaces[T], K>>): Promise<Awaited<ReturnType<MethodType<CameraInterfaces[T], K>>>>;
     handleMessage(message: ProxyMessageStructure): Promise<void | ProxyMessageStructure>;
 }

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

@@ -1,31 +1,16 @@
 import type { Camera } from '../../api/database/types.js';
 import type { CameraConfig } from '../../camera/types.js';
-import type { MessageQueue } from '../queue.js';
+import type { MessageQueue } from '../messageQueue.js';
 import type { DeviceManagerServerProxyMethods, ProxyMessageStructure } from '../types.js';
 export declare class DeviceManagerProxy implements DeviceManagerServerProxyMethods {
     private camerasService;
     private pluginsService;
     private messageQueue;
     constructor(messageQueue: MessageQueue);
-    getCameraByName(data: {
-        name: string;
-        pluginId: string;
-    }): Camera | undefined;
-    getCameraById(data: {
-        id: string;
-        pluginId: string;
-    }): Camera | void;
-    createCamera(data: {
-        camera: CameraConfig;
-        pluginId: string;
-    }): Promise<Camera>;
-    removeCameraByName(data: {
-        name: string;
-        pluginId: string;
-    }): Promise<void>;
-    removeCameraById(data: {
-        id: string;
-        pluginId: string;
-    }): Promise<void>;
+    getCameraByName(cameraName: string, pluginId: string): Camera | undefined;
+    getCameraById(cameraId: string, pluginId: string): Camera | void;
+    createCamera(cameraConfig: CameraConfig, pluginId: string): Promise<Camera>;
+    removeCameraByName(cameraName: string, pluginId: string): Promise<void>;
+    removeCameraById(cameraId: string, pluginId: string): Promise<void>;
     handleMessage(message: ProxyMessageStructure): Promise<void | ProxyMessageStructure>;
 }

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

@@ -1,4 +1,2 @@
 export { CameraDeviceProxy } from './cameraDevice.js';
 export { DeviceManagerProxy } from './deviceManager.js';
-export { PluginsManagerProxy } from './pluginsManager.js';
-export { SystemManagerProxy } from './systemManager.js';

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

@@ -1,15 +1,25 @@
 import type { Camera, VideoStreamingMode } from '../api/database/types.js';
 import type { CameraDevice } from '../camera/device.js';
 import type { CameraConfig, CameraConfigInputSettings, CameraDelegates, Container, PrebufferState, SetValues, StateValues } from '../camera/types.js';
-import type { BasePlugin } from '../plugins/base.js';
+import type { AudioDetectionPlugin } from '../plugins/interfaces/audioDetection.js';
+import type { BasePlugin } from '../plugins/interfaces/base.js';
+import type { MotionDetectionPlugin } from '../plugins/interfaces/motionDetection.js';
+import type { ObjectDetectionPlugin } from '../plugins/interfaces/objectDetection.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';
 import type { MethodKeys } from '../types.js';
 export interface QueueItem {
     message: ProxyMessageStructure;
     resolve: (response: any) => void;
-    reject: (error: Error) => void;
+    reject: (error: RemoteError) => void;
+}
+export interface DeserializedError {
+    name: string;
+    message: string;
+    stack: string;
+}
+export declare class RemoteError extends Error {
+    constructor(error: DeserializedError, cause: Omit<ProxyMessageStructure, 'error'>);
 }
 export interface ProxyMessageStructure {
     requestId: string;
@@ -18,14 +28,14 @@ export interface ProxyMessageStructure {
     targetName?: string;
     pluginId: string;
     type: 'request' | 'reply';
-    proxy: 'system' | 'device' | 'plugins' | 'camera';
-    client: 'cameraFn' | 'pluginFn' | 'pluginStorage' | 'device' | 'system' | keyof CameraDelegates;
+    proxy: 'device' | 'camera' | 'plugin';
+    client: 'cameraFn' | 'pluginFn' | 'deviceFn' | 'storageFn' | keyof CameraDelegates;
     fn: string;
     args: any[];
     timeout: number;
     timestamp: number;
     response?: any;
-    error?: any;
+    error?: DeserializedError;
 }
 export interface ProxyAuth {
     cluster: {
@@ -43,30 +53,11 @@ export interface StreamPayload {
     value: string;
 }
 export interface DeviceManagerServerProxyMethods {
-    createCamera(data: {
-        camera: CameraConfig;
-        pluginId: string;
-    }): Promise<Camera>;
-    getCameraByName(data: {
-        name: string;
-        pluginId: string;
-    }): Camera | void;
-    getCameraById(data: {
-        id: string;
-        pluginId: string;
-    }): Camera | void;
-    removeCameraByName(data: {
-        name: string;
-        pluginId: string;
-    }): Promise<void>;
-    removeCameraById(data: {
-        id: string;
-        pluginId: string;
-    }): Promise<void>;
-}
-export interface SystemManagerServerProxyMethods {
-}
-export interface PluginsManagerServerProxyMethods {
+    createCamera(camera: CameraConfig): Promise<Camera>;
+    getCameraByName(name: string): Camera | void;
+    getCameraById(id: string): Camera | void;
+    removeCameraByName(name: string): Promise<void>;
+    removeCameraById(id: string): Promise<void>;
 }
 export interface CameraDeviceProxyMethods {
     connect(): void;
@@ -81,8 +72,8 @@ export interface CameraDeviceProxyMethods {
         cameraState: boolean;
     };
     addCameraSource(source: CameraConfigInputSettings): Promise<void>;
-    updateCameraSource(id: string, source: Partial<CameraConfigInputSettings>): Promise<void>;
-    removeCameraSource(id: string): Promise<void>;
+    updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>): Promise<void>;
+    removeCameraSource(sourceId: string): Promise<void>;
 }
 export type CameraDeviceProxyMethodNames = MethodKeys<CameraDeviceProxyMethods>;
 export interface DeviceManagerListenerMessagePayload {
@@ -90,11 +81,11 @@ export interface DeviceManagerListenerMessagePayload {
     data: DeviceManagerProxyEvents['cameraSelected'] | DeviceManagerProxyEvents['cameraDeselected'];
 }
 export interface DeviceManagerProxyMethods {
-    getCameraByName(name: string): Promise<CameraDevice | undefined>;
-    getCameraById(id: string): Promise<CameraDevice | undefined>;
-    createCamera(camera: CameraConfig): Promise<CameraDevice>;
-    removeCameraByName(name: string): Promise<void>;
-    removeCameraById(id: string): Promise<void>;
+    getCameraByName(cameraName: string): Promise<CameraDevice | undefined>;
+    getCameraById(cameraId: string): Promise<CameraDevice | undefined>;
+    createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
+    removeCameraByName(cameraName: string): Promise<void>;
+    removeCameraById(cameraId: string): Promise<void>;
 }
 export type DeviceManagerProxyMethodNames = MethodKeys<DeviceManagerProxyMethods>;
 export interface DeviceManagerProxyEvents {
@@ -115,46 +106,12 @@ export interface DeviceManagerProxyGenericEvent<K extends keyof DeviceManagerPro
     type: K;
     data: DeviceManagerProxyEvents[K];
 }
-export interface SystemManagerListenerMessagePayload {
-    type: keyof SystemManagerProxyEventCallbacks;
-    data: any;
-}
-export interface SystemManagerProxyMethods {
-}
-export type SystemManagerProxyMethodNames = MethodKeys<SystemManagerProxyMethods>;
-export interface SystemManagerProxyMethodsListener {
-    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;
-}
-export interface SystemManagerProxyEvents {
-}
-export type SystemManagerProxyEventCallbacks = {};
-export interface SystemManagerProxyGenericEvent<K extends keyof SystemManagerProxyEvents> {
-    type: K;
-    data: SystemManagerProxyEvents[K];
-}
-export interface PluginsManagerListenerMessagePayload {
-    type: keyof PluginsManagerProxyEventCallbacks;
-    data: any;
-}
-export interface PluginsManagerProxyMethods {
-}
-export type PluginsManagerProxyMethodNames = MethodKeys<PluginsManagerProxyMethods>;
-export interface PluginsManagerProxyMethodsListener {
-    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;
-}
-export interface PluginsManagerProxyEvents {
-}
-export type PluginsManagerProxyEventCallbacks = {};
-export interface PluginsManagerProxyGenericEvent<K extends keyof PluginsManagerProxyEvents> {
-    type: K;
-    data: PluginsManagerProxyEvents[K];
+export interface PluginMap {
+    base: BasePlugin;
+    motionDetection: MotionDetectionPlugin;
+    objectDetection: ObjectDetectionPlugin;
+    audioDetection: AudioDetectionPlugin;
 }
-export type CallablePluginStorageMethods = Pick<CameraStorage, 'getConfig' | 'setConfig'>;
-export type CallablePluginMethods = Pick<BasePlugin, 'onFormSubmit'>;
 export interface CameraDeviceListenerStatePayload<K extends keyof StateValues> {
     stateName: K;
     data: {

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

@@ -0,0 +1,7 @@
+import { BasePlugin } from './base.js';
+import type { AudioMetadata } from '../../decoder/types.js';
+import type { AudioDetectionPluginResponse, RootSchema } from '../types.js';
+export declare abstract class AudioDetectionPlugin extends BasePlugin {
+    abstract interfaceSchema(): RootSchema | void;
+    abstract detectAudio(audioPath: string, metadata: AudioMetadata, config: Record<string, any>): Promise<AudioDetectionPluginResponse>;
+}

package/dist/types/server/src/plugins/{base.d.ts → interfaces/base.d.ts}

@@ -1,5 +1,5 @@
-import type { CameraDevice } from '../camera/device.js';
-import type { FormSubmitResponse } from './types.js';
+import type { CameraDevice } from '../../camera/device.js';
+import type { FormSubmitResponse } from '../types.js';
 export declare abstract class BasePlugin {
     abstract onFormSubmit(actionId: string, payload: any): Promise<FormSubmitResponse | void>;
     abstract configureCameras(cameras: CameraDevice[]): void;