@camera.ui/browser 0.0.71 → 0.0.73

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

@@ -0,0 +1,2 @@
+import type { FastifyPluginAsync } from 'fastify';
+export declare const UsersRoute: FastifyPluginAsync;

package/dist/types/server/src/api/schemas/plugins.schema.d.ts

@@ -0,0 +1,25 @@
+import zod from 'zod';
+export declare const installPluginSchema: zod.ZodObject<{
+    pluginname: zod.ZodEffects<zod.ZodString, string, string>;
+    pluginversion: zod.ZodDefault<zod.ZodOptional<zod.ZodString>>;
+}, "strict", zod.ZodTypeAny, {
+    pluginname: string;
+    pluginversion: string;
+}, {
+    pluginname: string;
+    pluginversion?: string | undefined;
+}>;
+export declare const actionPluginSchema: zod.ZodObject<{
+    actionId: zod.ZodString;
+    payload: zod.ZodAny;
+}, "strict", zod.ZodTypeAny, {
+    actionId: string;
+    payload?: any;
+}, {
+    actionId: string;
+    payload?: any;
+}>;
+export declare const patchPluginConfigJsonSchema: zod.ZodRecord<zod.ZodAny, zod.ZodAny>;
+export type InstallPluginInput = zod.TypeOf<typeof installPluginSchema>;
+export type ActionPluginInput = zod.TypeOf<typeof actionPluginSchema>;
+export type PatchPluginConfigJsonInput = zod.TypeOf<typeof patchPluginConfigJsonSchema>;

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

@@ -0,0 +1,10 @@
+import type { BackupInfo, MultipartFile, UiLocalStorage } from '../types/index.js';
+export declare class BackupService {
+    private logger;
+    private configService;
+    private socketService;
+    constructor();
+    createBackup(localStorage?: Partial<UiLocalStorage>): Promise<BackupInfo>;
+    restoreBackup(file: MultipartFile): Promise<any>;
+    removeBackup(backup: BackupInfo): Promise<void>;
+}

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

@@ -0,0 +1,2 @@
+declare const axiosInstance: import("axios").AxiosInstance;
+export default axiosInstance;

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

@@ -0,0 +1,11 @@
+import forge from 'node-forge';
+export interface CertKey {
+    cert: string;
+    certPath: string;
+    key: string;
+    keyPath: string;
+}
+export declare const getCert: () => CertKey;
+export declare const createRootCA: (customAddresses?: string[]) => CertKey;
+export declare const createCSR: (addresses: string[], keys: forge.pki.rsa.KeyPair) => Partial<CertKey>;
+export declare const createCert: (customAddresses?: string[]) => CertKey;

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

@@ -0,0 +1 @@
+export declare const moveFiles: (sourceDir: string, targetDir: string) => Promise<void>;

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

@@ -1,5 +1,5 @@
 import type { Namespace, Server, Socket } from 'socket.io';
-import { PLUGIN_STATUS } from '../../../plugins/types.js';
+import type { PLUGIN_STATUS } from '../../../plugins/types.js';
 import { RUNTIME_STATUS } from '../../../services/config/types.js';
 import type { SocketNsp } from '../types.js';
 export declare class StatusNamespace {

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

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

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

@@ -1,9 +1,9 @@
 /// <reference types="node" resolution-mode="require"/>
 import 'reflect-metadata';
 import { EventEmitter } from 'node:events';
-import { CameraController } from './camera/controller.js';
+import { CameraController } from './devices/camera/controller/index.js';
 import type { Camera, CameraExtensions } from './api/database/types.js';
-import type { StreamManager } from './decoder/worker/index.js';
+import type { FrameWorker } 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';
@@ -27,15 +27,15 @@ export declare class CameraUiAPI extends EventEmitter {
     configureCameras(): Promise<void>;
     addCamera(camera: Camera): Promise<{
         controller: CameraController;
-        manager: StreamManager;
+        worker: FrameWorker;
     }>;
     getCamera(cameraId: string): {
         controller: CameraController;
-        manager: StreamManager;
+        worker: FrameWorker;
     } | undefined;
     getCameras(pluginId?: string): {
         controller: CameraController;
-        manager: StreamManager;
+        worker: FrameWorker;
     }[];
     updateCamera(camera: Camera, extensions: CameraExtensions): void;
     removeCamera(camera: Camera, extensions: CameraExtensions): Promise<void>;

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

@@ -0,0 +1 @@
+export declare function buildFfmpegArguments(ffmpegPath: string, streamUrl: string, port: number): Promise<string[]>;

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

@@ -1,11 +1,22 @@
-import type { CameraController } from '../camera/controller.js';
-import type { StreamManager } from './worker/index.js';
-export declare class Decoder {
-    streamManagers: Map<string, StreamManager<any>>;
+import { FrameWorker } from './worker/index.js';
+import type { CameraController } from '../devices/camera/controller/index.js';
+export declare class FrameManager {
+    frameWorkers: Map<string, FrameWorker>;
+    private initialized;
     private api;
     private proxyServer;
-    private startAsWorker;
+    private logger;
+    private publisher?;
+    private subscriber?;
+    private subject;
     constructor();
-    addCamera(camera: CameraController): Promise<StreamManager>;
+    init(): Promise<void>;
+    addCamera(camera: CameraController): Promise<FrameWorker>;
     removeCamera(camera: CameraController): Promise<void>;
+    private handleConnectMessage;
+    private handleDisconnectMessage;
+    private disconnectClient;
+    private disconnectAllClients;
+    private startPingPongForClient;
+    private listenToMessages;
 }

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

@@ -1,53 +1,100 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 import type { ChildProcess } from 'node:child_process';
+import type { ResizeOptions, RotateOptions, Sharp } from 'sharp';
 export interface FrameMetadata {
     format: string;
     frameSize: number;
     width: number;
+    origWidth: number;
     height: number;
+    origHeight: number;
 }
-export interface FrameSession {
-    token: string;
-    wsPort: number;
+export interface ImageCrop {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
 }
-export interface Frame {
-    metadata: FrameMetadata;
+export interface ImageResize {
+    width?: number;
+    height?: number;
+    options?: ResizeOptions;
+}
+export interface ImageRotate {
+    angle: number;
+    options?: RotateOptions;
+}
+export interface ImageFormat {
+    format: 'rgba' | 'gray';
+}
+export interface ImageOptions {
+    format?: ImageFormat;
+    crop?: ImageCrop;
+    resize?: ImageResize;
+    rotate?: ImageRotate;
+}
+export interface ProcessImageRequest {
+    options: ImageOptions;
     data: Buffer;
 }
+export interface VideoFrame {
+    metadata: FrameMetadata;
+    inputWidth: number;
+    inputHeight: number;
+    inputFormat: string;
+    toBuffer: (options?: ImageOptions) => Promise<Buffer>;
+    toImage: (options?: ImageOptions) => Promise<Sharp>;
+}
 export interface VideoSession {
     isActive(): boolean;
     kill: (reason?: string) => void;
     cp: ChildProcess;
 }
 export interface BaseFrameWorkerConfig {
+    frameWorkerId: string;
     cameraId: string;
     cameraName: string;
     ffmpegPath: string;
-    logLevel?: string;
-    disableTimestamps?: boolean;
+    logLevel: string;
+    disableTimestamps: boolean;
     auth: {
         user: string;
         pass: string;
     };
 }
-export type WorkerMessage = 'ready' | 'getCameraSource';
-export type MainMessage = 'getMetadata' | 'startWorker' | 'stopWorker' | 'startVideoSession' | 'stopVideoSession' | 'setCameraName';
+export type WorkerMessage = 'started' | 'getFFmpegArgs';
+export type MainMessage = 'getMetadata' | 'startVideoSession' | 'stopVideoSession' | 'setCameraName';
 export interface MainToWorkerMessage {
-    id: string;
     message: MainMessage;
     data: Record<string, any>;
 }
 export interface WorkerToMainResponse {
-    id: string;
-    response: any;
+    response?: Record<string, any>;
 }
 export interface WorkerToMainMessage {
-    id: string;
     message: WorkerMessage;
     data: Record<string, any>;
 }
 export interface MainToWorkerResponse {
-    id: string;
-    response: any;
+    response?: Record<string, any>;
+}
+export interface SignalingRequest {
+    type: 'connect' | 'disconnect';
+    requestId: string;
+    cameraId: string;
+    pluginId: string;
+}
+export interface SignalingResponse {
+    type: 'connected' | 'disconnected' | 'error';
+    requestId: string;
+    message?: string;
+}
+export interface PingMessage {
+    type: 'ping';
+    requestId: string;
+}
+export interface PongMessage {
+    type: 'pong';
+    requestId: string;
 }

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

@@ -1,3 +1,42 @@
-export { StreamManager } from './runtime/base/index.js';
-export { StreamProcess } from './runtime/child-process/index.js';
-export { StreamWorker } from './runtime/worker-thread/index.js';
+import { Subscribed } from '../../utils/subscribed.js';
+import type { CameraController } from '../../devices/camera/controller/index.js';
+import type { FrameMetadata } from '../types.js';
+interface FrameWorkerClient {
+    pluginId: string;
+    requestIds: string[];
+}
+export declare class FrameWorker extends Subscribed {
+    token: string;
+    readonly clients: Map<string, FrameWorkerClient>;
+    private subject;
+    private ipcSubject;
+    private frameWorkerId;
+    private publisher?;
+    private subscriber?;
+    private logger;
+    private configService;
+    private camera;
+    private frameWorker?;
+    private initialized;
+    private stopped;
+    private auth;
+    private ffmpegArgs;
+    private py;
+    constructor(camera: CameraController, auth: {
+        user: string;
+        pass: string;
+    });
+    init(): Promise<void>;
+    close(): Promise<void>;
+    workerPID(): number;
+    getMetadata(): Promise<FrameMetadata>;
+    addClient(pluginId: string, requestId: string): Promise<void>;
+    removeClient(pluginId: string, requestId: string): Promise<void>;
+    private startVideoSession;
+    private stopVideoSession;
+    private startWorker;
+    private sendMessage;
+    private listenToMessages;
+    private getLogPrefix;
+}
+export {};

package/dist/types/server/src/{camera/base → devices/camera}/cameraDevice.d.ts

@@ -1,8 +1,8 @@
-import { StreamingSession } from '../streaming/streaming-session.js';
 import { BaseCameraDevice } from './index.js';
-import type { Frame } from '../../decoder/types.js';
-import type { StreamingConnectionOptions } from '../streaming/peer-connection.js';
-import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions } from '../types.js';
+import { StreamingSession } from './streaming/streaming-session.js';
+import type { VideoFrame } from '../../decoder/types.js';
+import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions } from './controller/types.js';
+import type { StreamingConnectionOptions } from './streaming/peer-connection.js';
 export declare abstract class CameraDevice extends BaseCameraDevice {
     private _delegate?;
     private _prebufferDelegate?;
@@ -10,7 +10,7 @@ export declare abstract class CameraDevice extends BaseCameraDevice {
     set delegate(delegate: CameraDelegate);
     get prebufferDelegate(): CameraPrebufferDelegate | undefined;
     set prebufferDelegate(delegate: CameraPrebufferDelegate);
-    abstract generateFrames(): AsyncIterableIterator<Frame>;
+    abstract generateFrames(): AsyncIterableIterator<VideoFrame>;
     abstract getFfmpegPath(): Promise<string>;
     snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<StreamingSession>;

package/dist/types/server/src/{camera/controller.d.ts → devices/camera/controller/index.d.ts}

@@ -1,8 +1,8 @@
-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 { CameraDevice } from '../cameraDevice.js';
+import type { Camera } from '../../../api/database/types.js';
+import type { VideoFrame } 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;
@@ -13,7 +13,7 @@ export declare class CameraController extends CameraDevice {
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     reboot(): Promise<void>;
-    generateFrames(): AsyncIterableIterator<Frame>;
+    generateFrames(): AsyncIterableIterator<VideoFrame>;
     getFfmpegPath(): Promise<string>;
     getIceServers(): Promise<IceServer[]>;
     updateCamera(updatedCamera: Camera): void;

package/dist/types/server/src/{camera → devices/camera/controller}/types.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
-import type { Observable, Subject } from 'rxjs';
-import type { CameraInformation, CameraInput, CameraInputSettings } from '../api/database/types.js';
+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 {
@@ -21,19 +20,6 @@ export interface FfmpegOptions {
     audio?: SpawnInput[];
     output: SpawnInput[];
 }
-export interface BasicBrowserPeerConnection {
-    enableMicrophone(track: MediaStreamTrack): void;
-    disableMicrophone(): void;
-    createOffer(): Promise<RTCSessionDescriptionInit>;
-    acceptAnswer(answer: {
-        type: 'answer';
-        sdp: string;
-    }): Promise<void>;
-    addIceCandidate(candidate: Partial<RTCIceCandidate>): Promise<void>;
-    onIceCandidate: Subject<RTCIceCandidate>;
-    onConnectionState: Observable<RTCPeerConnectionState>;
-    close(): void;
-}
 export interface CameraDelegate {
     snapshotRequest(requestId: string): Promise<Buffer>;
     prepareStream(requestId: string): Promise<void>;
@@ -102,17 +88,20 @@ export type CameraConfig = (BaseCameraConfig & {
 });
 export interface BaseDetection {
     id?: string;
-}
-export interface MotionDetection extends BaseDetection {
     label: string;
+    confidence: number;
     boundingBox: [number, number, number, number];
+    inputWidth: number;
+    inputHeight: number;
+    origWidth: number;
+    origHeight: number;
+}
+export interface MotionDetection extends BaseDetection {
 }
 export interface ObjectDetection extends BaseDetection {
-    lebel: string;
-    boundingBox: [number, number, number, number];
 }
 export interface BaseState<T extends LightState | AudioState | MotionState | ObjectState | SirenState | BatteryState | DoorbellState> {
-    timestamp: number;
+    timestamp: string;
     lastEvent?: Omit<T, 'lastEvent'>;
 }
 export interface MotionSetEvent {
@@ -148,7 +137,8 @@ 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 type States = LightState | MotionState | AudioState | ObjectState | DoorbellState | SirenState | BatteryState;
+export type Sets = LightSetEvent | MotionSetEvent | AudioSetEvent | ObjectSetEvent | DoorbellSetEvent | SirenSetEvent | BatterySetEvent;
 export interface StateValues {
     light: LightState;
     motion: MotionState;

package/dist/types/server/src/{camera/base → devices/camera}/index.d.ts

@@ -1,8 +1,9 @@
 import { LRUCache } from 'lru-cache';
-import { BehaviorSubject, Observable, Subscription } from 'rxjs';
+import { BehaviorSubject } from 'rxjs';
+import type { Observable, Subscription } from 'rxjs';
 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, SetValues, SirenSetEvent, SirenState, State, StateValues } from '../types.js';
+import type { AudioSetEvent, AudioState, BaseLogger, BatterySetEvent, BatteryState, CameraSource, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, SetValues, Sets, SirenSetEvent, SirenState, StateValues, States } from './controller/types.js';
 declare class Subscribed {
     private readonly subscriptions;
     private readonly additionalSubscriptions;
@@ -75,22 +76,23 @@ 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;
+    protected getAudioState(event: AudioSetEvent): AudioState;
+    protected getMotionState(event: MotionSetEvent): MotionState;
+    protected getObjectState(event: ObjectSetEvent): ObjectState;
+    protected getDoorbellState(event: DoorbellSetEvent): DoorbellState;
+    protected getLightState(event: LightSetEvent | LightState): LightState;
+    protected getSirenState(event: SirenSetEvent): SirenState;
+    protected getBatteryState(event: BatterySetEvent): BatteryState;
     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 isBatteryState(state: State): state is BatteryState;
-    protected isGenericState(state: State): state is DoorbellState;
+    protected stateChanged<T extends keyof SetValues>(oldState?: SetValues[T], newState?: SetValues[T]): boolean;
+    protected isAudioState(state: Sets): state is AudioSetEvent;
+    protected isMotionState(state: Sets): state is MotionSetEvent;
+    protected isObjectState(state: Sets): state is ObjectSetEvent;
+    protected isSirenState(state: Sets): state is SirenSetEvent;
+    protected isBatteryState(state: Sets): state is BatterySetEvent;
+    protected isGenericState(state: Sets): state is DoorbellSetEvent;
+    protected isStateEvent(state: States | Sets): state is States;
 }
 export {};

package/dist/types/server/src/{camera → devices/camera}/streaming/peer-connection.d.ts

@@ -1,10 +1,11 @@
-import { Observable, ReplaySubject, Subject } from 'rxjs';
-import { MediaStreamTrack, RTCSessionDescription, RTCIceCandidate as WeriftRTCICECandidate } from 'werift';
-import { Subscribed } from '../utils/subscribed.js';
-import type { ConnectionState, RTCIceCandidate, RtcpPacket, RtpPacket } from 'werift';
-import type { IceServer } from '../../services/config/types.js';
-import type { CameraDevice } from '../base/cameraDevice.js';
-import type { BaseLogger } from '../types.js';
+import { ReplaySubject, Subject } from 'rxjs';
+import { MediaStreamTrack } from 'werift';
+import { Subscribed } from '../../../utils/subscribed.js';
+import type { Observable } from 'rxjs';
+import type { ConnectionState, RTCIceCandidate, RTCSessionDescription, RtcpPacket, RtpPacket, RTCIceCandidate as WeriftRTCICECandidate } from 'werift';
+import type { IceServer } from '../../../services/config/types.js';
+import type { CameraDevice } from '../cameraDevice.js';
+import type { BaseLogger } from '../controller/types.js';
 export interface BasicPeerConnection {
     createOffer(): Promise<RTCSessionDescription>;
     acceptAnswer(answer: {
@@ -25,8 +26,8 @@ export declare class WeriftPeerConnection extends Subscribed implements BasicPee
     onAudioRtcp: Subject<RtcpPacket>;
     onVideoRtp: Subject<RtpPacket>;
     onVideoRtcp: Subject<RtcpPacket>;
-    onIceCandidate: Subject<WeriftRTCICECandidate>;
-    onConnectionState: ReplaySubject<"closed" | "connected" | "connecting" | "disconnected" | "failed" | "new">;
+    onIceCandidate: Subject<RTCIceCandidate>;
+    onConnectionState: ReplaySubject<"connected" | "disconnected" | "closed" | "failed" | "new" | "connecting">;
     returnAudioTrack: MediaStreamTrack;
     private onRequestKeyFrame;
     private cameraDevice;

package/dist/types/server/src/{camera → devices/camera}/streaming/streaming-session.d.ts

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

package/dist/types/server/src/{camera → devices/camera}/streaming/webrtc-connection.d.ts

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

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

@@ -0,0 +1,21 @@
+import 'reflect-metadata';
+export declare class CameraUi {
+    private started;
+    private api;
+    private logger;
+    private configService;
+    private pluginManager;
+    private go2rtc;
+    private server;
+    private proxy;
+    private frameManager;
+    private _restartAttempts;
+    private _maxRestartAttempts;
+    get restartAttempts(): number;
+    get maxRestartAttempts(): number;
+    constructor();
+    start(): Promise<void>;
+    close(): Promise<void>;
+    restart(...args: any[]): Promise<void>;
+    private init;
+}

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

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

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

@@ -2,7 +2,7 @@ import { type NatsConnection, type 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 { StateValues } from '../devices/camera/controller/types.js';
 import type { CameraDeviceListenerMessagePayload, DeviceManagerProxyEvents, PluginsManagerProxyEvents, ProxyAuth, SystemManagerProxyEvents } from './types.js';
 import type { WebsocketProxy } from './websocket.js';
 export declare class ProxyServer {

package/dist/types/server/src/nats/proxy/cameraDevice.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { Camera } from '../../api/database/types.js';
-import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions, PrebufferType, SetValues, StateValues, StreamInfo } from '../../camera/types.js';
-import type { FrameMetadata, FrameSession } from '../../decoder/types.js';
+import type { FrameMetadata } from '../../decoder/types.js';
+import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions, PrebufferType, SetValues, StateValues, StreamInfo } from '../../devices/camera/controller/types.js';
 import type { IceServer } from '../../services/config/types.js';
 import type { MessageQueue } from '../queue.js';
 import type { CameraDeviceProxyMethods, ProxyMessageStructure } from '../types.js';
@@ -46,10 +46,6 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): Promise<FrameMetadata>;
-    getFrameSession(data: {
-        cameraId: string;
-        pluginId: string;
-    }): Promise<FrameSession>;
     getFfmpegPath(): string;
     getIceServers(): IceServer[];
     snapshot(data: {

package/dist/types/server/src/nats/proxy/deviceManager.d.ts

@@ -1,5 +1,5 @@
 import type { Camera } from '../../api/database/types.js';
-import type { CameraConfig } from '../../camera/types.js';
+import type { CameraConfig } from '../../devices/camera/controller/types.js';
 import type { MessageQueue } from '../queue.js';
 import type { DeviceManagerServerProxyMethods, ProxyMessageStructure } from '../types.js';
 export declare class DeviceManagerProxy implements DeviceManagerServerProxyMethods {

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

@@ -2,14 +2,14 @@ import { RUNTIME_STATUS } from '../services/config/types.js';
 import type { ProxyAuth } from './types.js';
 export declare class NatsServer {
     readonly serverPort = 4222;
-    readonly websocketPort = 8223;
     private readonly clusterAmount;
-    private readonly serverClusterPort;
     private readonly auth;
+    private clusterPort?;
     private serverProcess?;
     private clusterProcesses;
     private logger;
     private configService;
+    private process;
     private tmpDir;
     private manuallyKilled;
     private shuttingDown;
@@ -27,6 +27,7 @@ export declare class NatsServer {
     private stringifyConfig;
     private kill;
     private handleClose;
+    private handleCloseCluster;
     private setStatus;
     private processLogger;
     private isIgnorableString;