@camera.ui/browser 0.0.81 → 0.0.83

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

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

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

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

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

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

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

@@ -3,10 +3,10 @@ import { EventEmitter } from 'node:events';
 import { CameraController } from './camera/controller.js';
 import type { Camera, CameraExtensions } from './api/database/types.js';
 import type { FrameWorker } from './decoder/worker.js';
-import type { BasePlugin } from './plugins/base.js';
+import type { BasePlugin } from './plugins/interfaces/base.js';
 import type { CameraExtension } from './plugins/types.js';
-import type { API } from './polyglot/node/plugins/api.js';
-import type { PluginLogger } from './polyglot/node/plugins/logger.js';
+import type { API } from './polyglot/node/plugins/pluginApi.js';
+import type { PluginLogger } from './polyglot/node/plugins/pluginLogger.js';
 export interface PluginConstructor {
     new (logger: PluginLogger, api: API): BasePlugin;
 }

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

@@ -1,14 +1,12 @@
-import { BaseCameraDevice } from './index.js';
-import { CameraAudioDetectionInterface } from './interfaces/audioDetection.js';
-import { CameraMotionDetectionInterface } from './interfaces/motionDetection.js';
-import { CameraObjectDetectionInterface } from './interfaces/objectDetection.js';
+import { CameraDevice } from './device.js';
 import { CameraPrebufferInterface } from './interfaces/prebuffer.js';
 import { CameraPTZInterface } from './interfaces/ptz.js';
 import type { Camera } from '../api/database/types.js';
+import type { MotionFrame, VideoFrame } from '../decoder/types.js';
 import type { ProxyServer } from '../nats/index.js';
 import type { IceServer } from '../services/config/types.js';
 import type { BaseLogger, CameraConfigInputSettings, CameraDelegate, CameraSource, SetValues } from './types.js';
-export declare class CameraController extends BaseCameraDevice {
+export declare class CameraController extends CameraDevice {
     proxy: ProxyServer;
     private motionTimeout?;
     private objectTimeout?;
@@ -16,15 +14,16 @@ export declare class CameraController extends BaseCameraDevice {
     private doorbellTimeout?;
     private doorbellTimeoutDuration;
     private prebufferStateSubscriptions;
-    cameraDelegate: CameraDelegate;
-    prebufferDelegate: CameraPrebufferInterface;
-    ptzDelegate: CameraPTZInterface;
-    audioDetectorDelegate: CameraAudioDetectionInterface;
-    motionDetectorDelegate: CameraMotionDetectionInterface;
-    objectDetectorDelegate: CameraObjectDetectionInterface;
+    protected cameraDelegate: CameraDelegate;
+    protected ptzDelegate: CameraPTZInterface;
+    protected prebufferDelegate: CameraPrebufferInterface;
     get camera(): Camera;
     get sources(): CameraSource[];
     constructor(camera: Camera, logger: BaseLogger, proxy: ProxyServer);
+    setDelegate(): void;
+    getFfmpegPath(): Promise<string>;
+    getFrames(): AsyncIterableIterator<VideoFrame>;
+    getMotionFrames(): AsyncIterableIterator<MotionFrame>;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     getIceServers(): Promise<IceServer[]>;
@@ -42,5 +41,6 @@ export declare class CameraController extends BaseCameraDevice {
     private subscribeToObjectState;
     private subscribeToDoorbellState;
     private triggerProxyEvent;
+    private proxyRequest;
     private isCameraEvent;
 }

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

@@ -4,15 +4,27 @@ import { WeriftSession } from './streaming/werift-session.js';
 import type { Observable } from 'rxjs';
 import type { MotionFrame, VideoFrame } from '../decoder/types.js';
 import type { StreamingConnectionOptions } from './streaming/peer-connection.js';
-import type { CameraDelegates, FrameState } from './types.js';
+import type { AudioSetEvent, BatterySetEvent, CameraConfigInputSettings, CameraDelegates, DoorbellSetEvent, FrameState, LightSetEvent, MotionSetEvent, ObjectSetEvent, SirenSetEvent } from './types.js';
 export declare abstract class CameraDevice extends BaseCameraDevice {
     protected readonly frameState: BehaviorSubject<FrameState>;
     protected readonly onFrame: Observable<FrameState>;
     abstract setDelegate<T extends keyof CameraDelegates>(name: T, delegate: CameraDelegates[T]): void;
-    createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<WeriftSession>;
-    removeAllListeners(): void;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
     abstract getFrames(prebufferDuration?: number): AsyncIterableIterator<VideoFrame>;
     abstract getMotionFrames(): AsyncIterableIterator<MotionFrame>;
     abstract getFfmpegPath(): Promise<string>;
+    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>;
+    createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<WeriftSession>;
+    protected removeAllListeners(): void;
     private createMotionFrameObservable;
 }

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, CameraAudioDetectionDelegate, CameraConfigInputSettings, CameraDelegate, CameraMotionDetectionDelegate, CameraObjectDetectionDelegate, CameraPTZDelegate, CameraPrebufferDelegate, CameraSource, Container, DetectionZone, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, PrebufferState, SetValues, Sets, SirenSetEvent, SirenState, StateValues, States } from './types.js';
-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,12 +30,9 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     readonly onDoorbellPressed: Observable<DoorbellState>;
     readonly onSirenDetected: Observable<SirenState>;
     readonly onBatteryChanged: Observable<BatteryState>;
-    abstract cameraDelegate: CameraDelegate;
-    abstract prebufferDelegate: CameraPrebufferDelegate;
-    abstract ptzDelegate: CameraPTZDelegate;
-    abstract motionDetectorDelegate: CameraMotionDetectionDelegate;
-    abstract audioDetectorDelegate: CameraAudioDetectionDelegate;
-    abstract objectDetectorDelegate: CameraObjectDetectionDelegate;
+    protected abstract cameraDelegate: CameraDelegate;
+    protected abstract ptzDelegate: CameraPTZDelegate;
+    protected abstract prebufferDelegate: CameraPrebufferDelegate;
     protected get cameraObject(): Camera;
     get id(): string;
     get nativeId(): string | undefined;
@@ -66,43 +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;
-    get recordingSource(): CameraSource;
-    get detectionSource(): 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;
@@ -110,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

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

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

@@ -1,10 +1,7 @@
 import type { Observable } from 'rxjs';
 import type { CameraInformation, CameraInput, CameraInputSettings, Point, ZoneFilter, ZoneType } from '../api/database/types.js';
 import type { FrameData, FrameMetadata } from '../decoder/types.js';
-import type { CameraAudioDetectionInterface } from './interfaces/audioDetection.js';
 import type { CameraInterface } from './interfaces/camera.js';
-import type { CameraMotionDetectionInterface } from './interfaces/motionDetection.js';
-import type { CameraObjectDetectionInterface } from './interfaces/objectDetection.js';
 import type { CameraPrebufferInterface } from './interfaces/prebuffer.js';
 import type { CameraPTZInterface } from './interfaces/ptz.js';
 export interface BaseLogger {
@@ -24,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;
@@ -182,7 +178,7 @@ export type StateValue<T extends keyof StateValues> = StateValues[T];
 export type SetValue<T extends keyof SetValues> = SetValues[T];
 export type OnChangeCallback<T extends keyof StateValues> = (newEvent: StateValues[T], oldEvent: StateValues[T]) => void;
 export declare abstract class CameraDelegate {
-    abstract reboot(): Promise<void>;
+    abstract snapshot(): Promise<ArrayBuffer>;
 }
 export declare abstract class CameraPrebufferDelegate {
     abstract getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;
@@ -193,28 +189,13 @@ export declare abstract class CameraPTZDelegate {
     abstract moveContinuous(pan: number, tilt: number, zoom: number): Promise<void>;
     abstract stop(): Promise<void>;
 }
-export declare abstract class CameraMotionDetectionDelegate {
-    abstract detectImage(image: Buffer): Promise<Detection[]>;
-}
-export declare abstract class CameraObjectDetectionDelegate {
-    abstract detectImage(image: Buffer): Promise<Detection[]>;
-}
-export declare abstract class CameraAudioDetectionDelegate {
-    abstract detectAudio(audio: Buffer): Promise<boolean>;
-}
 export interface CameraInterfaces {
     readonly cameraDelegate: CameraInterface;
     readonly prebufferDelegate: CameraPrebufferInterface;
     readonly ptzDelegate: CameraPTZInterface;
-    readonly motionDetectorDelegate: CameraMotionDetectionInterface;
-    readonly objectDetectorDelegate: CameraObjectDetectionInterface;
-    readonly audioDetectorDelegate: CameraAudioDetectionInterface;
 }
 export interface CameraDelegates {
     readonly cameraDelegate: CameraDelegate;
     readonly prebufferDelegate: CameraPrebufferDelegate;
     readonly ptzDelegate: CameraPTZDelegate;
-    readonly motionDetectorDelegate: CameraMotionDetectionDelegate;
-    readonly objectDetectorDelegate: CameraObjectDetectionDelegate;
-    readonly audioDetectorDelegate: CameraAudioDetectionDelegate;
 }

package/dist/types/server/src/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,7 +1,13 @@
-import type { ChildProcess } from 'node:child_process';
 import type { Sharp } from 'sharp';
 import type { MotionState } from '../camera/types.js';
 export type DecoderFormat = 'yuv' | 'rgb';
+export interface ImageMetadata {
+    width: number;
+    height: number;
+}
+export interface AudioMetadata {
+    mimeType: 'audio/mpeg' | 'audio/wav' | 'audio/ogg';
+}
 export interface FrameMetadata {
     format: DecoderFormat;
     frameSize: number;
@@ -30,7 +36,7 @@ export interface ImageOptions {
     crop?: ImageCrop;
     resize?: ImageResize;
 }
-export interface ProcessImageRequest {
+export interface ProcessPrebufferedImageRequest {
     frameData: FrameData;
     metadata: FrameMetadata;
     options: ImageOptions;
@@ -63,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;
@@ -75,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,21 +1,23 @@
 import { CameraDeviceProxy } from './proxy/cameraDevice.js';
-import { DeviceManagerProxy, PluginsManagerProxy, SystemManagerProxy } 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 { CameraDeviceListenerMessagePayload, DeviceManagerProxyEvents, PluginsManagerProxyEvents, ProxyAuth, SystemManagerProxyEvents } from './types.js';
+import type { CameraStorage } from '../polyglot/node/plugins/cameraStorage.js';
+import type { MethodKeys, MethodType } from '../types.js';
+import { 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 {
     private api;
     private logger;
     deviceManagerProxy?: DeviceManagerProxy;
-    pluginsManagerProxy?: PluginsManagerProxy;
-    systemManagerProxy?: SystemManagerProxy;
     cameraDeviceProxy?: CameraDeviceProxy;
     websocketProxy?: WebsocketProxy;
     server: NatsServer;
-    publisher?: NatsConnection;
-    subscriber?: Subscription;
+    publisher?: ProxyConnection;
+    subscriber?: ProxySubscription;
+    private pluginsService?;
     private messageQueue?;
     private initialized;
     auth: ProxyAuth;
@@ -23,12 +25,13 @@ export declare class ProxyServer {
     initialize(): Promise<void>;
     close(): Promise<void>;
     publishDeviceManagerEvent<K extends keyof DeviceManagerProxyEvents>(targetId: string, type: K, data: DeviceManagerProxyEvents[K]): void;
-    publishSystemManagerEvent<K extends keyof SystemManagerProxyEvents>(targetId: string, type: K, data: SystemManagerProxyEvents[K]): void;
-    publishPluginsManagerEvent<K extends keyof PluginsManagerProxyEvents>(targetId: string, type: K, data: PluginsManagerProxyEvents[K]): void;
     publishCameraEvent<K extends keyof StateValues>(cameraId: string, stateName: K, data: {
         newEvent: StateValues[K];
         oldEvent: StateValues[K];
     }, targetId?: string): void;
     publishCameraEvent(cameraId: string, type: CameraDeviceListenerMessagePayload['type'], data?: any, targetId?: string): void;
+    requestPluginFn<T extends keyof PluginMap, K extends MethodKeys<PluginMap[T]>>(pluginType: T, pluginId: string, fn: K, args: Parameters<MethodType<PluginMap[T], K>>, timeout?: number): Promise<Awaited<ReturnType<MethodType<PluginMap[T], K>>>>;
+    requestStorageFn<T extends MethodKeys<CameraStorage>>(pluginId: string, cameraId: string, fn: T, args: Parameters<MethodType<CameraStorage, T>>, timeout?: number): Promise<Awaited<ReturnType<MethodType<CameraStorage, T>>>>;
+    private requestHandler;
     private isCameraState;
 }

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

@@ -0,0 +1,20 @@
+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 type;
+    private publisher;
+    private subscriber;
+    private requestHandler;
+    private aborted;
+    private isProcessing;
+    private queue;
+    private pendingResponses;
+    constructor(type: 'server' | 'client', publisher: ProxyConnection, subscriber: ProxySubscription, logger: BaseLogger, requestHandler: (message: ProxyMessageStructure) => void);
+    abortQueue(): void;
+    enqueue(message: ProxyMessageStructure): Promise<any>;
+    private processQueue;
+    private onMessage;
+}