@camera.ui/browser 0.0.68 → 0.0.70

package/dist/types/server/src/api/websocket/nsp/notifications.d.ts

@@ -0,0 +1,11 @@
+import type { Namespace, Server, Socket } from 'socket.io';
+import type { SocketNsp } from '../types.js';
+export declare class NotificationsNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private logger;
+    constructor(io: Server);
+    clearNotifications(): Promise<void>;
+    getNotifications(socket: Socket): Promise<void>;
+    removeNotification(id?: string): Promise<void>;
+}

package/dist/types/server/src/api/websocket/nsp/plugins.d.ts

@@ -0,0 +1,13 @@
+import type { Namespace, Server } from 'socket.io';
+import type { PLUGIN_STATUS } from '../../../plugins/types.js';
+import type { SocketNsp } from '../types.js';
+export declare class PluginsNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private pluginManager;
+    constructor(io: Server);
+    pluginStatus(pluginName: string, callback?: Function): Promise<void | {
+        pluginName: string;
+        status: PLUGIN_STATUS;
+    }>;
+}

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

@@ -0,0 +1,9 @@
+import type { Namespace, Server, Socket } from 'socket.io';
+import type { SocketNsp } from '../types.js';
+export declare class ServerNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private logger;
+    constructor(io: Server);
+    checkUpdate(socket?: Socket): Promise<void>;
+}

package/dist/types/server/src/api/websocket/nsp/status.d.ts

@@ -0,0 +1,20 @@
+import type { Namespace, Server, Socket } from 'socket.io';
+import { PLUGIN_STATUS } from '../../../plugins/types.js';
+import { RUNTIME_STATUS } from '../../../services/config/types.js';
+import type { SocketNsp } from '../types.js';
+export declare class StatusNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private configService;
+    private pluginManager;
+    private go2rtc;
+    constructor(io: Server);
+    watchStats(socket: Socket, payload: any, callback?: Function): {
+        name: string;
+        status: RUNTIME_STATUS;
+    }[];
+    watchPluginStats(socket: Socket, payload: any, callback?: Function): {
+        name: string;
+        status: PLUGIN_STATUS;
+    }[];
+}

package/dist/types/server/src/api/websocket/nsp/streams.d.ts

@@ -0,0 +1,15 @@
+import type { Namespace, Server } from 'socket.io';
+import type { SocketNsp } from '../types.js';
+export declare class StreamsNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private bridges;
+    private logger;
+    private configService;
+    constructor(io: Server);
+    private connectBridge;
+    private sendMessage;
+    private closeBridge;
+    private onEnd;
+    private onDestroy;
+}

package/dist/types/server/src/api/{ws → websocket}/types.d.ts

@@ -1,8 +1,8 @@
-import { PLUGIN_STATUS } from '../../plugins/types';
+import { PLUGIN_STATUS } from '../../plugins/types.js';
 import type { Namespace } from 'socket.io';
 import type { WebSocket } from 'ws';
-import type { VideoStreamingMode } from '../database/types';
-export type SocketNsp = '/camera.ui' | '/metrics' | '/logs' | '/status' | '/notifications' | '/streams' | '/plugins' | '/proxy';
+import type { VideoStreamingMode } from '../database/types.js';
+export type SocketNsp = '/camera.ui' | '/metrics' | '/logs' | '/status' | '/notifications' | '/streams' | '/plugins' | '/proxy' | '/frame';
 export interface SocketNspMap {
     nsp: Namespace;
     [key: string]: any;

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

@@ -0,0 +1,44 @@
+/// <reference types="node" resolution-mode="require"/>
+import 'reflect-metadata';
+import { EventEmitter } from 'node:events';
+import { CameraController } from './camera/controller.js';
+import type { Camera, CameraExtensions } from './api/database/types.js';
+import type { StreamManager } from './decoder/worker/index.js';
+import type { BasePlugin } from './plugins/base.js';
+import type { API } from './plugins/node/api.js';
+import type { PluginLogger } from './plugins/node/logger.js';
+import type { CameraExtension } from './plugins/types.js';
+export interface PluginConstructor {
+    new (logger: PluginLogger, api: API): BasePlugin;
+}
+export declare const enum API_EVENT {
+    FINISH_LAUNCHING = "finishLaunching",
+    SHUTDOWN = "shutdown"
+}
+export declare interface CameraUiAPI {
+    on(event: 'finishLaunching', listener: () => void): this;
+    on(event: 'shutdown', listener: () => void): this;
+    emit(event: 'finishLaunching'): boolean;
+    emit(event: 'shutdown'): boolean;
+}
+export declare class CameraUiAPI extends EventEmitter {
+    private camerasMap;
+    constructor();
+    configureCameras(): Promise<void>;
+    addCamera(camera: Camera): Promise<{
+        controller: CameraController;
+        manager: StreamManager;
+    }>;
+    getCamera(cameraId: string): {
+        controller: CameraController;
+        manager: StreamManager;
+    } | undefined;
+    getCameras(pluginId?: string): {
+        controller: CameraController;
+        manager: StreamManager;
+    }[];
+    updateCamera(camera: Camera, extensions: CameraExtensions): void;
+    removeCamera(camera: Camera, extensions: CameraExtensions): Promise<void>;
+    selectCamera(pluginId: string, camera: Camera, extension: CameraExtension): void;
+    deselectCamera(pluginId: string, camera: Camera, extension: CameraExtension): void;
+}

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

@@ -1,8 +1,8 @@
-import { BaseCameraDevice } from '.';
-import { StreamingConnectionOptions } from '../streaming/peer-connection';
-import { StreamingSession } from '../streaming/streaming-session';
-import type { Frame } from '../../decoder/types';
-import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions } from '../types';
+import { StreamingConnectionOptions } from '../streaming/peer-connection.js';
+import { StreamingSession } from '../streaming/streaming-session.js';
+import { BaseCameraDevice } from './index.js';
+import type { Frame } from '../../decoder/types.js';
+import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions } from '../types.js';
 export declare abstract class CameraDevice extends BaseCameraDevice {
     private _delegate?;
     private _prebufferDelegate?;
@@ -12,6 +12,7 @@ export declare abstract class CameraDevice extends BaseCameraDevice {
     set prebufferDelegate(delegate: CameraPrebufferDelegate);
     abstract generateFrames(): AsyncIterableIterator<Frame>;
     abstract getFfmpegPath(): Promise<string>;
+    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>;

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

@@ -1,5 +1,6 @@
-import { BaseCameraDevice } from '.';
-import { BrowserStreamingSession } from '../streaming/browser/browser-streaming-session';
+import { BrowserStreamingSession } from '../streaming/browser/browser-streaming-session.js';
+import { BaseCameraDevice } from './index.js';
 export declare abstract class BrowserCameraDevice extends BaseCameraDevice {
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     createSession(sourceName: string, videoElement: HTMLVideoElement): Promise<BrowserStreamingSession>;
 }

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

@@ -1,7 +1,8 @@
+import { LRUCache } from 'lru-cache';
 import { BehaviorSubject, Observable, Subscription } from 'rxjs';
-import type { Camera, CameraInformation, CameraPublicProperties, CameraType, CameraZone } from '../../api/database/types';
-import type { IceServer } from '../../services/config/types';
-import type { AudioState, BaseLogger, BatteryState, CameraSource, DoorbellState, LightState, MotionState, ObjectState, OnSetEvent, SirenState, StateValues } from '../types';
+import type { Camera, CameraInformation, CameraPublicProperties, CameraType, CameraZone } from '../../api/database/types.js';
+import type { IceServer } from '../../services/config/types.js';
+import type { AudioSetEvent, AudioState, BaseLogger, BatterySetEvent, BatteryState, CameraSource, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, OnSetEvent, SirenSetEvent, SirenState, State, StateValues } from '../types.js';
 declare class Subscribed {
     private readonly subscriptions;
     private readonly additionalSubscriptions;
@@ -12,6 +13,7 @@ declare class Subscribed {
 }
 export declare abstract class BaseCameraDevice extends Subscribed {
     protected logger: BaseLogger;
+    protected snapshotCache: LRUCache<string, ArrayBuffer, unknown>;
     protected cameraSubject: BehaviorSubject<Camera>;
     protected cameraState: BehaviorSubject<boolean>;
     protected lightState: BehaviorSubject<LightState>;
@@ -73,8 +75,21 @@ export declare abstract class BaseCameraDevice extends Subscribed {
         newData: Camera[T];
     }>;
     removeAllListeners(): void;
+    protected getAudioState(event: AudioSetEvent): AudioState | undefined;
+    protected getMotionState(event: MotionSetEvent): MotionState | undefined;
+    protected getObjectState(event: ObjectSetEvent): ObjectState | undefined;
+    protected getDoorbellState(event: DoorbellSetEvent): DoorbellState | undefined;
+    protected getLightState(event: LightSetEvent): LightState | undefined;
+    protected getSirenState(event: SirenSetEvent): SirenState | undefined;
+    protected getBatteryState(event: BatterySetEvent): BatteryState | undefined;
     private createStateObservable;
     protected updateCamera(updatedCamera: Camera): void;
     protected updateCameraState(state: boolean): void;
+    protected stateChanged<T extends keyof StateValues>(oldState?: StateValues[T], newState?: StateValues[T]): boolean;
+    protected isAudioState(state: State): state is AudioState;
+    protected isMotionState(state: State): state is MotionState;
+    protected isObjectState(state: State): state is ObjectState;
+    protected isSirenState(state: State): state is SirenState;
+    protected isGenericState(state: State): state is DoorbellState;
 }
 export {};

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

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

package/dist/types/server/src/camera/streaming/browser/browser-peer-connection.d.ts

@@ -1,8 +1,8 @@
 import { ReplaySubject, Subject } from 'rxjs';
-import { Subscribed } from '../../utils/subscribed';
-import type { IceServer } from '../../../services/config/types';
-import type { BrowserCameraDevice as CameraDevice } from '../../base/cameraDeviceBrowser';
-import type { BaseLogger, BasicBrowserPeerConnection } from '../../types';
+import { Subscribed } from '../../utils/subscribed.js';
+import type { IceServer } from '../../../services/config/types.js';
+import type { BrowserCameraDevice as CameraDevice } from '../../base/cameraDeviceBrowser.js';
+import type { BaseLogger, BasicBrowserPeerConnection } from '../../types.js';
 export declare class BrowserPeerConnection extends Subscribed implements BasicBrowserPeerConnection {
     onIceCandidate: Subject<RTCIceCandidate>;
     onConnectionState: ReplaySubject<RTCPeerConnectionState>;

package/dist/types/server/src/camera/streaming/browser/browser-streaming-session.d.ts

@@ -1,8 +1,8 @@
 import { Observable, ReplaySubject } from 'rxjs';
-import { Subscribed } from '../../utils/subscribed';
-import type { BrowserCameraDevice as CameraDevice } from '../../base/cameraDeviceBrowser';
-import type { BaseLogger } from '../../types';
-import type { WebrtcBrowserConnection } from './webrtc-browser-connection';
+import { Subscribed } from '../../utils/subscribed.js';
+import type { BrowserCameraDevice as CameraDevice } from '../../base/cameraDeviceBrowser.js';
+import type { BaseLogger } from '../../types.js';
+import type { WebrtcBrowserConnection } from './webrtc-browser-connection.js';
 export declare class BrowserStreamingSession extends Subscribed {
     readonly onCallAnswered: ReplaySubject<void>;
     readonly onCallEnded: ReplaySubject<void>;

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

@@ -1,9 +1,9 @@
 import { ReplaySubject, type Observable } from 'rxjs';
-import { Subscribed } from '../../utils/subscribed';
-import { BrowserPeerConnection } from './browser-peer-connection';
-import type { IceServer } from '../../../services/config/types';
-import type { BrowserCameraDevice as CameraDevice } from '../../base/cameraDeviceBrowser';
-import type { BaseLogger } from '../../types';
+import { Subscribed } from '../../utils/subscribed.js';
+import { BrowserPeerConnection } from './browser-peer-connection.js';
+import type { IceServer } from '../../../services/config/types.js';
+import type { BrowserCameraDevice as CameraDevice } from '../../base/cameraDeviceBrowser.js';
+import type { BaseLogger } from '../../types.js';
 export declare class WebrtcBrowserConnection extends Subscribed {
     readonly onCallAnswered: ReplaySubject<string>;
     readonly onCallEnded: ReplaySubject<void>;

package/dist/types/server/src/camera/streaming/peer-connection.d.ts

@@ -1,10 +1,10 @@
 import { Observable, ReplaySubject, Subject } from 'rxjs';
 import { MediaStreamTrack, RTCSessionDescription, RTCIceCandidate as WeriftRTCICECandidate } from 'werift';
-import { Subscribed } from '../utils/subscribed';
+import { Subscribed } from '../utils/subscribed.js';
 import type { ConnectionState, RTCIceCandidate, RtcpPacket, RtpPacket } from 'werift';
-import type { IceServer } from '../../services/config/types';
-import type { CameraDevice } from '../base/cameraDevice';
-import type { BaseLogger } from '../types';
+import type { IceServer } from '../../services/config/types.js';
+import type { CameraDevice } from '../base/cameraDevice.js';
+import type { BaseLogger } from '../types.js';
 export interface BasicPeerConnection {
     createOffer(): Promise<RTCSessionDescription>;
     acceptAnswer(answer: {

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

@@ -1,9 +1,9 @@
 import { ReplaySubject, Subject } from 'rxjs';
 import { RtpPacket } from 'werift';
-import { Subscribed } from '../utils/subscribed';
-import type { CameraDevice } from '../base/cameraDevice';
-import type { BaseLogger, FfmpegOptions, SpawnInput } from '../types';
-import type { WebrtcConnection } from './webrtc-connection';
+import { Subscribed } from '../utils/subscribed.js';
+import type { CameraDevice } from '../base/cameraDevice.js';
+import type { BaseLogger, FfmpegOptions, SpawnInput } from '../types.js';
+import type { WebrtcConnection } from './webrtc-connection.js';
 export declare class StreamingSession extends Subscribed {
     readonly onCallEnded: ReplaySubject<void>;
     readonly onVideoRtp: Subject<RtpPacket>;

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

@@ -1,10 +1,10 @@
 import { ReplaySubject, Subject, type Observable } from 'rxjs';
-import { Subscribed } from '../utils/subscribed';
+import { Subscribed } from '../utils/subscribed.js';
 import type { RtpPacket } from 'werift';
-import type { IceServer } from '../../services/config/types';
-import type { CameraDevice } from '../base/cameraDevice';
-import type { BaseLogger } from '../types';
-import type { StreamingConnectionOptions } from './peer-connection';
+import type { IceServer } from '../../services/config/types.js';
+import type { CameraDevice } from '../base/cameraDevice.js';
+import type { BaseLogger } from '../types.js';
+import type { StreamingConnectionOptions } from './peer-connection.js';
 export declare class WebrtcConnection extends Subscribed {
     readonly onCameraConnected: ReplaySubject<void>;
     readonly onCallAnswered: ReplaySubject<string>;

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

@@ -1,6 +1,6 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 import type { Observable, Subject } from 'rxjs';
-import type { CameraInformation, CameraInput, CameraInputSettings } from '../api/database/types';
+import type { CameraInformation, CameraInput, CameraInputSettings } from '../api/database/types.js';
 export type SpawnInput = string | number;
 export type PrebufferType = 'recording' | 'stream';
 export interface CameraSource extends CameraInput {
@@ -100,25 +100,31 @@ export type CameraConfig = (BaseCameraConfig & {
 }) | (BaseCameraConfig & {
     delegate?: CameraDelegate;
 });
-export interface BaseState {
-    timestamp: number;
-    lastTriggered: number;
-}
-export interface Detections {
+export interface BaseDetection {
     id?: string;
-    label?: string;
+}
+export interface MotionDetection extends BaseDetection {
+    label: string;
+    boundingBox: [number, number, number, number];
+}
+export interface ObjectDetection extends BaseDetection {
+    lebel: string;
     boundingBox: [number, number, number, number];
 }
+export interface BaseState<T> {
+    timestamp: number;
+    lastEvent?: T;
+}
 export interface MotionSetEvent {
     state: boolean;
-    detections: Detections[];
+    detections: MotionDetection[];
 }
 export interface AudioSetEvent {
     state: boolean;
+    db?: number;
 }
 export interface ObjectSetEvent {
-    state: boolean;
-    detections: Detections[];
+    detections: ObjectDetection[];
 }
 export interface LightSetEvent {
     state: boolean;
@@ -128,19 +134,20 @@ export interface DoorbellSetEvent {
 }
 export interface SirenSetEvent {
     state: boolean;
+    level?: number;
 }
 export interface BatterySetEvent {
-    state: number;
-}
-export interface DeviceSetEvent {
-}
-export type LightState = BaseState & LightSetEvent;
-export type MotionState = BaseState & MotionSetEvent;
-export type AudioState = BaseState & AudioSetEvent;
-export type DoorbellState = BaseState & DoorbellSetEvent;
-export type SirenState = BaseState & SirenSetEvent;
-export type ObjectState = BaseState & ObjectSetEvent;
-export type BatteryState = BaseState & BatterySetEvent;
+    level: number;
+    lowBattery?: boolean;
+    charging?: boolean;
+}
+export type LightState = BaseState<LightState> & LightSetEvent;
+export type MotionState = BaseState<MotionState> & MotionSetEvent;
+export type AudioState = BaseState<AudioState> & AudioSetEvent;
+export type DoorbellState = BaseState<DoorbellState> & DoorbellSetEvent;
+export type SirenState = BaseState<SirenState> & SirenSetEvent;
+export type ObjectState = BaseState<ObjectState> & ObjectSetEvent;
+export type BatteryState = BaseState<BatteryState> & BatterySetEvent;
 export type State = LightState | MotionState | AudioState | ObjectState | DoorbellState | SirenState | BatteryState;
 export interface StateValues {
     light: LightState;

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

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

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

@@ -1,12 +1,16 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { ChildProcess } from 'child_process';
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { ChildProcess } from 'node:child_process';
 export interface FrameMetadata {
     format: string;
     frameSize: number;
     width: number;
     height: number;
 }
+export interface FrameSession {
+    token: string;
+    wsPort: number;
+}
 export interface Frame {
     metadata: FrameMetadata;
     data: Buffer;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,34 @@
+import { NatsConnection, Subscription } from 'nats';
+import { CameraDeviceProxy } from './proxy/cameraDevice.js';
+import { DeviceManagerProxy, PluginsManagerProxy, SystemManagerProxy } from './proxy/index.js';
+import { NatsServer } from './server.js';
+import type { StateValues } from '../camera/types.js';
+import type { CameraDeviceListenerMessagePayload, DeviceManagerProxyEvents, PluginsManagerProxyEvents, ProxyAuth, SystemManagerProxyEvents } from './types.js';
+import type { WebsocketProxy } from './websocket.js';
+export declare class ProxyServer {
+    private api;
+    private logger;
+    deviceManagerProxy?: DeviceManagerProxy;
+    pluginsManagerProxy?: PluginsManagerProxy;
+    systemManagerProxy?: SystemManagerProxy;
+    cameraDeviceProxy?: CameraDeviceProxy;
+    websocketProxy?: WebsocketProxy;
+    server: NatsServer;
+    publisher?: NatsConnection;
+    subscriber?: Subscription;
+    private messageQueue;
+    private initialized;
+    auth: ProxyAuth;
+    constructor();
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    publishDeviceManagerEvent<K extends keyof DeviceManagerProxyEvents>(targetId: string, type: K, data: DeviceManagerProxyEvents[K]): void;
+    publishSystemManagerEvent<K extends keyof SystemManagerProxyEvents>(targetId: string, type: K, data: SystemManagerProxyEvents[K]): void;
+    publishPluginsManagerEvent<K extends keyof PluginsManagerProxyEvents>(targetId: string, type: K, data: PluginsManagerProxyEvents[K]): void;
+    publishCameraEvent<K extends keyof StateValues>(cameraId: string, stateName: K, data: {
+        newEvent: StateValues[K];
+        oldEvent: StateValues[K];
+    }, targetId?: string): void;
+    publishCameraEvent(cameraId: string, type: CameraDeviceListenerMessagePayload['type'], data?: any, targetId?: string): void;
+    private isCameraState;
+}