@camera.ui/browser 0.0.81 → 0.0.83

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): Camera | undefined;
+    getCameraById(cameraId: 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/server.d.ts

@@ -10,7 +10,6 @@ export declare class NatsServer {
     private clusterProcesses;
     private logger;
     private configService;
-    private process;
     private tmpDir;
     private config;
     private manuallyKilled;

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

@@ -0,0 +1,12 @@
+import { EventEmitter } from 'events';
+import type { Msg, Subscription as NatsSubscription } from 'nats';
+export declare interface ProxySubscription {
+    on(event: 'message', listener: (message: Msg) => void): this;
+    emit(event: 'message', message: Msg): boolean;
+}
+export declare class ProxySubscription extends EventEmitter implements ProxySubscription {
+    readonly subscriber: NatsSubscription;
+    constructor(subscriber: NatsSubscription);
+    listen(): Promise<void>;
+    close(): void;
+}

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

@@ -1,15 +1,18 @@
 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 { AuthConfig } from '../decoder/types.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';
+import type { DeserializedError, RemoteError } from './error.js';
 export interface QueueItem {
     message: ProxyMessageStructure;
     resolve: (response: any) => void;
-    reject: (error: Error) => void;
+    reject: (error: RemoteError) => void;
 }
 export interface ProxyMessageStructure {
     requestId: string;
@@ -18,56 +21,24 @@ 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: {
-        user: string;
-        pass: string;
-    };
-    server: {
-        user: string;
-        pass: string;
-    };
+    cluster: AuthConfig;
+    server: AuthConfig;
 }
 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;
-        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 {
-}
 export interface CameraDeviceProxyMethods {
     connect(): void;
     disconnect(): void;
@@ -81,22 +52,38 @@ 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 {
-    type: keyof DeviceManagerProxyEventCallbacks;
-    data: DeviceManagerProxyEvents['cameraSelected'] | DeviceManagerProxyEvents['cameraDeselected'];
+export interface CameraDeviceListenerStatePayload<K extends keyof StateValues> {
+    stateName: K;
+    data: {
+        newEvent: StateValues[K];
+        oldEvent: StateValues[K];
+    };
 }
-export interface DeviceManagerProxyMethods {
-    getCameraByName(name: string): Promise<CameraDevice | undefined>;
-    getCameraById(id: string): Promise<CameraDevice | undefined>;
-    createCamera(camera: CameraConfig): Promise<CameraDevice>;
+export interface CameraDeviceListenerMessagePayload {
+    type: 'removed' | 'updated' | 'cameraState' | 'prebufferState';
+    data?: any;
+}
+export interface DeviceManagerServerProxyMethods {
+    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 type DeviceManagerProxyMethodNames = MethodKeys<DeviceManagerProxyMethods>;
+export interface DeviceManagerProxyMethods {
+    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 interface DeviceManagerListenerMessagePayload {
+    type: keyof DeviceManagerProxyEventCallbacks;
+    data: DeviceManagerProxyEvents['cameraSelected'] | DeviceManagerProxyEvents['cameraDeselected'];
+}
 export interface DeviceManagerProxyEvents {
     cameraSelected: {
         camera: Camera;
@@ -115,54 +102,9 @@ 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 type CallablePluginStorageMethods = Pick<CameraStorage, 'getConfig' | 'setConfig'>;
-export type CallablePluginMethods = Pick<BasePlugin, 'onFormSubmit'>;
-export interface CameraDeviceListenerStatePayload<K extends keyof StateValues> {
-    stateName: K;
-    data: {
-        newEvent: StateValues[K];
-        oldEvent: StateValues[K];
-    };
-}
-export interface CameraDeviceListenerMessagePayload {
-    type: 'removed' | 'updated' | 'cameraState' | 'prebufferState';
-    data?: any;
+export interface PluginMap {
+    base: BasePlugin;
+    motionDetection: MotionDetectionPlugin;
+    objectDetection: ObjectDetectionPlugin;
+    audioDetection: AudioDetectionPlugin;
 }

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

@@ -1,4 +1,2 @@
-export declare function generateSecureCredentials(): {
-    user: string;
-    pass: string;
-};
+import type { AuthConfig } from '../decoder/types.js';
+export declare function generateCredentials(): AuthConfig;

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

@@ -12,14 +12,14 @@ export declare class PluginManager {
     searchPaths: Set<string>;
     constructor();
     static isQualifiedPluginIdentifier(pluginName: string): boolean;
-    static extractPluginScope(pluginName: string): string;
+    static extractPluginScope(pluginName: string): string | undefined;
     static extractPluginName(pluginName: string): string;
     static transformDisplaName(pluginName: string): string;
     static loadPackageJSON(installPath: string): IPackageJson;
     initializeInstalledPlugins(): Promise<void>;
     initializeInstalledPlugin(plugin: Plugin): Promise<void>;
-    loadPlugin(absolutePath: string, pluginId?: string, storagePath?: string): Promise<Plugin>;
-    removePlugin(plugin: Plugin, removeFromDb?: boolean, removeStorage?: boolean): Promise<void>;
+    loadPlugin(absolutePath: string): Promise<Plugin>;
+    removePlugin(plugin: Plugin, removeStorage?: boolean): Promise<void>;
     startPluginChild(pluginName: string): Promise<void>;
     stopPluginChild(pluginName: string): Promise<void>;
     initializePlugins(): Promise<void>;
@@ -27,6 +27,4 @@ export declare class PluginManager {
     private loadInstalledPlugins;
     private removeOrphanedPlugins;
     private handleDisabledPlugins;
-    private loadDefaultPaths;
-    private addNpmPrefixToSearchPaths;
 }

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;

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

@@ -0,0 +1,6 @@
+import { BasePlugin } from './base.js';
+import type { MotionDetectionPluginResponse, RootSchema } from '../types.js';
+export declare abstract class MotionDetectionPlugin extends BasePlugin {
+    abstract interfaceSchema(): RootSchema | void;
+    abstract detectMotion(videoPath: string, config: Record<string, any>): Promise<MotionDetectionPluginResponse>;
+}

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

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

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

@@ -1,42 +1,33 @@
-import { PluginConfigService } from '../polyglot/node/plugins/config.js';
 import { PythonInstaller } from '../utils/pythonInstaller.js';
-import type { PluginConstructor } from '../api.js';
 import type { CameraUiPlugin, IPackageJson } from '../api/types/index.js';
 import type { PluginContract } from './types.js';
-export interface Context {
-    engines?: Record<string, string>;
-    dependencies?: Record<string, string>;
-}
 export declare class Plugin {
     private logger;
     private configService;
     private _disabled;
     private _info;
     private _contract;
-    readonly main: string;
+    private loadContext;
     readonly id: string;
+    readonly main: string;
     readonly pluginName: string;
     readonly displayName: string;
     readonly scope?: string;
     readonly isPython: boolean;
-    readonly isESM: boolean;
     readonly isSymLink: boolean;
     readonly installPath: string;
-    readonly pythonInstallPath: string;
     readonly configFile: string;
     readonly storagePath: string;
     readonly py: PythonInstaller;
-    readonly config: PluginConfigService;
-    pluginConstructor?: PluginConstructor;
-    private loadContext?;
     get contract(): PluginContract;
     get info(): CameraUiPlugin;
     set info(value: CameraUiPlugin);
     get disabled(): boolean;
     set disabled(value: boolean);
-    constructor(pluginName: string, installPath: string, packageJSON: IPackageJson, pluginId: string, scope?: string, storagePath?: string);
+    constructor(pluginName: string, installPath: string, packageJSON: IPackageJson, pluginId: string, scope?: string);
     load(): Promise<void>;
     reparsePackageJson(): void;
     private parsePackageJson;
     private parseContract;
+    private getMainFile;
 }

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

@@ -1,4 +1,9 @@
 import type { Camera } from '../api/database/types.js';
+import type { Detection } from '../camera/types.js';
+export interface Context {
+    engines?: Record<string, string>;
+    dependencies?: Record<string, string>;
+}
 export interface SchemaConfig {
     rootSchema: PluginRootSchema;
     config: Record<string, any>;
@@ -75,9 +80,9 @@ export interface JsonBaseSchema<T = any> {
     hidden?: boolean;
     group?: string;
     defaultValue?: T;
+    store?: boolean;
 }
 export interface PluginJsonBaseSchema<T = any> extends JsonBaseSchema<T> {
-    store?: boolean;
     onSet?: (newValue: any, oldValue: any) => Promise<void>;
     onGet?: () => Promise<any>;
 }
@@ -134,13 +139,10 @@ export interface PluginJsonSchemaObject extends PluginJsonBaseSchema {
 export interface JsonSchemaObjectWithButtons extends JsonSchemaObject {
     buttons: [JsonSchemaButton, JsonSchemaButton?];
 }
-export interface JsonSchemaAnyOf {
-    anyOf: JsonSchema[];
-}
 export interface JsonSchemaArray extends JsonBaseSchema {
     type: 'array';
     opened?: boolean;
-    items?: JsonSchema | JsonSchemaAnyOf;
+    items?: JsonSchema;
 }
 export interface JsonSchemaButton {
     label: string;
@@ -171,4 +173,13 @@ export interface FormSubmitResponse {
     toast?: ToastMessage;
     schema?: FormSubmitSchema;
 }
+export interface MotionDetectionPluginResponse {
+    filePath: string;
+}
+export interface ObjectDetectionPluginResponse {
+    detections: Detection[];
+}
+export interface AudioDetectionPluginResponse {
+    detected: boolean;
+}
 export {};

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

@@ -30,6 +30,6 @@ export declare class PluginWorker {
     private handleClose;
     private reset;
     private updatePython;
-    private listenToMessages;
+    private onChildMessage;
     private cleanedProcessEnv;
 }

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

@@ -1,5 +1,5 @@
 import type { PluginJsonSchema, PluginJsonSchemaForm, SchemaConfig } from '../../../plugins/types.js';
-import type { PluginAPI } from './api.js';
+import type { API } from './pluginApi.js';
 export declare class CameraStorage {
     private cameraId;
     private instance;
@@ -8,7 +8,7 @@ export declare class CameraStorage {
     private _schema;
     private _values;
     get values(): Record<string, any>;
-    constructor(api: PluginAPI, instance: any, cameraId: string, schema?: PluginJsonSchemaForm);
+    constructor(api: API, instance: any, cameraId: string, schema?: PluginJsonSchemaForm);
     /**
      * Initialize the storage.
      * This will load the configuration from the database.

package/dist/types/server/src/polyglot/node/plugins/{api.d.ts → pluginApi.d.ts}

@@ -1,11 +1,12 @@
 import { EventEmitter } from 'node:events';
-import { DeviceManager, PluginsManager, SystemManager } from './proxy/index.js';
+import { PluginConfigService } from './configService.js';
 import { StorageController } from './storageController.js';
-import type { BasePlugin } from '../../../plugins/base.js';
-import type { Plugin } from '../../../plugins/plugin.js';
-import type { PluginConfigService } from './config.js';
-import type { PluginLogger } from './logger.js';
-export declare interface API {
+import type { AuthConfig } from '../../../decoder/types.js';
+import type { BasePlugin } from '../../../plugins/interfaces/base.js';
+import type { PluginInfo } from '../../../plugins/types.js';
+import type { PluginLogger } from './pluginLogger.js';
+import type { DeviceManager } from './proxy/deviceManager.js';
+export declare interface PluginAPI {
     on(event: 'finishLaunching', listener: () => void): this;
     on(event: 'shutdown', listener: () => void): this;
     once(event: 'finishLaunching', listener: () => void): this;
@@ -16,26 +17,18 @@ export declare interface API {
     removeListener(event: 'shutdown', listener: () => void): this;
     removeAllListeners(event?: string): this;
     readonly deviceManager: DeviceManager;
-    readonly pluginsManager: PluginsManager;
-    readonly systemManager: SystemManager;
     readonly storageController: StorageController;
     readonly configService: PluginConfigService;
     readonly storagePath: string;
     readonly configFile: string;
 }
-export declare class PluginAPI extends EventEmitter implements API {
-    private initialized;
+export declare class API extends EventEmitter implements PluginAPI {
     readonly deviceManager: DeviceManager;
-    readonly pluginsManager: PluginsManager;
-    readonly systemManager: SystemManager;
     readonly storageController: StorageController;
     readonly configService: PluginConfigService;
     readonly storagePath: string;
     readonly configFile: string;
     readonly plugin: BasePlugin;
-    constructor(plugin: Plugin, logger: PluginLogger, proxyEndpoints: string[], auth: {
-        user: string;
-        pass: string;
-    });
-    init(): Promise<void>;
+    constructor(plugin: PluginInfo, storagePath: string, configFile: string, logger: PluginLogger, proxyEndpoints: string[], auth: AuthConfig);
+    private loadModule;
 }

package/dist/types/server/src/polyglot/node/plugins/{logger.d.ts → pluginLogger.d.ts}

@@ -12,5 +12,7 @@ export declare class PluginLogger {
     attention(...args: any[]): void;
     debug(...args: any[]): void;
     trace(...args: any[]): void;
+    private formatMessage;
+    private formattedArgs;
     private formatDateTime;
 }

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

@@ -1,20 +1,17 @@
 import { CameraDevice } from '../../../../camera/device.js';
-import { CameraAudioDetectionInterface } from '../../../../camera/interfaces/audioDetection.js';
 import { CameraInterface } from '../../../../camera/interfaces/camera.js';
-import { CameraMotionDetectionInterface } from '../../../../camera/interfaces/motionDetection.js';
-import { CameraObjectDetectionInterface } from '../../../../camera/interfaces/objectDetection.js';
 import { CameraPrebufferInterface } from '../../../../camera/interfaces/prebuffer.js';
 import { CameraPTZInterface } from '../../../../camera/interfaces/ptz.js';
 import { MotionFrame, VideoFrame } from '../../../../camera/videoFrame.js';
 import type { Camera } from '../../../../api/database/types.js';
-import type { CameraAudioDetectionDelegate, CameraConfigInputSettings, CameraDelegate, CameraDelegates, CameraMotionDetectionDelegate, CameraObjectDetectionDelegate, CameraPrebufferDelegate, CameraPTZDelegate, CameraSource, SetValues } from '../../../../camera/types.js';
-import type { VideoFrame as VideoFrameImp } from '../../../../decoder/types.js';
+import type { CameraConfigInputSettings, CameraDelegates, CameraSource, SetValues } from '../../../../camera/types.js';
+import type { AuthConfig, VideoFrame as VideoFrameImp } from '../../../../decoder/types.js';
 import type { CameraDeviceProxyMethods } from '../../../../nats/types.js';
 import type { PluginInfo } from '../../../../plugins/types.js';
 import type { IceServer } from '../../../../services/config/types.js';
 import type { MethodKeys, MethodType } from '../../../../types.js';
-import type { PluginAPI } from '../api.js';
-import type { PluginLogger } from '../logger.js';
+import type { API } from '../pluginApi.js';
+import type { PluginLogger } from '../pluginLogger.js';
 export declare class CameraDeviceProxy extends CameraDevice {
     private api;
     private initialized;
@@ -42,17 +39,11 @@ export declare class CameraDeviceProxy extends CameraDevice {
     private auth;
     private proxyEndpoints;
     private plugin;
-    cameraDelegate: CameraInterface;
-    prebufferDelegate: CameraPrebufferInterface;
-    ptzDelegate: CameraPTZInterface;
-    audioDetectorDelegate: CameraAudioDetectionInterface;
-    motionDetectorDelegate: CameraMotionDetectionInterface;
-    objectDetectorDelegate: CameraObjectDetectionInterface;
+    protected cameraDelegate: CameraInterface;
+    protected ptzDelegate: CameraPTZInterface;
+    protected prebufferDelegate: CameraPrebufferInterface;
     get sources(): CameraSource[];
-    constructor(api: PluginAPI, logger: PluginLogger, camera: Camera, plugin: PluginInfo, proxyEndpoints: string[], auth: {
-        user: string;
-        pass: string;
-    });
+    constructor(api: API, logger: PluginLogger, camera: Camera, plugin: PluginInfo, proxyEndpoints: string[], auth: AuthConfig);
     init(): Promise<void>;
     setDelegate<T extends keyof CameraDelegates>(name: T, delegate: CameraDelegates[T]): void;
     connect(): Promise<void>;
@@ -74,13 +65,8 @@ export declare class CameraDeviceProxy extends CameraDevice {
     private closeFrameSubscriber;
     private closeMotionFrameSubsciber;
     private requestHandler;
-    private listenToMessages;
-    private listenToSignalingMessages;
-    onRequest<T extends MethodKeys<CameraDeviceProxyMethods>>(client: 'cameraFn', fn: T, args?: Parameters<MethodType<CameraDeviceProxyMethods, T>>, timeout?: number): Promise<any>;
-    onRequest<T extends MethodKeys<CameraDelegate>>(client: 'cameraDelegate', fn: T, args?: Parameters<MethodType<CameraDelegate, T>>, timeout?: number): Promise<any>;
-    onRequest<T extends MethodKeys<CameraPrebufferDelegate>>(client: 'prebufferDelegate', fn: T, args?: Parameters<MethodType<CameraPrebufferDelegate, T>>, timeout?: number): Promise<any>;
-    onRequest<T extends MethodKeys<CameraPTZDelegate>>(client: 'ptzDelegate', fn: T, args?: Parameters<MethodType<CameraPTZDelegate, T>>, timeout?: number): Promise<any>;
-    onRequest<T extends MethodKeys<CameraMotionDetectionDelegate>>(client: 'motionDetectorDelegate', fn: T, args?: Parameters<MethodType<CameraMotionDetectionDelegate, T>>, timeout?: number): Promise<any>;
-    onRequest<T extends MethodKeys<CameraObjectDetectionDelegate>>(client: 'objectDetectorDelegate', fn: T, args?: Parameters<MethodType<CameraObjectDetectionDelegate, T>>, timeout?: number): Promise<any>;
-    onRequest<T extends MethodKeys<CameraAudioDetectionDelegate>>(client: 'audioDetectorDelegate', fn: T, args?: Parameters<MethodType<CameraAudioDetectionDelegate, T>>, timeout?: number): Promise<any>;
+    private onProxyMessage;
+    private onSignalingMessage;
+    onRequest<T extends MethodKeys<CameraDeviceProxyMethods>>(client: 'cameraFn', fn: T, args?: Parameters<MethodType<CameraDeviceProxyMethods, T>>, timeout?: number): Promise<Awaited<ReturnType<MethodType<CameraDeviceProxyMethods, T>>>>;
+    onRequest<T extends keyof CameraDelegates, K extends MethodKeys<CameraDelegates[T]>>(client: T, fn: K, args: Parameters<MethodType<CameraDelegates[T], K>>, timeout?: number): Promise<Awaited<ReturnType<MethodType<CameraDelegates[T], K>>>>;
 }