@camera.ui/browser 0.0.35 → 0.0.36

package/dist/src/camera/streaming/streaming-session.d.ts

@@ -1,8 +1,8 @@
 import { RtpPacket } from 'werift';
 import { ReplaySubject, Subject } from 'rxjs';
-import { Subscribed } from '../subscribed';
+import { Subscribed } from '../utils/subscribed';
 import type { WebrtcConnection } from './webrtc-connection';
-import type { FfmpegOptions, SpawnInput, CameraDevice } from '../types';
+import type { FfmpegOptions, SpawnInput, BaseLogger, CameraDevice } from '../types';
 export declare class StreamingSession extends Subscribed {
     readonly onCallEnded: ReplaySubject<void>;
     readonly onVideoRtp: Subject<RtpPacket>;
@@ -16,7 +16,7 @@ export declare class StreamingSession extends Subscribed {
     private connection;
     private logger;
     get isUsingOpus(): Promise<boolean>;
-    constructor(cameraDevice: CameraDevice, connection: WebrtcConnection);
+    constructor(cameraDevice: CameraDevice, logger: BaseLogger, connection: WebrtcConnection);
     reservePort(bufferPorts?: number): Promise<number>;
     startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
     transcodeReturnAudio(ffmpegOptions: {

package/dist/src/camera/streaming/webrtc-connection.d.ts

@@ -1,7 +1,7 @@
 import { ReplaySubject, Subject, type Observable } from 'rxjs';
-import { Subscribed } from '../subscribed';
+import { Subscribed } from '../utils/subscribed';
 import type { RtpPacket } from 'werift';
-import type { StreamingConnectionOptions, CameraDevice } from '../types';
+import type { StreamingConnectionOptions, BaseLogger, CameraDevice } from '../types';
 import type { IceServer } from '../../services/config/types';
 export declare class WebrtcConnection extends Subscribed {
     readonly onCameraConnected: ReplaySubject<void>;
@@ -18,9 +18,9 @@ export declare class WebrtcConnection extends Subscribed {
     private readonly ws;
     private readonly onOfferSent;
     private hasEnded;
-    private logger;
     private cameraDevice;
-    constructor(cameraDevice: CameraDevice, sourceName: string, iceServers: IceServer[], options: StreamingConnectionOptions);
+    private logger;
+    constructor(cameraDevice: CameraDevice, sourceName: string, iceServers: IceServer[], logger: BaseLogger, options: StreamingConnectionOptions);
     sendAudioPacket(rtp: RtpPacket): void;
     stop(): void;
     requestKeyFrame(): void;

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

@@ -2,15 +2,21 @@
 /// <reference types="node" />
 import type { Observable, Subject } from 'rxjs';
 import type { ConnectionState, RTCIceCandidate } from 'werift';
-import type { Camera, CameraPublicProperties, CameraInputSettings, CameraZone, CameraSource } from '../api/database/types';
+import type { Camera, CameraPublicProperties, CameraInputSettings, CameraZone, CameraInput, CameraType, CameraInformation } from '../api/database/types';
 import type { StreamingSession } from './streaming/streaming-session';
 export type SpawnInput = string | number;
 export type PrebufferType = 'recording' | 'stream';
+export interface CameraSource extends CameraInput {
+    isPrebuffering(type: PrebufferType): Promise<boolean>;
+    getPrebufferRawUrl(type: PrebufferType): Promise<string | undefined>;
+    getStreamInfo(): Promise<StreamInfo | undefined>;
+}
 export interface BaseLogger {
     log: (...args: any[]) => void;
     error: (...args: any[]) => void;
     warn: (...args: any[]) => void;
     debug: (...args: any[]) => void;
+    trace: (...args: any[]) => void;
 }
 export interface FfmpegOptions {
     input?: SpawnInput[];
@@ -41,36 +47,37 @@ export interface CameraDevice {
     nativeId?: string;
     disabled: boolean;
     name: string;
-    type: string;
-    model: string;
+    type: CameraType;
+    info: CameraInformation;
     sources: CameraSource[];
     motionZones: CameraZone[];
     objectZones: CameraZone[];
-    logger: BaseLogger;
     isCloud: boolean;
     hasLight: boolean;
     hasSiren: boolean;
+    hasBinarySensor: boolean;
+    hasBattery: boolean;
     hasMotionDetector: boolean;
     hasAudioDetector: boolean;
     hasObjectDetector: boolean;
     hasPtz: boolean;
-    onLightDetected: Observable<LightState>;
+    onLightSwitched: Observable<LightState>;
     onMotionDetected: Observable<MotionState>;
     onAudioDetected: Observable<AudioState>;
     onObjectDetected: Observable<ObjectState>;
     onDoorbellPressed: Observable<DoorbellState>;
     onSirenDetected: Observable<SirenState>;
+    onBatteryChanged: Observable<BatteryState>;
+    reboot(): 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>;
+    configurePrebufferDelegate(delegate: CameraPrebufferDelegate): void;
     getFfmpegPath(): Promise<string>;
     getIceServers(): Promise<RTCIceServer[]>;
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<StreamingSession>;
     streamVideo(sourceName: string, options: FfmpegOptions): Promise<StreamingSession>;
     recordToFile(sourceName: string, outputPath: string, duration?: number): Promise<void>;
@@ -91,6 +98,30 @@ export interface CameraDelegate {
     prepareStream(requestId: string): Promise<void>;
     onOffer(requestId: string, sdp: string): Promise<string>;
     onCandidates(requestId: string, candidates: string): Promise<void>;
+    reboot(): Promise<void>;
+}
+export interface CameraPrebufferDelegate {
+    isPrebuffering(sourceName: string, type: PrebufferType): Promise<boolean>;
+    getPrebufferRawUrl(sourceName: string, type: PrebufferType): Promise<string | undefined>;
+    getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;
+}
+export interface AudioStreamOptions {
+    enabled?: boolean;
+    codec?: string;
+    bitrate?: number;
+    sampleRate?: number;
+}
+export interface VideoStreamOptions {
+    codec?: string;
+    width?: number;
+    height?: number;
+    bitrate?: number;
+    fps?: number;
+    idrInterval?: number;
+}
+export interface StreamInfo {
+    audio: AudioStreamOptions;
+    video: VideoStreamOptions;
 }
 export type Sdp = string;
 export type IceCandiate = string;
@@ -118,8 +149,10 @@ export interface BaseCameraConfig {
     isCloud?: boolean;
     hasLight?: boolean;
     hasSiren?: boolean;
+    hasBinarySensor?: boolean;
+    hasBattery?: boolean;
     disabled?: boolean;
-    model?: string;
+    info?: Partial<CameraInformation>;
 }
 export type CameraConfig = (BaseCameraConfig & {
     sources?: Omit<CameraInputSettings, '_id'>[];
@@ -149,6 +182,9 @@ export interface DoorbellSetEvent {
 export interface SirenSetEvent {
     state: boolean;
 }
+export interface BatterySetEvent {
+    state: number;
+}
 export interface DeviceSetEvent {
 }
 export type LightState = BaseState & LightSetEvent;
@@ -157,7 +193,8 @@ export type AudioState = BaseState & AudioSetEvent;
 export type DoorbellState = BaseState & DoorbellSetEvent;
 export type SirenState = BaseState & SirenSetEvent;
 export type ObjectState = BaseState & ObjectSetEvent;
-export type State = LightState | MotionState | AudioState | ObjectState | DoorbellState | SirenState;
+export type BatteryState = BaseState & BatterySetEvent;
+export type State = LightState | MotionState | AudioState | ObjectState | DoorbellState | SirenState | BatteryState;
 export interface StateValues {
     light: LightState;
     motion: MotionState;
@@ -165,10 +202,11 @@ export interface StateValues {
     object: ObjectState;
     doorbell: DoorbellState;
     siren: SirenState;
+    battery: BatteryState;
 }
 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 : ObjectSetEvent;
+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 OnChangeCallback<T extends keyof StateValues> = (newEvent: StateValues[T], oldEvent: StateValues[T]) => void;

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

@@ -21,4 +21,5 @@ export declare class Go2Rtc {
     private handleClose;
     private setStatus;
     private processLogger;
+    private isIgnorableString;
 }

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

@@ -7,6 +7,7 @@ export declare class CameraStorage implements CameraStorageMethods {
     private db;
     private _schema;
     private _values;
+    get values(): Record<string, any>;
     constructor(api: API, instance: any, cameraId: string, schema?: PluginJsonSchemaForm);
     /**
      * Initialize the storage.

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

@@ -18,8 +18,8 @@ type OptionalZodZobject = z.ZodOptional<z.ZodObject<Record<string, z.ZodTypeAny>
     [x: string]: any;
 }> | z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>> | z.ZodRecord<z.ZodString, z.ZodAny>;
 type OptionalZodArray = z.ZodOptional<z.ZodType<any, any, any>> | z.ZodType<any, any, any>;
-type OptionalZodEnum = z.ZodOptional<z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>> | z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>;
-type OptionalZodEnumMultiple = z.ZodOptional<z.ZodArray<z.ZodUnion<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>, 'many'>> | z.ZodArray<z.ZodUnion<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>, 'many'>;
+type OptionalZodEnum = z.ZodOptional<z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>> | z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]> | z.ZodEffects<z.ZodAny, any, any> | z.ZodUnion<any>;
+type OptionalZodEnumMultiple = z.ZodOptional<z.ZodArray<z.ZodUnion<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>, 'many'>> | z.ZodArray<z.ZodUnion<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>, 'many'> | z.ZodEffects<z.ZodAny, any, any> | z.ZodUnion<any>;
 type ZodAny = z.ZodType<any, any, any>;
 /**
  * Generate root JSON schema from value.
@@ -137,7 +137,7 @@ export declare const generateStringSchema: (value: string) => JsonSchemaString;
  * @param type - The type of the enum.
  * @returns - The generated JSON schema for the enum.
  */
-export declare const generateEnumSchema: (value: (string | number | boolean)[], type: 'string' | 'number' | 'boolean') => JsonSchemaEnum;
+export declare const generateEnumSchema: (value: string[]) => JsonSchemaEnum;
 /**
  * Generates a JSON schema for an object.
  *

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

@@ -27,7 +27,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 +80,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 +124,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/proxy/client/cameraDevice.d.ts

@@ -1,26 +1,31 @@
-import { CameraDeviceHub } from '../../camera';
+import { CameraController } from '../../camera';
+import { StreamingSession } from '../../camera/streaming/streaming-session';
 import type { Camera } from '../../api/database/types';
-import type { StateValues, OnSetEvent, PrebufferType, CameraDelegate } from '../../camera/types';
+import type { StateValues, OnSetEvent, StreamingConnectionOptions, FfmpegOptions, CameraSource } from '../../camera/types';
 import type { IceServer } from '../../services/config/types';
-export declare class CameraDeviceClientProxy extends CameraDeviceHub {
-    private removed;
+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?;
+    private routerAddress;
+    private publisherAddress;
+    get sources(): CameraSource[];
     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>;
+    reboot(): Promise<void>;
     getFfmpegPath(): Promise<string>;
     getIceServers(): Promise<IceServer[]>;
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
+    createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<StreamingSession>;
+    streamVideo(sourceName: string, options: FfmpegOptions): Promise<StreamingSession>;
+    recordToFile(sourceName: string, outputPath: string, duration?: number): Promise<void>;
     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

@@ -13,7 +13,7 @@ export declare class DeviceManager implements DeviceManagerProxyMethods, DeviceM
     private pluginId;
     private pluginName;
     private dealerId;
-    private subscriberId;
+    private subscriberIds;
     private MAX_LISTENERS_PER_EVENT;
     private devices;
     private eventListeners;

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

@@ -9,7 +9,7 @@ export declare class PluginsManager implements PluginsManagerProxyMethods, Plugi
     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);

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

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

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,32 +13,31 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     private pluginsService;
     private messageQueue;
     constructor(messageQueue: MessageQueue);
-    snapshot(data: {
-        prebuffer?: boolean;
+    reboot(data: {
         cameraId: string;
         pluginId: string;
-        ws?: boolean;
-    }): Promise<ArrayBuffer>;
-    setPrebufferSource(data: {
+        ws?: boolean | undefined;
+    }): Promise<void>;
+    getStreamInfo(data: {
         sourceName: string;
-        address: string;
-        type: PrebufferType;
         cameraId: string;
         pluginId: string;
-        ws?: boolean;
-    }): Promise<void>;
-    removePrebufferSource(data: {
+        ws?: boolean | undefined;
+    }): Promise<StreamInfo | undefined>;
+    isPrebuffering(data: {
         sourceName: string;
         type: PrebufferType;
         cameraId: string;
         pluginId: string;
-        ws?: boolean;
-    }): Promise<void>;
-    removePrebufferSources(data: {
+        ws?: boolean | undefined;
+    }): Promise<boolean>;
+    getPrebufferRawUrl(data: {
+        sourceName: string;
+        type: PrebufferType;
         cameraId: string;
         pluginId: string;
-        ws?: boolean;
-    }): Promise<void>;
+        ws?: boolean | undefined;
+    }): Promise<string | undefined>;
     getFffmpegPath(data: {
         cameraId: string;
         pluginId: string;
@@ -50,21 +48,12 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
         pluginId: string;
         ws?: boolean;
     }): IceServer[];
-    updateState<T extends keyof StateValues>(data: {
-        stateName: T;
-        eventData: OnSetEvent<T>;
-        cameraId: string;
-        pluginId: string;
-        ws?: boolean;
-    }): Promise<void>;
-    refreshStates(data: {
+    snapshot(data: {
+        forceNew?: boolean;
         cameraId: string;
         pluginId: string;
         ws?: boolean;
-    }): Promise<{
-        camera: Camera;
-        states: StateValues;
-    }>;
+    }): Promise<ArrayBuffer>;
     streamVideo(data: {
         sourceName: string;
         options: FfmpegOptions;
@@ -80,9 +69,28 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
         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>;
+    updateState<T extends keyof StateValues>(data: {
+        stateName: T;
+        eventData: OnSetEvent<T>;
+        cameraId: string;
+        pluginId: string;
+        ws?: boolean;
+    }): Promise<void>;
+    refreshStates(data: {
+        cameraId: string;
+        pluginId: string;
+        ws?: boolean;
+    }): Promise<{
+        camera: Camera;
+        states: StateValues;
+    }>;
+    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/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;
@@ -147,37 +147,35 @@ export interface CameraDeviceListenerStatePayload<K extends keyof StateValues> {
     };
 }
 export interface CameraDeviceListenerMessagePayload {
-    type: 'removed' | 'updated' | 'updatedSources';
+    type: 'removed' | 'updated';
     data?: any;
 }
 export interface CameraDeviceProxyMethods {
-    snapshot(data: {
-        sourceName: string;
-        prebuffer?: boolean;
+    reboot(data: {
         cameraId: string;
         pluginId: string;
         ws?: boolean;
-    }): Promise<ArrayBuffer>;
-    setPrebufferSource(data: {
+    }): Promise<void>;
+    isPrebuffering(data: {
         sourceName: string;
-        address: string;
         type: PrebufferType;
         cameraId: string;
         pluginId: string;
         ws?: boolean;
-    }): Promise<void>;
-    removePrebufferSource(data: {
+    }): Promise<boolean>;
+    getPrebufferRawUrl(data: {
         sourceName: string;
         type: PrebufferType;
         cameraId: string;
         pluginId: string;
         ws?: boolean;
-    }): Promise<void>;
-    removePrebufferSources(data: {
+    }): Promise<string | undefined>;
+    getStreamInfo(data: {
+        sourceName: string;
         cameraId: string;
         pluginId: string;
         ws?: boolean;
-    }): Promise<void>;
+    }): Promise<StreamInfo | undefined>;
     getFffmpegPath(data: {
         cameraId: string;
         pluginId: string;
@@ -188,21 +186,12 @@ export interface CameraDeviceProxyMethods {
         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;
         ws?: boolean;
-    }): Promise<{
-        camera: Camera;
-        states: StateValues;
-    }>;
+    }): Promise<ArrayBuffer>;
     streamVideo(data: {
         sourceName: string;
         options: FfmpegOptions;
@@ -218,6 +207,21 @@ export interface CameraDeviceProxyMethods {
         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;