@camera.ui/browser 0.0.33 → 0.0.35

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

@@ -1,13 +1,14 @@
 import { Observable } from 'rxjs';
 import { StreamingSession } from './streaming/streaming-session';
-import type { Camera, CameraInput, CameraPublicProperties } from '../api/database/types';
+import type { Camera, CameraSource, CameraPrebufferInput, CameraPublicProperties, CameraZone } from '../api/database/types';
 import type { ProxyServer } from '../proxy';
-import type { CameraDevice, BaseLogger, Input } from './types';
+import type { CameraDevice, BaseLogger, CameraDelegate } from './types';
 import type { IceServer } from '../services/config/types';
 import type { StateValues, OnSetEvent, LightState, MotionState, AudioState, ObjectState, DoorbellState, SirenState, StreamingConnectionOptions, FfmpegOptions, PrebufferType } from './types';
 export declare class CameraDeviceHub implements CameraDevice {
     private proxy?;
     private cameraSubject;
+    private prebufferSubject;
     private lightState;
     private motionState;
     private audioState;
@@ -21,8 +22,10 @@ export declare class CameraDeviceHub implements CameraDevice {
     onDoorbellPressed: Observable<DoorbellState>;
     onSirenDetected: Observable<SirenState>;
     logger: BaseLogger;
+    delegate?: CameraDelegate;
     get id(): string;
     get nativeId(): string | undefined;
+    get pluginId(): string;
     get disabled(): boolean;
     get name(): string;
     get type(): string;
@@ -34,31 +37,41 @@ export declare class CameraDeviceHub implements CameraDevice {
     get hasAudioDetector(): boolean;
     get hasObjectDetector(): boolean;
     get hasPtz(): boolean;
-    get sources(): Input[];
+    get motionZones(): CameraZone[];
+    get objectZones(): CameraZone[];
+    get sources(): CameraSource[];
     constructor(camera: Camera, logger?: BaseLogger, proxy?: ProxyServer);
-    snapshot(sourceName?: string): Promise<ArrayBuffer>;
-    setPrebufferSource(sourceName: string, address: string | null, type: PrebufferType, initialData?: boolean): Promise<void>;
+    getStreamSource(): CameraSource;
+    getSnapshotSource(): CameraSource;
+    getRecordingSource(): CameraSource;
+    getDetectionSource(): CameraSource;
+    configureDelegate(delegate: CameraDelegate): void;
+    snapshot(prebuffer?: boolean): Promise<ArrayBuffer>;
+    setPrebufferSource(sourceIdOrName: string, address: string, type: PrebufferType): Promise<void>;
+    removePrebufferSource(sourceIdOrName: string, type: 'recording' | 'stream'): Promise<void>;
+    removePrebufferSources(): Promise<void>;
     getFfmpegPath(): Promise<string>;
     getIceServers(): Promise<IceServer[]>;
-    getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
     createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<StreamingSession>;
     streamVideo(sourceName: string, options: FfmpegOptions): Promise<StreamingSession>;
     recordToFile(sourceName: string, outputPath: string, duration?: number): Promise<void>;
+    getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
     updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): Promise<void>;
     onStateChange<T extends keyof StateValues>(stateName: T): Observable<{
         newState: StateValues[T];
         oldState: StateValues[T];
     }>;
     onPropertyChange<T extends keyof CameraPublicProperties>(property: T): Observable<{
-        oldState: Camera[T];
-        newState: Camera[T];
+        oldData: Camera[T];
+        newData: Camera[T];
     }>;
-    updateCamera(camera: Camera): void;
-    updateSources(sources: CameraInput[]): void;
+    updateCamera(updatedCamera: Camera): void;
+    updatePrebufferSources(sources: CameraPrebufferInput[]): void;
     removeCamera(): void;
     removeAllListeners(): void;
     private createStateObservable;
     private subscribeToCameraChanges;
+    private subscribeToSourceChanges;
     private subscribeToStateChanges;
     private triggerProxyEvent;
 }

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

@@ -1,6 +1,8 @@
+/// <reference types="pouchdb-core" />
+/// <reference types="node" />
 import type { Observable, Subject } from 'rxjs';
 import type { ConnectionState, RTCIceCandidate } from 'werift';
-import type { CameraInput, Camera, CameraPublicProperties, CameraInputSettings } from '../api/database/types';
+import type { Camera, CameraPublicProperties, CameraInputSettings, CameraZone, CameraSource } from '../api/database/types';
 import type { StreamingSession } from './streaming/streaming-session';
 export type SpawnInput = string | number;
 export type PrebufferType = 'recording' | 'stream';
@@ -35,9 +37,16 @@ export interface BasicPeerConnection {
 }
 export interface CameraDevice {
     id: string;
+    pluginId: string;
+    nativeId?: string;
     disabled: boolean;
     name: string;
-    nativeId?: string;
+    type: string;
+    model: string;
+    sources: CameraSource[];
+    motionZones: CameraZone[];
+    objectZones: CameraZone[];
+    logger: BaseLogger;
     isCloud: boolean;
     hasLight: boolean;
     hasSiren: boolean;
@@ -45,35 +54,44 @@ export interface CameraDevice {
     hasAudioDetector: boolean;
     hasObjectDetector: boolean;
     hasPtz: boolean;
-    type: string;
-    model: string;
-    sources: Input[];
-    logger: BaseLogger;
     onLightDetected: Observable<LightState>;
     onMotionDetected: Observable<MotionState>;
     onAudioDetected: Observable<AudioState>;
     onObjectDetected: Observable<ObjectState>;
     onDoorbellPressed: Observable<DoorbellState>;
     onSirenDetected: Observable<SirenState>;
-    snapshot(sourceName?: string): Promise<ArrayBuffer>;
-    setPrebufferSource(sourceName: string, address: string | null, type: 'recording' | 'stream'): Promise<void>;
+    getStreamSource(): CameraSource;
+    getSnapshotSource(): CameraSource;
+    getRecordingSource(): CameraSource;
+    getDetectionSource(): CameraSource;
+    configureDelegate(delegate: CameraDelegate): void;
+    snapshot(prebuffer?: boolean): Promise<ArrayBuffer>;
+    setPrebufferSource(sourceName: string, address: string, type: 'recording' | 'stream'): Promise<void>;
+    removePrebufferSource(sourceName: string, type: 'recording' | 'stream'): Promise<void>;
+    removePrebufferSources(): Promise<void>;
     getFfmpegPath(): Promise<string>;
     getIceServers(): Promise<RTCIceServer[]>;
-    getValue<T extends keyof StateValues>(stateName: T): StateValue<T>;
     createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<StreamingSession>;
     streamVideo(sourceName: string, options: FfmpegOptions): Promise<StreamingSession>;
     recordToFile(sourceName: string, outputPath: string, duration?: number): Promise<void>;
+    getValue<T extends keyof StateValues>(stateName: T): StateValue<T>;
     updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): Promise<void>;
     onStateChange<T extends keyof StateValues>(stateName: T): Observable<{
         newState: StateValues[T];
         oldState: StateValues[T];
     }>;
     onPropertyChange<T extends keyof CameraPublicProperties>(property: T): Observable<{
-        oldState: Camera[T];
-        newState: Camera[T];
+        oldData: Camera[T];
+        newData: Camera[T];
     }>;
     removeAllListeners(): void;
 }
+export interface CameraDelegate {
+    snapshotRequest(requestId: string): Promise<Buffer>;
+    prepareStream(requestId: string): Promise<void>;
+    onOffer(requestId: string, sdp: string): Promise<string>;
+    onCandidates(requestId: string, candidates: string): Promise<void>;
+}
 export type Sdp = string;
 export type IceCandiate = string;
 export interface Go2RtcOfferMessage {
@@ -94,7 +112,7 @@ export interface ErrorMessage {
 }
 export type Go2RtcIncomingMessage = Go2RtcAnswerMessage | Go2RtcIceCandidateMessage | ErrorMessage;
 export type Go2RtcOutgoingMessage = Go2RtcOfferMessage | Go2RtcIceCandidateMessage;
-export interface CameraConfig {
+export interface BaseCameraConfig {
     name: string;
     nativeId?: string;
     isCloud?: boolean;
@@ -102,12 +120,12 @@ export interface CameraConfig {
     hasSiren?: boolean;
     disabled?: boolean;
     model?: string;
-    sources: CameraInputSettings[];
-}
-export interface Input extends CameraInput {
-    readonly isStreamPrebuffering?: boolean;
-    readonly isRecordingPrebuffering?: boolean;
 }
+export type CameraConfig = (BaseCameraConfig & {
+    sources?: Omit<CameraInputSettings, '_id'>[];
+}) | (BaseCameraConfig & {
+    delegate?: CameraDelegate;
+});
 export interface BaseState {
     timestamp: number;
     lastTriggered: number;

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

@@ -1,11 +1,11 @@
 import type { API } from '../api';
 import type { PluginJsonSchemaForm, PluginJsonSchema, CameraStorage as CameraStorageMethods, SchemaConfig } from './types';
 export declare class CameraStorage implements CameraStorageMethods {
-    schema: PluginJsonSchemaForm;
     private cameraId;
     private instance;
     private api;
     private db;
+    private _schema;
     private _values;
     constructor(api: API, instance: any, cameraId: string, schema?: PluginJsonSchemaForm);
     /**
@@ -13,6 +13,17 @@ export declare class CameraStorage implements CameraStorageMethods {
      * This will load the configuration from the database.
      */
     initializeStorage(): Promise<void>;
+    /**
+     * Get a value from the configuration by its key/path.
+     * If the schema has an onGet function, the onGet function will be called.
+     * If the onGet functions is undefined, the value from the configuration will be returned.
+     * If the schema has a default value, and the configuration value is undefined, the default value will be returned.
+     *
+     * @param path - The path to the configuration value.
+     * @returns The value from the configuration.
+     */
+    getValue<T = string>(path: string, defaultValue: T): Promise<T> | T;
+    getValue<T = string>(path: string, defaultValue?: T): Promise<T> | T | undefined;
     /**
      * Set a new value for a given key/path in the configuration.
      * If the schema of the value has an onSet function, and the value has changed, the onSet function will be called.
@@ -23,15 +34,12 @@ export declare class CameraStorage implements CameraStorageMethods {
      */
     setValue<T = string>(path: string, newValue: T): Promise<void>;
     /**
-     * Get a value from the configuration by its key/path.
-     * If the schema has an onGet function, the onGet function will be called.
-     * If the onGet functions is undefined, the value from the configuration will be returned.
-     * If the schema has a default value, and the configuration value is undefined, the default value will be returned.
+     * Check if a value exists by its config path/key.
      *
-     * @param path - The path to the configuration value.
-     * @returns The value from the configuration.
+     * @param path - The path to the value to check.
+     * @returns True if the value exists, false otherwise.
      */
-    getValue<T = string>(path: string): T | Promise<T> | undefined;
+    hasValue(path: string): boolean;
     /**
      * Get the root schema and configuration.
      * This will also call the onGet functions for the schema.
@@ -73,6 +81,13 @@ export declare class CameraStorage implements CameraStorageMethods {
      * @param schema - The new schema to set.
      */
     changeSchema(path: string, newSchema: Partial<PluginJsonSchema>): Promise<void>;
+    /**
+     * Get a schema by its config path/key.
+     *
+     * @param path - The path to the schema to get.
+     * @returns The schema.
+     */
+    getSchema<T>(path: string): T | undefined;
     /**
      * Check if a schema exists by its config path/key.
      *
@@ -80,13 +95,6 @@ export declare class CameraStorage implements CameraStorageMethods {
      * @returns True if the schema exists, false otherwise.
      */
     hasSchema(path: string): boolean;
-    /**
-     * Check if a value exists by its config path/key.
-     *
-     * @param path - The path to the value to check.
-     * @returns True if the value exists, false otherwise.
-     */
-    hasValue(path: string): boolean;
     private resolveOnGetFunctions;
     private resolveOnGetFunctionsForObject;
     private resolveOnGetFunctionsForSchema;
@@ -94,4 +102,5 @@ export declare class CameraStorage implements CameraStorageMethods {
     private filterStorableValues;
     private containsStorableSchema;
     private saveDb;
+    private removeDb;
 }

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

@@ -31,9 +31,6 @@ export declare class PluginManager {
     stopPluginChild(pluginName: string): Promise<void>;
     private loadInstalledPlugins;
     private removeOrphanedPlugins;
-    private buildDependencyGraph;
-    private groupPlugins;
-    private topologicalSort;
     private handlePluginRegistration;
     private loadDefaultPaths;
     private addNpmPrefixToSearchPaths;

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

@@ -16,7 +16,7 @@ export interface Context {
  * Represents a loaded camera.ui plugin.
  */
 export declare class Plugin {
-    _disabled: boolean;
+    private _disabled;
     private logger;
     private configService;
     private _info;

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

@@ -26,14 +26,21 @@ export interface JSONObject {
 }
 export type JSONArray = JSONValue[];
 export type PluginConfig = Record<string, any>;
-export type CameraExtension = 'hub' | 'prebuffer' | 'motionDetection' | 'objectDetection' | 'audioDetection' | 'ptz';
 export declare const CAMERA_EXTENSIONS: CameraExtension[];
-export interface PluginContract {
+export type CameraExtension = 'hub' | 'prebuffer' | 'motionDetection' | 'objectDetection' | 'audioDetection' | 'ptz';
+type ExtensionOrSupport = {
+    extension: CameraExtension;
+    supportAdditionalCameras?: never;
+} | {
+    extension?: never;
+    supportAdditionalCameras?: boolean;
+};
+export interface PluginContractBase {
     pluginName: string;
-    builtIns?: CameraExtension[];
-    extension?: CameraExtension;
+    builtIns?: Exclude<CameraExtension, 'hub'>[];
     dependencies?: string[];
 }
+export type PluginContract = PluginContractBase & ExtensionOrSupport;
 export declare const enum PLUGIN_STATUS {
     READY = "ready",
     STARTING = "starting",
@@ -54,7 +61,6 @@ export interface PluginStorage {
 }
 export interface ZmqInfo {
     zmqRouterAddress: string;
-    zmqReqAddress: string;
     zmqPubAddress: string;
     zmqPublicKey: string;
 }
@@ -87,7 +93,7 @@ export interface JsonBaseSchema<T = any> {
 }
 export interface PluginJsonBaseSchema<T = any> extends JsonBaseSchema<T> {
     store?: boolean;
-    onSet?: (newValue: any, oldValue: any) => void | Promise<void>;
+    onSet?: (newValue: any, oldValue: any) => Promise<void> | void;
     onGet?: () => any | Promise<any>;
 }
 export interface JsonSchemaString extends JsonBaseSchema<string> {
@@ -130,10 +136,12 @@ export interface PluginJsonSchemaEnum extends PluginJsonBaseSchema<string | numb
 }
 export interface JsonSchemaObject extends JsonBaseSchema {
     type: 'object';
+    opened?: boolean;
     properties?: JsonSchemaForm;
 }
 export interface PluginJsonSchemaObject extends PluginJsonBaseSchema {
     type: 'object';
+    opened?: boolean;
     properties?: PluginJsonSchemaForm;
 }
 export interface JsonSchemaObjectWithButtons extends JsonSchemaObject {
@@ -144,6 +152,7 @@ export interface JsonSchemaAnyOf {
 }
 export interface JsonSchemaArray extends JsonBaseSchema {
     type: 'array';
+    opened?: boolean;
     items?: JsonSchema | JsonSchemaAnyOf;
 }
 export interface JsonSchemaButton {
@@ -164,3 +173,4 @@ export interface RootSchema {
 export interface PluginRootSchema {
     schema: PluginJsonSchemaForm;
 }
+export {};

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

@@ -1,24 +1,27 @@
 import { CameraDeviceHub } from '../../camera';
 import type { Camera } from '../../api/database/types';
-import type { StateValues, OnSetEvent, BaseLogger, PrebufferType } from '../../camera/types';
+import type { StateValues, OnSetEvent, PrebufferType, CameraDelegate } from '../../camera/types';
 import type { IceServer } from '../../services/config/types';
 export declare class CameraDeviceClientProxy extends CameraDeviceHub {
-    private targetId;
-    private targetName;
-    private clientTargetId;
-    private subTargetId;
-    private pluginId;
+    private removed;
     private api;
-    private client;
+    private dealer;
     private subscriber;
     private messageQueue;
+    private dealerId;
+    private subscriberId;
+    private pluginID;
     private close?;
-    constructor(camera: Camera, logger: BaseLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, serverPublicKey: string);
+    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>;
     getFfmpegPath(): Promise<string>;
     getIceServers(): Promise<IceServer[]>;
     updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): Promise<void>;
     refreshStates(): Promise<void>;
+    private handleRouterRequest;
     private listenToSubscriberEvents;
     private onRequest;
 }

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

@@ -1,23 +1,23 @@
 import { CameraDeviceClientProxy } from '../client/cameraDevice';
-import type { CameraConfig, CameraDevice, BaseLogger } from '../../camera/types';
-import type { DeviceManagerProxyMethods, DeviceManagerProxyEventCallbacks } from '../types';
-export declare class DeviceManager implements DeviceManagerProxyMethods {
-    private pluginId;
-    private pluginName;
-    private clientTargetId;
-    private subTargetId;
+import type { CameraConfig, CameraDevice } from '../../camera/types';
+import type { DeviceManagerProxyMethods, DeviceManagerProxyEventCallbacks, DeviceManagerProxyMethodsListener } from '../types';
+export declare class DeviceManager implements DeviceManagerProxyMethods, DeviceManagerProxyMethodsListener {
     private api;
     private logger;
-    private client;
+    private dealer;
     private subscriber;
     private messageQueue;
-    private reqServerAddress;
-    private pubServerAddress;
+    private routerAddress;
+    private publisherAddress;
     private serverPublicKey;
+    private pluginId;
+    private pluginName;
+    private dealerId;
+    private subscriberId;
     private MAX_LISTENERS_PER_EVENT;
     private devices;
     private eventListeners;
-    constructor(logger: BaseLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, serverPublicKey: string, cameraDevices?: CameraDeviceClientProxy[]);
+    constructor(pluginId: string, pluginName: string, routerAddress: string, publisherAddress: string, serverPublicKey: string, cameraDevices?: CameraDeviceClientProxy[]);
     getCameraById(id: string): Promise<CameraDevice | undefined>;
     getCameraByName(name: string): Promise<CameraDevice | undefined>;
     createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
@@ -26,7 +26,8 @@ export declare class DeviceManager implements DeviceManagerProxyMethods {
     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;
+    private handleRouterRequest;
     private listenToSubscriberEvents;
     private onRequest;
-    private addCamera;
+    private addOrGetCamera;
 }

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

@@ -1,26 +1,23 @@
-import type { BaseLogger } from '../../camera/types';
-import type { PluginsManagerProxyMethods, PluginsManagerProxyEventCallbacks } from '../types';
-export declare class PluginsManager implements PluginsManagerProxyMethods {
-    private pluginId;
-    private pluginName;
-    private clientTargetId;
-    private subTargetId;
-    private dealerTargetId;
+import type { PluginsManagerProxyMethods, PluginsManagerProxyMethodsListener, PluginsManagerProxyEventCallbacks } from '../types';
+export declare class PluginsManager implements PluginsManagerProxyMethods, PluginsManagerProxyMethodsListener {
     private api;
     private logger;
     private plugin?;
-    private client;
-    private subscriber;
     private dealer;
+    private subscriber;
     private messageQueue;
+    private pluginId;
+    private pluginName;
+    private dealerId;
+    private subscriberId;
     private MAX_LISTENERS_PER_EVENT;
     private eventListeners;
-    constructor(logger: BaseLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, routerAddress: string, serverPublicKey: string);
+    constructor(pluginId: string, pluginName: string, routerAddress: string, publisherAddress: string, serverPublicKey: string);
     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;
+    private handleRouterRequest;
     private listenToSubscriberEvents;
-    private listenToRouterRequests;
     private onRequest;
     private isPluginMessage;
     private isStorageMessage;

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

@@ -1,11 +1,14 @@
-import { Request } from 'zeromq';
+import { Dealer } from 'zeromq';
+import type { ProxyMessageStructure } from '../types';
 export declare class ClientMessageQueue {
-    private requestClient;
-    private queue;
+    private logger;
+    private dealer;
+    private requestHandler;
     private isProcessing;
+    private queue;
     private pendingResponses;
-    constructor(requestClient: Request);
-    enqueue(message: any, timeout?: number): Promise<any>;
+    constructor(requestHandler: (message: ProxyMessageStructure) => void, dealer: Dealer);
+    enqueue(message: ProxyMessageStructure): Promise<any>;
     private processQueue;
-    private listenToReplies;
+    private listenToRouter;
 }

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

@@ -1,21 +1,21 @@
-import type { BaseLogger } from '../../camera/types';
-import type { SystemManagerProxyMethods, SystemManagerProxyEventCallbacks } from '../types';
-export declare class SystemManager implements SystemManagerProxyMethods {
-    private pluginId;
-    private pluginName;
-    private clientTargetId;
-    private subTargetId;
+import type { SystemManagerProxyMethods, SystemManagerProxyMethodsListener, SystemManagerProxyEventCallbacks } from '../types';
+export declare class SystemManager implements SystemManagerProxyMethods, SystemManagerProxyMethodsListener {
     private api;
     private logger;
-    private client;
+    private dealer;
     private subscriber;
     private messageQueue;
+    private pluginId;
+    private pluginName;
+    private dealerId;
+    private subscriberId;
     private MAX_LISTENERS_PER_EVENT;
     private eventListeners;
-    constructor(logger: BaseLogger, pluginId: string, pluginName: string, reqServerAddress: string, pubServerAddress: string, serverPublicKey: string);
+    constructor(pluginId: string, pluginName: string, routerAddress: string, publisherAddress: string, serverPublicKey: string);
     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;
+    private handleRouterRequest;
     private listenToSubscriberEvents;
     private onRequest;
 }

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

@@ -1,26 +1,29 @@
-import { Reply, Router, Publisher } from 'zeromq';
+import { Router, Publisher } from 'zeromq';
 import { ServerProxy } from './proxies/server';
 import { CameraDeviceProxy } from './proxies/camera';
 import { PluginProxy } from './proxies/plugin';
 import type { ProxyBridge } from './ws';
-import type { ProxyEvents, TargetID, QueueItem } from './types';
+import type { StateValues } from '../camera/types';
+import type { DeviceManagerProxyEvents, SystemManagerProxyEvents, PluginsManagerProxyEvents, CameraDeviceListenerMessagePayload } from './types';
 export declare class ProxyServer {
     server?: ServerProxy;
     camera?: CameraDeviceProxy;
     plugin?: PluginProxy;
-    private logger;
     private configService;
     router: Router;
-    reqServer: Reply;
-    pubServer: Publisher;
+    publisher: Publisher;
     socketBridge?: ProxyBridge;
     private messageQueue;
     constructor();
     initialize(): Promise<void>;
     close(): Promise<void>;
-    sendMessage(item: QueueItem): Promise<void>;
-    publishEvent<K extends keyof ProxyEvents>(targetId: TargetID, type: K, data: ProxyEvents[K]): Promise<void>;
-    private listenToRequestMessages;
-    private listenToRouterMessages;
-    private isProxyMessage;
+    publishDeviceManagerEvent<K extends keyof DeviceManagerProxyEvents>(targetId: string, type: K, data: DeviceManagerProxyEvents[K]): Promise<void>;
+    publishSystemManagerEvent<K extends keyof SystemManagerProxyEvents>(targetId: string, type: K, data: SystemManagerProxyEvents[K]): Promise<void>;
+    publishPluginsManagerEvent<K extends keyof PluginsManagerProxyEvents>(targetId: string, type: K, data: PluginsManagerProxyEvents[K]): Promise<void>;
+    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>;
+    private isCameraState;
 }