@camera.ui/browser 0.0.35 → 0.0.37

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

@@ -1,5 +1,4 @@
 import type { Camera } from '../api/database/types';
-import type { CameraDevice } from '../camera/types';
 export type PluginGraph = Map<string, string[]>;
 export type PluginCycles = Map<string, string[]>;
 export type PluginGroups = Map<string, string[]>;
@@ -7,18 +6,6 @@ export interface SchemaConfig {
     rootSchema: PluginRootSchema;
     config: Record<string, any>;
 }
-export interface CameraStorage {
-    setValue<T = string>(path: string, newValue: T): Promise<void>;
-    getValue<T = string>(path: string): T | Promise<T> | undefined;
-    getConfig(): Promise<SchemaConfig>;
-    setConfig(config: Record<string, any>): Promise<void>;
-}
-export interface BasePlugin {
-    onFormSubmit(actionId: string, payload: any): Promise<{
-        toast?: string;
-    } | void>;
-    configureCameras(cameras: CameraDevice[]): void;
-}
 export declare const PLUGIN_IDENTIFIER_PATTERN: RegExp;
 export type JSONValue = string | number | boolean | JSONObject | JSONArray;
 export interface JSONObject {
@@ -27,7 +14,7 @@ export interface JSONObject {
 export type JSONArray = JSONValue[];
 export type PluginConfig = Record<string, any>;
 export declare const CAMERA_EXTENSIONS: CameraExtension[];
-export type CameraExtension = 'hub' | 'prebuffer' | 'motionDetection' | 'objectDetection' | 'audioDetection' | 'ptz';
+export type CameraExtension = 'hub' | 'prebuffer' | 'motionDetection' | 'objectDetection' | 'audioDetection' | 'ptz' | 'intercom';
 type ExtensionOrSupport = {
     extension: CameraExtension;
     supportAdditionalCameras?: never;
@@ -80,7 +67,7 @@ export interface ProcessResponse {
 }
 export type JsonSchemaType = 'string' | 'number' | 'boolean' | 'object' | 'array';
 export interface JsonBaseSchema<T = any> {
-    type: string;
+    type: JsonSchemaType;
     key?: string;
     title?: string;
     description?: string;
@@ -124,14 +111,14 @@ export interface JsonSchemaBoolean extends JsonBaseSchema<boolean> {
 export interface PluginJsonSchemaBoolean extends PluginJsonBaseSchema<boolean> {
     type: 'boolean';
 }
-export interface JsonSchemaEnum extends JsonBaseSchema<string | number | boolean> {
-    type: 'string' | 'number' | 'boolean';
-    enum: (string | number | boolean)[];
+export interface JsonSchemaEnum extends JsonBaseSchema<string> {
+    type: 'string';
+    enum: string[];
     multiple?: boolean;
 }
-export interface PluginJsonSchemaEnum extends PluginJsonBaseSchema<string | number | boolean> {
-    type: 'string' | 'number' | 'boolean';
-    enum: (string | number | boolean)[];
+export interface PluginJsonSchemaEnum extends PluginJsonBaseSchema<string> {
+    type: 'string';
+    enum: string[];
     multiple?: boolean;
 }
 export interface JsonSchemaObject extends JsonBaseSchema {

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

@@ -8,13 +8,11 @@ export declare class PluginWorker {
     private configService;
     private socketService;
     private started;
-    private manuallyKilled;
     private shuttingDown;
     private _status;
     get status(): PLUGIN_STATUS;
     constructor(plugin: Plugin);
     start(): Promise<void>;
-    stop(): Promise<void>;
     teardown(): Promise<void>;
     restart(): Promise<void>;
     getPID(): number;

package/dist/src/proxy/client/cameraDevice.d.ts

@@ -1,26 +1,31 @@
-import { CameraDeviceHub } from '../../camera';
+import { CameraController } from '../../camera';
 import type { Camera } from '../../api/database/types';
-import type { StateValues, OnSetEvent, PrebufferType, CameraDelegate } from '../../camera/types';
 import type { IceServer } from '../../services/config/types';
-export declare class CameraDeviceClientProxy extends CameraDeviceHub {
-    private removed;
+import type { ZmqInfo } from '../../plugins/types';
+import type { PluginAPI } from '../../plugins/api';
+import type { StateValues, OnSetEvent, CameraSource } from '../../camera/types';
+export declare class CameraDeviceClientProxy extends CameraController {
     private api;
+    private logger;
     private dealer;
     private subscriber;
     private messageQueue;
     private dealerId;
-    private subscriberId;
+    private subscriberIds;
     private pluginID;
-    private close?;
-    constructor(camera: Camera, pluginId: string, pluginName: string, routerAddress: string, publisherAddress: string, serverPublicKey: string);
-    configureDelegate(delegate: CameraDelegate): void;
-    setPrebufferSource(sourceName: string, address: string | null, type: PrebufferType): Promise<void>;
-    removePrebufferSource(sourceName: string, type: 'recording' | 'stream'): Promise<void>;
-    removePrebufferSources(): Promise<void>;
+    private routerAddress;
+    private publisherAddress;
+    get sources(): CameraSource[];
+    constructor(api: PluginAPI, camera: Camera, pluginId: string, pluginName: string, proxy: ZmqInfo);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    reboot(): Promise<void>;
     getFfmpegPath(): Promise<string>;
     getIceServers(): Promise<IceServer[]>;
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): Promise<void>;
     refreshStates(): Promise<void>;
+    close(): void;
     private handleRouterRequest;
     private listenToSubscriberEvents;
     private onRequest;

package/dist/src/proxy/client/deviceManager.d.ts

@@ -1,23 +1,24 @@
 import { CameraDeviceClientProxy } from '../client/cameraDevice';
 import type { CameraConfig, CameraDevice } from '../../camera/types';
+import type { PluginLogger } from '../../services/logger';
+import type { ZmqInfo } from '../../plugins/types';
 import type { DeviceManagerProxyMethods, DeviceManagerProxyEventCallbacks, DeviceManagerProxyMethodsListener } from '../types';
+import { PluginAPI } from '../../plugins/api';
 export declare class DeviceManager implements DeviceManagerProxyMethods, DeviceManagerProxyMethodsListener {
     private api;
     private logger;
     private dealer;
     private subscriber;
     private messageQueue;
-    private routerAddress;
-    private publisherAddress;
-    private serverPublicKey;
+    private proxy;
     private pluginId;
     private pluginName;
     private dealerId;
-    private subscriberId;
+    private subscriberIds;
     private MAX_LISTENERS_PER_EVENT;
     private devices;
     private eventListeners;
-    constructor(pluginId: string, pluginName: string, routerAddress: string, publisherAddress: string, serverPublicKey: string, cameraDevices?: CameraDeviceClientProxy[]);
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, proxy: ZmqInfo);
     getCameraById(id: string): Promise<CameraDevice | undefined>;
     getCameraByName(name: string): Promise<CameraDevice | undefined>;
     createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
@@ -26,6 +27,7 @@ export declare class DeviceManager implements DeviceManagerProxyMethods, DeviceM
     listen<E extends keyof DeviceManagerProxyEventCallbacks>(eventType: E, callback: DeviceManagerProxyEventCallbacks[E]): void;
     removeListener<E extends keyof DeviceManagerProxyEventCallbacks>(eventType: E, callbackToRemove: DeviceManagerProxyEventCallbacks[E]): void;
     removeAllListeners<E extends keyof DeviceManagerProxyEventCallbacks>(eventType?: E): void;
+    configureCameras(cameraDevices: CameraDeviceClientProxy[]): void;
     private handleRouterRequest;
     private listenToSubscriberEvents;
     private onRequest;

package/dist/src/proxy/client/pluginsManager.d.ts

@@ -1,18 +1,20 @@
+import type { ZmqInfo } from '../../plugins/types';
+import type { PluginLogger } from '../../services/logger';
 import type { PluginsManagerProxyMethods, PluginsManagerProxyMethodsListener, PluginsManagerProxyEventCallbacks } from '../types';
+import type { PluginAPI } from '../../plugins/api';
 export declare class PluginsManager implements PluginsManagerProxyMethods, PluginsManagerProxyMethodsListener {
     private api;
     private logger;
-    private plugin?;
     private dealer;
     private subscriber;
     private messageQueue;
     private pluginId;
     private pluginName;
     private dealerId;
-    private subscriberId;
+    private subscriberIds;
     private MAX_LISTENERS_PER_EVENT;
     private eventListeners;
-    constructor(pluginId: string, pluginName: string, routerAddress: string, publisherAddress: string, serverPublicKey: string);
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, proxy: ZmqInfo);
     listen<E extends keyof PluginsManagerProxyEventCallbacks>(eventType: E, callback: PluginsManagerProxyEventCallbacks[E]): void;
     removeListener<E extends keyof PluginsManagerProxyEventCallbacks>(eventType: E, callbackToRemove: PluginsManagerProxyEventCallbacks[E]): void;
     removeAllListeners<E extends keyof PluginsManagerProxyEventCallbacks>(eventType?: E): void;

package/dist/src/proxy/client/queue.d.ts

@@ -4,10 +4,12 @@ export declare class ClientMessageQueue {
     private logger;
     private dealer;
     private requestHandler;
+    private aborted;
     private isProcessing;
     private queue;
     private pendingResponses;
     constructor(requestHandler: (message: ProxyMessageStructure) => void, dealer: Dealer);
+    abortQueue(): void;
     enqueue(message: ProxyMessageStructure): Promise<any>;
     private processQueue;
     private listenToRouter;

package/dist/src/proxy/client/systemManager.d.ts

@@ -1,4 +1,7 @@
 import type { SystemManagerProxyMethods, SystemManagerProxyMethodsListener, SystemManagerProxyEventCallbacks } from '../types';
+import type { PluginLogger } from '../../services/logger';
+import type { ZmqInfo } from '../../plugins/types';
+import { PluginAPI } from '../../plugins/api';
 export declare class SystemManager implements SystemManagerProxyMethods, SystemManagerProxyMethodsListener {
     private api;
     private logger;
@@ -8,10 +11,10 @@ export declare class SystemManager implements SystemManagerProxyMethods, SystemM
     private pluginId;
     private pluginName;
     private dealerId;
-    private subscriberId;
+    private subscriberIds;
     private MAX_LISTENERS_PER_EVENT;
     private eventListeners;
-    constructor(pluginId: string, pluginName: string, routerAddress: string, publisherAddress: string, serverPublicKey: string);
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, proxy: ZmqInfo);
     listen<E extends keyof SystemManagerProxyEventCallbacks>(eventType: E, callback: SystemManagerProxyEventCallbacks[E]): void;
     removeListener<E extends keyof SystemManagerProxyEventCallbacks>(eventType: E, callbackToRemove: SystemManagerProxyEventCallbacks[E]): void;
     removeAllListeners<E extends keyof SystemManagerProxyEventCallbacks>(eventType?: E): void;

package/dist/src/proxy/index.d.ts

@@ -23,7 +23,7 @@ export declare class ProxyServer {
     publishCameraEvent<K extends keyof StateValues>(cameraId: string, stateName: K, data: {
         newEvent: StateValues[K];
         oldEvent: StateValues[K];
-    }): Promise<void>;
-    publishCameraEvent(cameraId: string, type: CameraDeviceListenerMessagePayload['type'], data?: any): Promise<void>;
+    }, targetId?: string): Promise<void>;
+    publishCameraEvent(cameraId: string, type: CameraDeviceListenerMessagePayload['type'], data?: any, targetId?: string): Promise<void>;
     private isCameraState;
 }

package/dist/src/proxy/proxies/camera.d.ts

@@ -1,11 +1,10 @@
 /// <reference types="pouchdb-core" />
 /// <reference types="node" />
-import type { OnSetEvent, StateValues } from '../../camera/types';
+import type { OnSetEvent, StateValues, StreamInfo } from '../../camera/types';
 import type { IceServer } from '../../services/config/types';
-import type { FfmpegOptions, PrebufferType, CameraDelegate } from '../../camera/types';
+import type { FfmpegOptions, CameraDelegate, CameraPrebufferDelegate, PrebufferType } from '../../camera/types';
 import type { CameraDeviceProxyMethods, ProxyMessageStructure } from '../types';
 import type { MessageQueue } from '../queue';
-import type { CameraDeviceHub } from '../../camera';
 import type { Camera } from '../../api/database/types';
 export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     private api;
@@ -14,75 +13,86 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     private pluginsService;
     private messageQueue;
     constructor(messageQueue: MessageQueue);
-    snapshot(data: {
-        prebuffer?: boolean;
+    connect(data: {
         cameraId: string;
-        pluginId: string;
-        ws?: boolean;
-    }): Promise<ArrayBuffer>;
-    setPrebufferSource(data: {
+        pluginId?: string;
+        ws?: boolean | undefined;
+    }): Promise<void>;
+    disconnect(data: {
+        cameraId: string;
+        pluginId?: string | undefined;
+        ws?: boolean | undefined;
+    }): Promise<void>;
+    reboot(data: {
+        cameraId: string;
+        pluginId?: string;
+        ws?: boolean | undefined;
+    }): Promise<void>;
+    getStreamInfo(data: {
+        sourceName: string;
+        cameraId: string;
+        pluginId?: string;
+        ws?: boolean | undefined;
+    }): Promise<StreamInfo | undefined>;
+    isPrebuffering(data: {
         sourceName: string;
-        address: string;
         type: PrebufferType;
         cameraId: string;
-        pluginId: string;
-        ws?: boolean;
-    }): Promise<void>;
-    removePrebufferSource(data: {
+        pluginId?: string;
+        ws?: boolean | undefined;
+    }): Promise<boolean>;
+    getPrebufferRawUrl(data: {
         sourceName: string;
         type: PrebufferType;
         cameraId: string;
-        pluginId: string;
-        ws?: boolean;
-    }): Promise<void>;
-    removePrebufferSources(data: {
+        pluginId?: string;
+        ws?: boolean | undefined;
+    }): Promise<string | undefined>;
+    getFffmpegPath(): string;
+    getIceServers(): IceServer[];
+    snapshot(data: {
+        forceNew?: boolean;
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
-    }): Promise<void>;
-    getFffmpegPath(data: {
+    }): Promise<ArrayBuffer>;
+    streamVideo(data: {
+        sourceName: string;
+        options: FfmpegOptions;
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
-    }): string;
-    getIceServers(data: {
+    }): Promise<void>;
+    recordToFile(data: {
+        sourceName: string;
+        outputPath: string;
+        duration?: number;
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
-    }): IceServer[];
+    }): Promise<void>;
     updateState<T extends keyof StateValues>(data: {
         stateName: T;
         eventData: OnSetEvent<T>;
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
     }): Promise<void>;
     refreshStates(data: {
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
     }): Promise<{
         camera: Camera;
         states: StateValues;
     }>;
-    streamVideo(data: {
-        sourceName: string;
-        options: FfmpegOptions;
-        cameraId: string;
-        pluginId: string;
-        ws?: boolean;
-    }): Promise<void>;
-    recordToFile(data: {
-        sourceName: string;
-        outputPath: string;
-        duration?: number;
-        cameraId: string;
-        pluginId: string;
-        ws?: boolean;
-    }): Promise<void>;
-    onRequestSnapshotRequest(cameraDevice: CameraDeviceHub, ...args: Parameters<CameraDelegate['snapshotRequest']>): Promise<Buffer>;
-    onRequestPrepareStream(cameraDevice: CameraDeviceHub, ...args: Parameters<CameraDelegate['prepareStream']>): Promise<void>;
-    onRequestWebRTCOffer(cameraDevice: CameraDeviceHub, ...args: Parameters<CameraDelegate['onOffer']>): Promise<string>;
-    onRequestWebRTCIceCandidates(cameraDevice: CameraDeviceHub, ...args: Parameters<CameraDelegate['onCandidates']>): Promise<void>;
+    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/src/proxy/proxies/plugin.d.ts

@@ -1,4 +1,5 @@
-import { type CameraStorage, type BasePlugin } from '../../plugins/types';
+import type { CameraStorage } from '../../plugins/cameraStorage';
+import type { BasePlugin } from '../../plugins/base';
 import type { MethodKeys, ProxyMessageStructure } from '../types';
 import type { MessageQueue } from '../queue';
 export declare class PluginProxy {
@@ -6,6 +7,6 @@ export declare class PluginProxy {
     private messageQueue;
     constructor(messageQueue: MessageQueue);
     onRequestPluginFn<K extends Exclude<MethodKeys<BasePlugin>, 'configureCameras'>>(pluginId: string, fn: K, ...args: Parameters<BasePlugin[K]>): Promise<ReturnType<BasePlugin[K]>>;
-    onRequestStorageFn<K extends MethodKeys<CameraStorage>>(pluginId: string, cameraId: string, fn: K, ...args: Parameters<CameraStorage[K]>): Promise<ReturnType<CameraStorage[K]>>;
+    onRequestStorageFn<K extends MethodKeys<CameraStorage>>(pluginId: string, cameraId: string, fn: K, ...args: Parameters<CameraStorage[K]>): Promise<Awaited<ReturnType<CameraStorage[K]>>>;
     handleMessage(message: ProxyMessageStructure): Promise<void>;
 }

package/dist/src/proxy/queue.d.ts

@@ -4,10 +4,12 @@ export declare class MessageQueue {
     private logger;
     private proxyServer;
     private router;
+    private aborted;
     private isProcessing;
     private queue;
     private pendingResponses;
     constructor(proxyServer: ProxyServer);
+    abortQueue(): void;
     enqueue(message: ProxyMessageStructure): Promise<any>;
     private processQueue;
     private listenToDealer;

package/dist/src/proxy/types.d.ts

@@ -1,6 +1,6 @@
 import type { Camera } from '../api/database/types';
 import type { CameraExtension } from '../plugins/types';
-import type { CameraConfig, OnSetEvent, StateValues, CameraDevice, FfmpegOptions, PrebufferType } from '../camera/types';
+import type { CameraConfig, OnSetEvent, StateValues, CameraDevice, FfmpegOptions, PrebufferType, StreamInfo } from '../camera/types';
 import type { IceServer } from '../services/config/types';
 export type MethodKeys<T> = {
     [K in keyof T]: T[K] extends Function ? K : never;
@@ -18,7 +18,7 @@ export interface ProxyMessageStructure {
     pluginId: string;
     type: 'request' | 'reply';
     proxy: 'system' | 'device' | 'plugins' | 'camera';
-    client: 'pluginFn' | 'pluginStorage' | 'cameraFn' | 'cameraDelegate' | 'device' | 'system';
+    client: 'pluginFn' | 'pluginStorage' | 'cameraFn' | 'cameraDelegate' | 'cameraPrebufferDelegate' | 'device' | 'system';
     fn: string;
     args: any;
     timeout: number;
@@ -138,7 +138,7 @@ export interface PluginsManagerProxyGenericEvent<K extends keyof PluginsManagerP
     type: K;
     data: PluginsManagerProxyEvents[K];
 }
-export type CameraDeviceListenerSocketEventType = 'updateDevice' | 'updateState' | 'updateOptions';
+export type CameraDeviceListenerSocketEventType = 'updateDevice' | 'updateState';
 export interface CameraDeviceListenerStatePayload<K extends keyof StateValues> {
     stateName: K;
     data: {
@@ -147,67 +147,66 @@ export interface CameraDeviceListenerStatePayload<K extends keyof StateValues> {
     };
 }
 export interface CameraDeviceListenerMessagePayload {
-    type: 'removed' | 'updated' | 'updatedSources';
+    type: 'removed' | 'updated' | 'cameraState';
     data?: any;
 }
 export interface CameraDeviceProxyMethods {
-    snapshot(data: {
-        sourceName: string;
-        prebuffer?: boolean;
+    connect(data: {
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
-    }): Promise<ArrayBuffer>;
-    setPrebufferSource(data: {
+    }): Promise<void>;
+    disconnect(data: {
+        cameraId: string;
+        pluginId?: string;
+        ws?: boolean;
+    }): Promise<void>;
+    reboot(data: {
+        cameraId: string;
+        pluginId?: string;
+        ws?: boolean;
+    }): Promise<void>;
+    isPrebuffering(data: {
         sourceName: string;
-        address: string;
         type: PrebufferType;
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
-    }): Promise<void>;
-    removePrebufferSource(data: {
+    }): Promise<boolean>;
+    getPrebufferRawUrl(data: {
         sourceName: string;
         type: PrebufferType;
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
-    }): Promise<void>;
-    removePrebufferSources(data: {
+    }): Promise<string | undefined>;
+    getStreamInfo(data: {
+        sourceName: string;
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
-    }): Promise<void>;
+    }): Promise<StreamInfo | undefined>;
     getFffmpegPath(data: {
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
     }): string;
     getIceServers(data: {
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
     }): IceServer[];
-    updateState<T extends keyof StateValues>(data: {
-        stateName: T;
-        eventData: OnSetEvent<T>;
-        cameraId: string;
-        pluginId: string;
-        ws?: boolean;
-    }): void;
-    refreshStates(data: {
+    snapshot(data: {
+        forceNew?: boolean;
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
-    }): Promise<{
-        camera: Camera;
-        states: StateValues;
-    }>;
+    }): Promise<ArrayBuffer>;
     streamVideo(data: {
         sourceName: string;
         options: FfmpegOptions;
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
     }): Promise<void>;
     recordToFile(data: {
@@ -215,9 +214,24 @@ export interface CameraDeviceProxyMethods {
         outputPath: string;
         duration?: number;
         cameraId: string;
-        pluginId: string;
+        pluginId?: string;
         ws?: boolean;
     }): Promise<void>;
+    updateState<T extends keyof StateValues>(data: {
+        stateName: T;
+        eventData: OnSetEvent<T>;
+        cameraId: string;
+        pluginId?: string;
+        ws?: boolean;
+    }): void;
+    refreshStates(data: {
+        cameraId: string;
+        pluginId?: string;
+        ws?: boolean;
+    }): Promise<{
+        camera: Camera;
+        states: StateValues;
+    }>;
 }
 export type CameraDeviceProxyMethodNames = MethodKeys<CameraDeviceProxyMethods>;
 export type CameraDeviceProxyEventCallbacks = {

package/dist/src/services/config/types.d.ts

@@ -30,7 +30,7 @@ export interface IConfig {
     settings: Partial<InterfaceSettings>;
     plugins: Partial<PluginsSettings>;
 }
-export type LoggingLevel = 'info' | 'debug' | 'warn' | 'error' | 'verbose';
+export type LoggingLevel = 'info' | 'debug' | 'warn' | 'error' | 'trace';
 export interface Logger {
     level?: LoggingLevel;
     disableTimestamps?: boolean;

package/dist/src/services/logger/index.d.ts

@@ -12,17 +12,18 @@ export declare class PluginLogger {
     warn(...args: any[]): void;
     attention(...args: any[]): void;
     debug(...args: any[]): void;
+    trace(...args: any[]): void;
 }
 export declare class Logger {
     private _loggerPrefix;
     private _debugEnabled;
-    private _verboseLogging;
+    private _traceLogging;
     private _disableTimestamps;
     notifications: UiNotification[];
     get debugEnabled(): boolean;
     set debugEnabled(state: boolean);
-    get verboseLogging(): boolean;
-    set verboseLogging(state: boolean);
+    get traceLogging(): boolean;
+    set traceLogging(state: boolean);
     get disableTimestamps(): boolean;
     set disableTimestamps(state: boolean);
     get prefix(): string;
@@ -32,7 +33,7 @@ export declare class Logger {
     warn(...args: any[]): void;
     attention(...args: any[]): void;
     debug(...args: any[]): void;
-    verbose(...args: any[]): void;
+    trace(...args: any[]): void;
     notify(title: string, text: string, type: LoggingLevel, link: string, socket?: Socket): Promise<void>;
     private setNotification;
     private formatDateTime;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camera.ui/browser",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "description": "camera.ui browser client",
   "author": "seydx (https://github.com/seydx/camera.ui)",
   "main": "./dist/bundle.js",
@@ -28,10 +28,10 @@
     "bufferutil": "^4.0.8",
     "rimraf": "^5.0.5",
     "ts-loader": "^9.5.1",
-    "typescript": "^5.3.3",
-    "updates": "^15.1.1",
+    "typescript": "^5.4.2",
+    "updates": "^15.3.1",
     "utf-8-validate": "^6.0.3",
-    "webpack": "^5.90.0",
+    "webpack": "^5.90.3",
     "webpack-cli": "^5.1.4"
   },
   "bugs": {

package/dist/src/plugins/child.d.ts

@@ -1,18 +0,0 @@
-import 'reflect-metadata';
-import { Plugin } from './plugin';
-import { BasePlugin } from './base';
-export declare class PluginChild {
-    private displayName;
-    plugin?: Plugin;
-    pluginConstructor?: BasePlugin;
-    private api?;
-    private storage?;
-    private pluginManager?;
-    private logger;
-    constructor();
-    private start;
-    private stop;
-    private sendMessage;
-    private processHandler;
-    private signalHander;
-}