@camera.ui/browser 0.0.69 → 0.0.71

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

@@ -0,0 +1,27 @@
+import { CameraDevice } from './base/cameraDevice.js';
+import type { Camera } from '../api/database/types.js';
+import type { Frame } from '../decoder/types.js';
+import type { ProxyServer } from '../nats/index.js';
+import type { IceServer } from '../services/config/types.js';
+import type { BaseLogger } from './types.js';
+export declare class CameraController extends CameraDevice {
+    private proxy;
+    private motionTimeout?;
+    private doorbellTimeout?;
+    private doorbellTimeoutDuration;
+    constructor(camera: Camera, logger: BaseLogger, proxy: ProxyServer);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    reboot(): Promise<void>;
+    generateFrames(): AsyncIterableIterator<Frame>;
+    getFfmpegPath(): Promise<string>;
+    getIceServers(): Promise<IceServer[]>;
+    updateCamera(updatedCamera: Camera): void;
+    cleanup(): void;
+    private subscribeToCameraState;
+    private subscribeToMotionState;
+    private subscribeToDoorbellState;
+    private subscribeToCameraChanges;
+    private subscribeToStateChanges;
+    private triggerProxyEvent;
+}

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

@@ -100,25 +100,31 @@ export type CameraConfig = (BaseCameraConfig & {
 }) | (BaseCameraConfig & {
     delegate?: CameraDelegate;
 });
-export interface BaseState {
-    timestamp: number;
-    lastTriggered: number;
-}
-export interface Detections {
+export interface BaseDetection {
     id?: string;
-    label?: string;
+}
+export interface MotionDetection extends BaseDetection {
+    label: string;
     boundingBox: [number, number, number, number];
 }
+export interface ObjectDetection extends BaseDetection {
+    lebel: string;
+    boundingBox: [number, number, number, number];
+}
+export interface BaseState<T extends LightState | AudioState | MotionState | ObjectState | SirenState | BatteryState | DoorbellState> {
+    timestamp: number;
+    lastEvent?: Omit<T, 'lastEvent'>;
+}
 export interface MotionSetEvent {
     state: boolean;
-    detections: Detections[];
+    detections: MotionDetection[];
 }
 export interface AudioSetEvent {
     state: boolean;
+    db?: number;
 }
 export interface ObjectSetEvent {
-    state: boolean;
-    detections: Detections[];
+    detections: ObjectDetection[];
 }
 export interface LightSetEvent {
     state: boolean;
@@ -128,19 +134,20 @@ export interface DoorbellSetEvent {
 }
 export interface SirenSetEvent {
     state: boolean;
+    level?: number;
 }
 export interface BatterySetEvent {
-    state: number;
-}
-export interface DeviceSetEvent {
-}
-export type LightState = BaseState & LightSetEvent;
-export type MotionState = BaseState & MotionSetEvent;
-export type AudioState = BaseState & AudioSetEvent;
-export type DoorbellState = BaseState & DoorbellSetEvent;
-export type SirenState = BaseState & SirenSetEvent;
-export type ObjectState = BaseState & ObjectSetEvent;
-export type BatteryState = BaseState & BatterySetEvent;
+    level: number;
+    lowBattery?: boolean;
+    charging?: boolean;
+}
+export type LightState = BaseState<LightState> & LightSetEvent;
+export type MotionState = BaseState<MotionState> & MotionSetEvent;
+export type AudioState = BaseState<AudioState> & AudioSetEvent;
+export type DoorbellState = BaseState<DoorbellState> & DoorbellSetEvent;
+export type SirenState = BaseState<SirenState> & SirenSetEvent;
+export type ObjectState = BaseState<ObjectState> & ObjectSetEvent;
+export type BatteryState = BaseState<BatteryState> & BatterySetEvent;
 export type State = LightState | MotionState | AudioState | ObjectState | DoorbellState | SirenState | BatteryState;
 export interface StateValues {
     light: LightState;
@@ -151,9 +158,18 @@ export interface StateValues {
     siren: SirenState;
     battery: BatteryState;
 }
+export interface SetValues {
+    light: LightSetEvent;
+    motion: MotionSetEvent;
+    audio: AudioSetEvent;
+    object: ObjectSetEvent;
+    doorbell: DoorbellSetEvent;
+    siren: SirenSetEvent;
+    battery: BatterySetEvent;
+}
 export type CameraStateCallbacks = {
     [K in keyof StateValues]: (event: StateValues[K]) => void;
 };
 export type StateValue<T extends keyof StateValues> = StateValues[T];
-export type OnSetEvent<T extends keyof StateValues> = T extends 'light' ? LightSetEvent : T extends 'motion' ? MotionSetEvent : T extends 'audio' ? AudioSetEvent : T extends 'doorbell' ? DoorbellSetEvent : T extends 'siren' ? SirenSetEvent : T extends 'battery' ? BatterySetEvent : ObjectSetEvent;
+export type SetValue<T extends keyof SetValues> = SetValues[T];
 export type OnChangeCallback<T extends keyof StateValues> = (newEvent: StateValues[T], oldEvent: StateValues[T]) => void;

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

@@ -0,0 +1,11 @@
+import type { CameraController } from '../camera/controller.js';
+import type { StreamManager } from './worker/index.js';
+export declare class Decoder {
+    streamManagers: Map<string, StreamManager<any>>;
+    private api;
+    private proxyServer;
+    private startAsWorker;
+    constructor();
+    addCamera(camera: CameraController): Promise<StreamManager>;
+    removeCamera(camera: CameraController): Promise<void>;
+}

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

@@ -7,6 +7,10 @@ export interface FrameMetadata {
     width: number;
     height: number;
 }
+export interface FrameSession {
+    token: string;
+    wsPort: number;
+}
 export interface Frame {
     metadata: FrameMetadata;
     data: Buffer;

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

@@ -0,0 +1,3 @@
+export { StreamManager } from './runtime/base/index.js';
+export { StreamProcess } from './runtime/child-process/index.js';
+export { StreamWorker } from './runtime/worker-thread/index.js';

package/dist/types/server/src/decoder/worker/runtime/base/index.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Subscribed } from '../../../../camera/utils/subscribed.js';
+import type { ChildProcess } from 'node:child_process';
+import type { Worker } from 'node:worker_threads';
+import type { CameraController } from '../../../../camera/controller.js';
+import type { ConfigService } from '../../../../services/config/index.js';
+import type { Logger } from '../../../../services/logger/index.js';
+import type { FrameMetadata, MainMessage, MainToWorkerMessage, MainToWorkerResponse, WorkerToMainMessage } from '../../../types.js';
+export declare abstract class StreamManager<T extends Worker | ChildProcess = any> extends Subscribed {
+    token: string;
+    protected readonly logger: Logger;
+    protected readonly configService: ConfigService;
+    protected readonly camera: CameraController;
+    protected frameWorker?: T;
+    protected stopped: boolean;
+    protected auth: {
+        user: string;
+        pass: string;
+    };
+    constructor(camera: CameraController, auth: {
+        user: string;
+        pass: string;
+    });
+    abstract listen(): Promise<void>;
+    abstract close(): Promise<void>;
+    abstract workerPID(): number;
+    getMetadata(): Promise<FrameMetadata>;
+    startVideoSession(): Promise<void>;
+    stopVideoSession(): Promise<void>;
+    protected onMessage(workerMessage: WorkerToMainMessage): Promise<void>;
+    protected abstract sendMessage(message: MainMessage, skipResponse?: boolean, data?: Record<string, any>): Promise<any>;
+    protected abstract sendReponse(response: MainToWorkerResponse): void;
+    protected abstract send(message: MainToWorkerMessage | MainToWorkerResponse): void;
+    protected getLogPrefix(): string;
+}

package/dist/types/server/src/decoder/worker/runtime/child-process/index.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" resolution-mode="require"/>
+import { ChildProcess } from 'node:child_process';
+import { StreamManager } from '../base/index.js';
+import type { CameraController } from '../../../../camera/controller.js';
+import type { MainMessage, MainToWorkerMessage, MainToWorkerResponse } from '../../../types.js';
+export declare class StreamProcess extends StreamManager<ChildProcess> {
+    constructor(camera: CameraController, auth: {
+        user: string;
+        pass: string;
+    });
+    listen(): Promise<void>;
+    close(): Promise<void>;
+    workerPID(): number;
+    protected sendMessage(message: MainMessage, skipResponse?: boolean, data?: Record<string, any>): Promise<any>;
+    protected sendReponse(response: MainToWorkerResponse): void;
+    protected send(message: MainToWorkerMessage | MainToWorkerResponse): void;
+}

package/dist/types/server/src/decoder/worker/runtime/worker-thread/index.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Worker } from 'node:worker_threads';
+import { StreamManager } from '../base/index.js';
+import type { CameraController } from '../../../../camera/controller.js';
+import type { MainMessage, MainToWorkerMessage, MainToWorkerResponse } from '../../../types.js';
+export declare class StreamWorker extends StreamManager<Worker> {
+    private channel1;
+    private channel2;
+    private messageFromMain;
+    private messageToMain;
+    private responseToMain;
+    constructor(camera: CameraController, auth: {
+        user: string;
+        pass: string;
+    });
+    listen(): Promise<void>;
+    close(): Promise<void>;
+    workerPID(): number;
+    protected sendMessage(message: MainMessage, skipResponse?: boolean, data?: Record<string, any>): Promise<any>;
+    protected sendReponse(response: MainToWorkerResponse): void;
+    protected send(message: MainToWorkerMessage | MainToWorkerResponse): void;
+}

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

@@ -0,0 +1,25 @@
+import { RUNTIME_STATUS } from '../services/config/types.js';
+export declare class Go2Rtc {
+    private go2rtcProcess?;
+    private api;
+    private logger;
+    private configService;
+    version: string;
+    os: string;
+    private started;
+    private restarting;
+    private manuallyKilled;
+    private shuttingDown;
+    private _status;
+    get status(): RUNTIME_STATUS;
+    constructor();
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    restart(): Promise<void>;
+    getPID(): number;
+    private kill;
+    private handleClose;
+    private setStatus;
+    private processLogger;
+    private isIgnorableString;
+}

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

@@ -0,0 +1 @@
+export declare const NATS_SERVER_SUBJECT = "camera.ui-server";

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

@@ -0,0 +1,34 @@
+import { type NatsConnection, type Subscription } from 'nats';
+import { CameraDeviceProxy } from './proxy/cameraDevice.js';
+import { DeviceManagerProxy, PluginsManagerProxy, SystemManagerProxy } from './proxy/index.js';
+import { NatsServer } from './server.js';
+import type { StateValues } from '../camera/types.js';
+import type { CameraDeviceListenerMessagePayload, DeviceManagerProxyEvents, PluginsManagerProxyEvents, ProxyAuth, SystemManagerProxyEvents } 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 messageQueue;
+    private initialized;
+    auth: ProxyAuth;
+    constructor();
+    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;
+    private isCameraState;
+}

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

@@ -0,0 +1,96 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Camera } from '../../api/database/types.js';
+import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions, PrebufferType, SetValues, StateValues, StreamInfo } from '../../camera/types.js';
+import type { FrameMetadata, FrameSession } from '../../decoder/types.js';
+import type { IceServer } from '../../services/config/types.js';
+import type { MessageQueue } from '../queue.js';
+import type { CameraDeviceProxyMethods, ProxyMessageStructure } from '../types.js';
+export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
+    private api;
+    private configService;
+    private camerasService;
+    private pluginsService;
+    private socketService;
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
+    connect(data: {
+        cameraId: string;
+        pluginId: string;
+    }): void;
+    disconnect(data: {
+        cameraId: string;
+        pluginId: string;
+    }): void;
+    reboot(data: {
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    getStreamInfo(data: {
+        sourceName: string;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<StreamInfo | undefined>;
+    isPrebuffering(data: {
+        sourceName: string;
+        type: PrebufferType;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<boolean>;
+    getPrebufferRawUrl(data: {
+        sourceName: string;
+        type: PrebufferType;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<string | undefined>;
+    getFrameMetadata(data: {
+        cameraId: string;
+        pluginId: string;
+    }): Promise<FrameMetadata>;
+    getFrameSession(data: {
+        cameraId: string;
+        pluginId: string;
+    }): Promise<FrameSession>;
+    getFfmpegPath(): string;
+    getIceServers(): IceServer[];
+    snapshot(data: {
+        forceNew?: boolean;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<ArrayBuffer>;
+    streamVideo(data: {
+        sourceName: string;
+        options: FfmpegOptions;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    recordToFile(data: {
+        sourceName: string;
+        outputPath: string;
+        duration?: number;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    updateState<T extends keyof SetValues>(data: {
+        stateName: T;
+        eventData: SetValues[T];
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    refreshStates(data: {
+        cameraId: string;
+        pluginId: string;
+    }): {
+        camera: Camera;
+        states: StateValues;
+        cameraState: boolean;
+    };
+    onRequestReboot(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['reboot']>): Promise<Buffer>;
+    onRequestGetStreamInfo(pluginId: string, cameraId: string, ...args: Parameters<CameraPrebufferDelegate['getStreamInfo']>): Promise<StreamInfo | undefined>;
+    onRequestIsPrebuffering(pluginId: string, cameraId: string, ...args: Parameters<CameraPrebufferDelegate['isPrebuffering']>): Promise<boolean>;
+    onRequestGetRawUrl(pluginId: string, cameraId: string, ...args: Parameters<CameraPrebufferDelegate['getPrebufferRawUrl']>): Promise<string | undefined>;
+    onRequestSnapshotRequest(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['snapshotRequest']>): Promise<Buffer>;
+    onRequestPrepareStream(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['prepareStream']>): Promise<void>;
+    onRequestWebRTCOffer(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['onOffer']>): Promise<string>;
+    onRequestWebRTCIceCandidates(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['onCandidates']>): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
+}

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

@@ -0,0 +1,31 @@
+import type { Camera } from '../../api/database/types.js';
+import type { CameraConfig } from '../../camera/types.js';
+import type { MessageQueue } from '../queue.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>;
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
+}

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

@@ -0,0 +1,4 @@
+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/proxy/pluginsManager.d.ts

@@ -0,0 +1,12 @@
+import type { BasePlugin } from '../../plugins/base.js';
+import type { CameraStorage } from '../../plugins/node/cameraStorage.js';
+import type { MessageQueue } from '../queue.js';
+import type { CallablePluginMethods, CallablePluginStorageMethods, PluginsManagerServerProxyMethods, ProxyMessageStructure } from '../types.js';
+export declare class PluginsManagerProxy implements PluginsManagerServerProxyMethods {
+    private pluginsService;
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
+    onRequestPluginFn<K extends keyof CallablePluginMethods>(pluginId: string, fn: K, ...args: Parameters<BasePlugin[K]>): Promise<ReturnType<BasePlugin[K]>>;
+    onRequestStorageFn<K extends keyof CallablePluginStorageMethods>(pluginId: string, cameraId: string, fn: K, ...args: Parameters<CameraStorage[K]>): Promise<Awaited<ReturnType<CameraStorage[K]>>>;
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import type { MessageQueue } from '../queue.js';
+import type { ProxyMessageStructure, SystemManagerServerProxyMethods } from '../types.js';
+export declare class SystemManagerProxy implements SystemManagerServerProxyMethods {
+    private pluginsService;
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
+}

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

@@ -0,0 +1,17 @@
+import type { ProxyServer } from './index.js';
+import type { ProxyMessageStructure } from './types.js';
+export declare class MessageQueue {
+    private logger;
+    private proxyServer;
+    private publisher;
+    private subscriber;
+    private aborted;
+    private isProcessing;
+    private queue;
+    private pendingResponses;
+    constructor(proxyServer: ProxyServer);
+    abortQueue(): void;
+    enqueue(message: ProxyMessageStructure): Promise<any>;
+    private processQueue;
+    private listenToMessages;
+}

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

@@ -0,0 +1,33 @@
+import { RUNTIME_STATUS } from '../services/config/types.js';
+import type { ProxyAuth } from './types.js';
+export declare class NatsServer {
+    readonly serverPort = 4222;
+    readonly websocketPort = 8223;
+    private readonly clusterAmount;
+    private readonly serverClusterPort;
+    private readonly auth;
+    private serverProcess?;
+    private clusterProcesses;
+    private logger;
+    private configService;
+    private tmpDir;
+    private manuallyKilled;
+    private shuttingDown;
+    private _status;
+    get status(): RUNTIME_STATUS;
+    constructor(auth: ProxyAuth);
+    start(): Promise<void>;
+    private startServer;
+    private startClusterServer;
+    private setupProcess;
+    stop(): Promise<void>;
+    restart(): Promise<void>;
+    getPID(): number;
+    private writeConfigFile;
+    private stringifyConfig;
+    private kill;
+    private handleClose;
+    private setStatus;
+    private processLogger;
+    private isIgnorableString;
+}

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

@@ -1,8 +1,10 @@
 import type { Camera } from '../api/database/types.js';
 import type { CameraDevice } from '../camera/base/cameraDevice.js';
 import type { BrowserCameraDevice } from '../camera/base/cameraDeviceBrowser.js';
-import type { CameraConfig, FfmpegOptions, OnSetEvent, PrebufferType, StateValues, StreamInfo } from '../camera/types.js';
-import type { FrameMetadata } from '../decoder/types.js';
+import type { CameraConfig, FfmpegOptions, PrebufferType, SetValues, StateValues, StreamInfo } from '../camera/types.js';
+import type { FrameMetadata, FrameSession } from '../decoder/types.js';
+import type { BasePlugin } from '../plugins/base.js';
+import type { CameraStorage } from '../plugins/node/cameraStorage.js';
 import type { CameraExtension } from '../plugins/types.js';
 import type { IceServer } from '../services/config/types.js';
 export type MethodKeys<T> = {
@@ -60,11 +62,11 @@ export interface DeviceManagerServerProxyMethods {
     getCameraByName(data: {
         name: string;
         pluginId: string;
-    }): Promise<Camera | undefined>;
+    }): Camera | void;
     getCameraById(data: {
         id: string;
         pluginId: string;
-    }): Promise<Camera | undefined>;
+    }): Camera | void;
     removeCameraByName(data: {
         name: string;
         pluginId: string;
@@ -82,11 +84,11 @@ export interface CameraDeviceProxyMethods {
     connect(data: {
         cameraId: string;
         pluginId: string;
-    }): Promise<void>;
+    }): void;
     disconnect(data: {
         cameraId: string;
         pluginId: string;
-    }): Promise<void>;
+    }): void;
     reboot(data: {
         cameraId: string;
         pluginId: string;
@@ -112,6 +114,10 @@ export interface CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): Promise<FrameMetadata>;
+    getFrameSession(data: {
+        cameraId: string;
+        pluginId: string;
+    }): Promise<FrameSession>;
     getFfmpegPath(data: {
         cameraId: string;
         pluginId: string;
@@ -138,20 +144,20 @@ export interface CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): Promise<void>;
-    updateState<T extends keyof StateValues>(data: {
+    updateState<T extends keyof SetValues>(data: {
         stateName: T;
-        eventData: OnSetEvent<T>;
+        eventData: SetValues[T];
         cameraId: string;
         pluginId: string;
     }): void;
     refreshStates(data: {
         cameraId: string;
         pluginId: string;
-    }): Promise<{
+    }): {
         camera: Camera;
         states: StateValues;
         cameraState: boolean;
-    }>;
+    };
 }
 export type CameraDeviceProxyMethodNames = MethodKeys<CameraDeviceProxyMethods>;
 export interface DeviceManagerListenerMessagePayload {
@@ -235,6 +241,8 @@ export interface PluginsManagerProxyGenericEvent<K extends keyof PluginsManagerP
     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: {

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

@@ -0,0 +1,4 @@
+export declare function generateSecureCredentials(): {
+    user: string;
+    pass: string;
+};

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

@@ -0,0 +1,22 @@
+import type { Namespace, Server } from 'socket.io';
+import type { SocketNsp } from '../api/websocket/types.js';
+import type { StateValues } from '../camera/types.js';
+import type { CameraDeviceListenerMessagePayload } from './types.js';
+export declare class WebsocketProxy {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private proxy;
+    constructor(io: Server);
+    init(): void;
+    publishCameraEvent<K extends keyof StateValues>(cameraId: string, stateName: K, data: {
+        newEvent: StateValues[K];
+        oldEvent: StateValues[K];
+    }): void;
+    publishCameraEvent(cameraId: string, type: CameraDeviceListenerMessagePayload['type'], data?: any): void;
+    private setupEventListeners;
+    private isSystemManagerMethod;
+    private isDeviceManagerMethod;
+    private isPluginsManagerMethod;
+    private isCameraManagerMethod;
+    private isCameraState;
+}

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

@@ -0,0 +1,7 @@
+import type { CameraDevice } from '../camera/base/cameraDevice.js';
+export declare abstract class BasePlugin {
+    abstract onFormSubmit(actionId: string, payload: any): Promise<{
+        toast?: string;
+    }>;
+    abstract configureCameras(cameras: CameraDevice[]): Promise<void>;
+}

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

@@ -0,0 +1,31 @@
+import 'reflect-metadata';
+import { Plugin } from './plugin.js';
+import { PluginWorker } from './worker.js';
+import type { IPackageJson } from '../api/types/index.js';
+export declare class PluginManager {
+    private logger;
+    private api;
+    private configService;
+    private pythonVersionsToInstall;
+    plugins: Map<string, Plugin>;
+    pluginWorkers: Map<string, PluginWorker>;
+    searchPaths: Set<string>;
+    constructor();
+    static isQualifiedPluginIdentifier(pluginName: string): boolean;
+    static extractPluginScope(pluginName: string): string;
+    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>;
+    startPluginChild(pluginName: string): Promise<void>;
+    stopPluginChild(pluginName: string): Promise<void>;
+    initializePlugins(): Promise<void>;
+    installRequiredPythonEnvs(): Promise<void>;
+    private loadInstalledPlugins;
+    private removeOrphanedPlugins;
+    private loadDefaultPaths;
+    private addNpmPrefixToSearchPaths;
+}