@camera.ui/browser 0.0.82 → 0.0.84

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

@@ -1,13 +1,13 @@
 import { PLUGIN_STATUS } from '../plugins/types.js';
 import { Subscribed } from '../utils/subscribed.js';
 import type { CameraController } from '../camera/controller.js';
+import type { AuthConfig } from './types.js';
 export declare class FrameWorker extends Subscribed {
-    token: string;
+    readonly frameWorkerId: string;
     name: string;
     private readonly clients;
     private subject;
     private ipcSubject;
-    private frameWorkerId;
     private publisher?;
     private subscriber?;
     private logger;
@@ -24,10 +24,7 @@ export declare class FrameWorker extends Subscribed {
     private py;
     private _status;
     get status(): PLUGIN_STATUS;
-    constructor(cameraDevice: CameraController, proxyEndpoints: string[], auth: {
-        user: string;
-        pass: string;
-    });
+    constructor(cameraDevice: CameraController, proxyEndpoints: string[], auth: AuthConfig);
     start(): Promise<void>;
     close(): Promise<void>;
     restart(): Promise<void>;
@@ -36,7 +33,7 @@ export declare class FrameWorker extends Subscribed {
     private restartWorker;
     private killWorker;
     private sendMessage;
-    private listenToMessages;
+    private onChildMessage;
     private setStatus;
     private getLogPrefix;
 }

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

@@ -0,0 +1,17 @@
+import { ProxySubscription } from './subscription.js';
+import type { NatsConnection, RequestOptions } from 'nats';
+import type { AuthConfig } from '../decoder/types.js';
+export declare class ProxyConnection {
+    private name;
+    private servers;
+    private auth;
+    private publisher?;
+    private subscribers;
+    private closed;
+    constructor(name: string, servers: string[], auth: AuthConfig);
+    connect(): Promise<NatsConnection>;
+    subscribe(subject: string, skipListening?: boolean): ProxySubscription;
+    publish(subject: string, message: any): void;
+    request(subject: string, message: any, opts?: RequestOptions): Promise<any>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+import type { ProxyMessageStructure } from './types.js';
+export interface DeserializedError {
+    name: string;
+    message: string;
+    stack: string;
+}
+export declare class RemoteError extends Error {
+    constructor(error: DeserializedError, cause: Omit<ProxyMessageStructure, 'error'>);
+}

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

@@ -1,10 +1,11 @@
+import { ProxyConnection } from './connection.js';
 import { CameraDeviceProxy } from './proxy/cameraDevice.js';
-import { DeviceManagerProxy } from './proxy/index.js';
+import { DeviceManagerProxy } from './proxy/deviceManager.js';
 import { NatsServer } from './server.js';
-import type { NatsConnection, Subscription } from 'nats';
 import type { StateValues } from '../camera/types.js';
 import type { CameraStorage } from '../polyglot/node/plugins/cameraStorage.js';
 import type { MethodKeys, MethodType } from '../types.js';
+import type { ProxySubscription } from './subscription.js';
 import type { CameraDeviceListenerMessagePayload, DeviceManagerProxyEvents, PluginMap, ProxyAuth } from './types.js';
 import type { WebsocketProxy } from './websocket.js';
 export declare class ProxyServer {
@@ -14,8 +15,8 @@ export declare class ProxyServer {
     cameraDeviceProxy?: CameraDeviceProxy;
     websocketProxy?: WebsocketProxy;
     server: NatsServer;
-    publisher?: NatsConnection;
-    subscriber?: Subscription;
+    publisher?: ProxyConnection;
+    subscriber?: ProxySubscription;
     private pluginsService?;
     private messageQueue?;
     private initialized;
@@ -31,5 +32,6 @@ export declare class ProxyServer {
     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 requestHandler;
     private isCameraState;
 }

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

@@ -1,17 +1,20 @@
-import type { ProxyServer } from './index.js';
+import type { BaseLogger } from '../camera/types.js';
+import type { ProxyConnection } from './connection.js';
+import type { ProxySubscription } from './subscription.js';
 import type { ProxyMessageStructure } from './types.js';
 export declare class MessageQueue {
     private logger;
-    private proxyServer;
+    private type;
     private publisher;
     private subscriber;
+    private requestHandler;
     private aborted;
     private isProcessing;
     private queue;
     private pendingResponses;
-    constructor(proxyServer: ProxyServer);
+    constructor(type: 'server' | 'client', publisher: ProxyConnection, subscriber: ProxySubscription, logger: BaseLogger, requestHandler: (message: ProxyMessageStructure) => void);
     abortQueue(): void;
     enqueue(message: ProxyMessageStructure): Promise<any>;
     private processQueue;
-    private listenToMessages;
+    private onMessage;
 }

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

@@ -26,5 +26,5 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
         cameraState: boolean;
     };
     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>;
+    requestHandler(message: ProxyMessageStructure): Promise<void | ProxyMessageStructure>;
 }

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

@@ -7,10 +7,10 @@ export declare class DeviceManagerProxy implements DeviceManagerServerProxyMetho
     private pluginsService;
     private messageQueue;
     constructor(messageQueue: MessageQueue);
-    getCameraByName(cameraName: string, pluginId: string): Camera | undefined;
-    getCameraById(cameraId: string, pluginId: string): Camera | 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>;
+    requestHandler(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,26 +1,19 @@
 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 { 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 { 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: 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;
     cameraId?: string;
@@ -38,27 +31,14 @@ export interface ProxyMessageStructure {
     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(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;
     disconnect(): void;
@@ -75,10 +55,23 @@ export interface CameraDeviceProxyMethods {
     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 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 interface DeviceManagerProxyMethods {
     getCameraByName(cameraName: string): Promise<CameraDevice | undefined>;
@@ -87,7 +80,10 @@ export interface DeviceManagerProxyMethods {
     removeCameraByName(cameraName: string): Promise<void>;
     removeCameraById(cameraId: string): Promise<void>;
 }
-export type DeviceManagerProxyMethodNames = MethodKeys<DeviceManagerProxyMethods>;
+export interface DeviceManagerListenerMessagePayload {
+    type: keyof DeviceManagerProxyEventCallbacks;
+    data: DeviceManagerProxyEvents['cameraSelected'] | DeviceManagerProxyEvents['cameraDeselected'];
+}
 export interface DeviceManagerProxyEvents {
     cameraSelected: {
         camera: Camera;
@@ -112,14 +108,3 @@ export interface PluginMap {
     objectDetection: ObjectDetectionPlugin;
     audioDetection: AudioDetectionPlugin;
 }
-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;
-}

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/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,7 +1,11 @@
 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;
+    rootSchema: RootSchema;
     config: Record<string, any>;
 }
 export declare const PLUGIN_IDENTIFIER_PATTERN: RegExp;
@@ -64,7 +68,7 @@ export interface ProcessResponse {
     type: PLUGIN_STATUS;
     data?: ProcessErrorMessage;
 }
-export type JsonSchemaType = 'string' | 'number' | 'boolean' | 'object' | 'array';
+export type JsonSchemaType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'button';
 export interface JsonBaseSchema<T = any> {
     type: JsonSchemaType;
     key?: string;
@@ -77,8 +81,6 @@ export interface JsonBaseSchema<T = any> {
     group?: string;
     defaultValue?: T;
     store?: boolean;
-}
-export interface PluginJsonBaseSchema<T = any> extends JsonBaseSchema<T> {
     onSet?: (newValue: any, oldValue: any) => Promise<void>;
     onGet?: () => Promise<any>;
 }
@@ -88,76 +90,47 @@ export interface JsonSchemaString extends JsonBaseSchema<string> {
     minLength?: number;
     maxLength?: number;
 }
-export interface PluginJsonSchemaString extends PluginJsonBaseSchema<string> {
-    type: 'string';
-    format?: 'date-time' | 'date' | 'time' | 'email' | 'uuid' | 'ipv4' | 'ipv6' | 'password' | 'qrCode';
-    minLength?: number;
-    maxLength?: number;
-}
 export interface JsonSchemaNumber extends JsonBaseSchema<number> {
     type: 'number';
     minimum?: number;
     maximum?: number;
     step?: number;
 }
-export interface PluginJsonSchemaNumber extends PluginJsonBaseSchema<number> {
-    type: 'number';
-    minimum?: number;
-    maximum?: number;
-    step?: number;
-}
 export interface JsonSchemaBoolean extends JsonBaseSchema<boolean> {
     type: 'boolean';
 }
-export interface PluginJsonSchemaBoolean extends PluginJsonBaseSchema<boolean> {
-    type: 'boolean';
-}
 export interface JsonSchemaEnum extends JsonBaseSchema<string> {
     type: 'string';
     enum: string[];
     multiple?: boolean;
 }
-export interface PluginJsonSchemaEnum extends PluginJsonBaseSchema<string> {
-    type: 'string';
-    enum: string[];
-    multiple?: boolean;
-}
 export interface JsonSchemaObject extends JsonBaseSchema {
     type: 'object';
     opened?: boolean;
     properties?: JsonSchemaForm;
 }
-export interface PluginJsonSchemaObject extends PluginJsonBaseSchema {
-    type: 'object';
-    opened?: boolean;
-    properties?: PluginJsonSchemaForm;
-}
-export interface JsonSchemaObjectWithButtons extends JsonSchemaObject {
-    buttons: [JsonSchemaButton, JsonSchemaButton?];
-}
 export interface JsonSchemaArray extends JsonBaseSchema {
     type: 'array';
     opened?: boolean;
     items?: JsonSchema;
 }
-export interface JsonSchemaButton {
+export interface JsonSchemaButton extends JsonBaseSchema {
+    type: 'button';
+}
+export interface JsonSchemaObjectButton {
     label: string;
     onSubmit: string;
 }
-export type JsonSchema = JsonSchemaString | JsonSchemaNumber | JsonSchemaBoolean | JsonSchemaEnum | JsonSchemaObject | JsonSchemaObjectWithButtons | JsonSchemaArray;
-export type PluginJsonSchema = PluginJsonSchemaString | PluginJsonSchemaNumber | PluginJsonSchemaBoolean | PluginJsonSchemaEnum | PluginJsonSchemaObject;
+export interface JsonSchemaObjectWithButtons extends JsonSchemaObject {
+    buttons: JsonSchemaObjectButton[];
+}
+export type JsonSchema = JsonSchemaString | JsonSchemaNumber | JsonSchemaBoolean | JsonSchemaEnum | JsonSchemaObject | JsonSchemaObjectWithButtons | JsonSchemaArray | JsonSchemaButton;
 export interface JsonSchemaForm {
     [key: string]: JsonSchema;
 }
-export interface PluginJsonSchemaForm {
-    [key: string]: PluginJsonSchema;
-}
 export interface RootSchema {
     schema: JsonSchemaForm;
 }
-export interface PluginRootSchema {
-    schema: PluginJsonSchemaForm;
-}
 export interface ToastMessage {
     type: 'info' | 'success' | 'warning' | 'error';
     message: string;

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,14 +1,13 @@
-import type { PluginJsonSchema, PluginJsonSchemaForm, SchemaConfig } from '../../../plugins/types.js';
-import type { PluginAPI } from './api.js';
-export declare class CameraStorage {
+import type { JsonSchema, JsonSchemaForm, SchemaConfig } from '../../../plugins/types.js';
+import type { API } from './pluginApi.js';
+export declare class CameraStorage<T extends Record<string, any> = Record<string, any>> {
     private cameraId;
     private instance;
     private api;
     private db;
-    private _schema;
-    private _values;
-    get values(): Record<string, any>;
-    constructor(api: PluginAPI, instance: any, cameraId: string, schema?: PluginJsonSchemaForm);
+    schema: JsonSchemaForm;
+    values: T;
+    constructor(api: API, instance: any, cameraId: string, schema?: JsonSchemaForm);
     /**
      * Initialize the storage.
      * This will load the configuration from the database.
@@ -54,7 +53,7 @@ export declare class CameraStorage {
      *
      * @param newConfig - The new configuration to set.
      */
-    setConfig(newConfig: Record<string, any>): Promise<void>;
+    setConfig(newConfig: T): Promise<void>;
     /**
      * Add a new schema to the existing schema.
      * It will also add the value to the configuration.
@@ -63,8 +62,8 @@ export declare class CameraStorage {
      * @param schema - The new schema to add.
      * @param path - The path to the schema to add.
      */
-    addSchema(schema: PluginJsonSchemaForm): Promise<void>;
-    addSchema(path: string, schema: PluginJsonSchema): Promise<void>;
+    addSchema(schema: JsonSchemaForm): Promise<void>;
+    addSchema(path: string, schema: JsonSchema): Promise<void>;
     /**
      * Remove a schema by its config path/key from the existing schema.
      * It will also remove the value from the configuration.
@@ -81,7 +80,7 @@ export declare class CameraStorage {
      * @param path - The path to the schema to change.
      * @param schema - The new schema to set.
      */
-    changeSchema(path: string, newSchema: Partial<PluginJsonSchema>): Promise<void>;
+    changeSchema(path: string, newSchema: Partial<JsonSchema>): Promise<void>;
     /**
      * Get a schema by its config path/key.
      *

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 } from './proxy/index.js';
+import { PluginConfigService } from './configService.js';
 import { StorageController } from './storageController.js';
+import type { AuthConfig } from '../../../decoder/types.js';
 import type { BasePlugin } from '../../../plugins/interfaces/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 { 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;
@@ -21,17 +22,13 @@ export declare interface API {
     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 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

@@ -5,13 +5,13 @@ import { CameraPTZInterface } from '../../../../camera/interfaces/ptz.js';
 import { MotionFrame, VideoFrame } from '../../../../camera/videoFrame.js';
 import type { Camera } from '../../../../api/database/types.js';
 import type { CameraConfigInputSettings, CameraDelegates, CameraSource, SetValues } from '../../../../camera/types.js';
-import type { VideoFrame as VideoFrameImp } from '../../../../decoder/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;
@@ -39,14 +39,11 @@ export declare class CameraDeviceProxy extends CameraDevice {
     private auth;
     private proxyEndpoints;
     private plugin;
-    cameraDelegate: CameraInterface;
+    protected cameraDelegate: CameraInterface;
+    protected ptzDelegate: CameraPTZInterface;
     protected prebufferDelegate: CameraPrebufferInterface;
-    ptzDelegate: CameraPTZInterface;
     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>;
@@ -68,8 +65,8 @@ export declare class CameraDeviceProxy extends CameraDevice {
     private closeFrameSubscriber;
     private closeMotionFrameSubsciber;
     private requestHandler;
-    private listenToMessages;
-    private listenToSignalingMessages;
+    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>>>>;
 }