@camera.ui/browser 0.0.82 → 0.0.83

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

@@ -1,18 +1,10 @@
 import { LRUCache } from 'lru-cache';
 import { BehaviorSubject } from 'rxjs';
-import type { Observable, Subscription } from 'rxjs';
+import { Subscribed } from '../utils/subscribed.js';
+import type { Observable } 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, 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;
-    protected addSubscriptions(...subscriptions: Subscription[]): void;
-    protected addAdditionalSubscriptions(...subscriptions: Subscription[]): void;
-    protected unsubscribe(): void;
-    protected unsubscribeAdditional(): void;
-}
+import type { AudioSetEvent, AudioState, BaseLogger, BatterySetEvent, BatteryState, CameraDelegate, CameraPTZDelegate, CameraPrebufferDelegate, CameraSource, Container, DetectionZone, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, PrebufferState, SetValues, SirenSetEvent, SirenState, StateValues } from './types.js';
 export declare abstract class BaseCameraDevice extends Subscribed {
     protected logger: BaseLogger;
     protected snapshotCache: LRUCache<string, ArrayBuffer, unknown>;
@@ -38,9 +30,9 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     readonly onDoorbellPressed: Observable<DoorbellState>;
     readonly onSirenDetected: Observable<SirenState>;
     readonly onBatteryChanged: Observable<BatteryState>;
-    abstract cameraDelegate: CameraDelegate;
+    protected abstract cameraDelegate: CameraDelegate;
+    protected abstract ptzDelegate: CameraPTZDelegate;
     protected abstract prebufferDelegate: CameraPrebufferDelegate;
-    abstract ptzDelegate: CameraPTZDelegate;
     protected get cameraObject(): Camera;
     get id(): string;
     get nativeId(): string | undefined;
@@ -63,44 +55,39 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     get activityZones(): DetectionZone[];
     get activitySettings(): CameraActivitySettings;
     get frameWorkerSettings(): CameraFrameWorkerSettings;
-    get sources(): CameraSource[];
     get streamSource(): CameraSource;
     get snapshotSource(): CameraSource | undefined;
     get highResolutionSource(): CameraSource | undefined;
     get midResolutionSource(): CameraSource | undefined;
     get lowResolutionSource(): CameraSource | undefined;
+    get ptz(): CameraPTZDelegate;
+    abstract get sources(): CameraSource[];
     constructor(camera: Camera, logger: BaseLogger);
+    abstract getIceServers(): Promise<IceServer[]>;
+    protected abstract cleanup(): void;
     getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
     snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     onStateChange<T extends keyof StateValues>(stateName: T): Observable<{
         newState: StateValues[T];
         oldState: StateValues[T];
     }>;
-    abstract connect(): Promise<void>;
-    abstract disconnect(): Promise<void>;
-    abstract getIceServers(): Promise<IceServer[]>;
-    abstract updateState(stateName: 'light', eventData: LightSetEvent): Promise<void>;
-    abstract updateState(stateName: 'motion', eventData: MotionSetEvent, frame?: VideoFrame): Promise<void>;
-    abstract updateState(stateName: 'audio', eventData: AudioSetEvent): Promise<void>;
-    abstract updateState(stateName: 'object', eventData: ObjectSetEvent): Promise<void>;
-    abstract updateState(stateName: 'doorbell', eventData: DoorbellSetEvent): Promise<void>;
-    abstract updateState(stateName: 'siren', eventData: SirenSetEvent): Promise<void>;
-    abstract updateState(stateName: 'battery', eventData: BatterySetEvent): Promise<void>;
-    abstract addCameraSource(source: CameraConfigInputSettings): Promise<void>;
-    abstract updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>): Promise<void>;
-    abstract removeCameraSource(sourceId: string): Promise<void>;
-    protected abstract cleanup(): void;
-    protected updateStateInternal<T extends keyof SetValues>(stateName: T, eventData: SetValues[T], skipCheck?: boolean): void;
     onPropertyChange<T extends keyof Camera>(property: T | T[]): Observable<{
         property: T;
         oldData: Camera[T];
         newData: Camera[T];
     }>;
-    removeAllListeners(): void;
+    protected removeAllListeners(): void;
+    protected updateCamera(updatedCamera: Camera): void;
+    protected updateCameraState(state: boolean): void;
+    protected updatePrebuffer(sourceId: string, container: Container, state: PrebufferState): void;
+    protected updateStateInternal<T extends keyof SetValues>(stateName: T, eventData: SetValues[T], skipCheck?: boolean): void;
     protected checkStateInternal<T extends keyof SetValues>(stateName: T, event: SetValues[T]): {
         changed: boolean;
         event: StateValues[T];
     };
+    protected cameraSourcePrebufferState(sourceId: string, container: Container): PrebufferState;
+    protected createPrebufferStateObservable(sourceId: string, container: Container): Observable<PrebufferState>;
+    protected stateChanged<T extends keyof SetValues>(oldState?: SetValues[T], newState?: SetValues[T], type?: keyof StateValues): boolean;
     protected getAudioState(event: AudioSetEvent, ignoreLastEvet?: boolean): AudioState;
     protected getMotionState(event: MotionSetEvent, ignoreLastEvet?: boolean): MotionState;
     protected getObjectState(event: ObjectSetEvent, ignoreLastEvet?: boolean): ObjectState;
@@ -108,14 +95,6 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     protected getLightState(event: LightSetEvent, ignoreLastEvet?: boolean): LightState;
     protected getSirenState(event: SirenSetEvent, ignoreLastEvet?: boolean): SirenState;
     protected getBatteryState(event: BatterySetEvent, ignoreLastEvet?: boolean): BatteryState;
-    protected updateCamera(updatedCamera: Camera): void;
-    protected updatePrebuffer(sourceId: string, container: Container, state: PrebufferState): Promise<void>;
-    protected updateCameraSourcesState(): void;
-    protected updateCameraState(state: boolean): void;
-    protected cameraSourcePrebufferState(sourceId: string, container: Container): PrebufferState;
+    private isStateEvent;
     private createStateObservable;
-    protected createPrebufferStateObservable(sourceId: string, container: Container): Observable<PrebufferState>;
-    protected stateChanged<T extends keyof SetValues>(oldState?: SetValues[T], newState?: SetValues[T], type?: keyof StateValues): boolean;
-    protected isStateEvent(state: States | Sets): state is States;
 }
-export {};

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

@@ -6,6 +6,5 @@ export declare class CameraInterface extends CameraDelegate {
     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

@@ -21,8 +21,7 @@ export interface FfmpegOptions {
 }
 export type Container = 'mp4' | 'mpegts';
 export interface BasePrebufferState {
-    maxDuration: number;
-    availableDuration: number;
+    duration: number;
 }
 export interface PrebufferStateTrue extends BasePrebufferState {
     state: true;
@@ -180,7 +179,6 @@ 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 {
     abstract getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;

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

@@ -1,5 +1,5 @@
-import type { NatsConnection } from 'nats';
 import type { DecoderFormat, FrameBuffer, FrameData, FrameImage, FrameMetadata, ImageOptions, MotionFrame as MotionFrameMethods, VideoFrame as VideoFrameMethods } from '../decoder/types.js';
+import type { ProxyConnection } from '../nats/connection.js';
 import type { MotionState } from './types.js';
 export declare class VideoFrame implements VideoFrameMethods {
     readonly frameData: FrameData;
@@ -10,7 +10,7 @@ export declare class VideoFrame implements VideoFrameMethods {
     get inputWidth(): number;
     get inputHeight(): number;
     get inputFormat(): DecoderFormat;
-    constructor(cameraId: string, publisher: NatsConnection, frameData: FrameData, metadata: FrameMetadata, prebufferDuration: number);
+    constructor(cameraId: string, publisher: ProxyConnection, frameData: FrameData, metadata: FrameMetadata, prebufferDuration: number);
     toBuffer(options?: ImageOptions): Promise<FrameBuffer>;
     toImage(options?: ImageOptions): Promise<FrameImage>;
     save(path: string, options?: ImageOptions): Promise<void>;
@@ -20,5 +20,5 @@ export declare class VideoFrame implements VideoFrameMethods {
 }
 export declare class MotionFrame extends VideoFrame implements MotionFrameMethods {
     readonly motion: MotionState;
-    constructor(cameraId: string, publisher: NatsConnection, frameData: FrameData, motionState: MotionState, metadata: FrameMetadata);
+    constructor(cameraId: string, publisher: ProxyConnection, frameData: FrameData, motionState: MotionState, metadata: FrameMetadata);
 }

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

@@ -1,4 +1,3 @@
-import type { ChildProcess } from 'node:child_process';
 import type { Sharp } from 'sharp';
 import type { MotionState } from '../camera/types.js';
 export type DecoderFormat = 'yuv' | 'rgb';
@@ -7,9 +6,7 @@ export interface ImageMetadata {
     height: number;
 }
 export interface AudioMetadata {
-    channels: number;
-    sampleRate: number;
-    format: string;
+    mimeType: 'audio/mpeg' | 'audio/wav' | 'audio/ogg';
 }
 export interface FrameMetadata {
     format: DecoderFormat;
@@ -72,10 +69,9 @@ export interface VideoFrame {
 export interface MotionFrame extends VideoFrame {
     motion: MotionState;
 }
-export interface VideoSession {
-    isActive(): boolean;
-    kill: (reason?: string) => void;
-    cp: ChildProcess;
+export interface AuthConfig {
+    user: string;
+    password: string;
 }
 export interface BaseFrameWorkerConfig {
     frameWorkerId: string;
@@ -84,10 +80,7 @@ export interface BaseFrameWorkerConfig {
     ffmpegPath: string;
     logLevel: string;
     disableTimestamps: boolean;
-    auth: {
-        user: string;
-        pass: string;
-    };
+    auth: AuthConfig;
     proxyEndpoints: string[];
     fps: number;
     resolution: number;

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

@@ -1,6 +1,7 @@
 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;
     name: string;
@@ -24,10 +25,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 +34,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 { 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 { ProxyConnection } from './connection.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/deviceManager.d.ts

@@ -7,8 +7,8 @@ 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>;

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,5 +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>;

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 } 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;
 }