@camera.ui/browser 0.0.79 → 0.0.80

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

@@ -1,5 +1,5 @@
-import { type CameraExtension } from '../../plugins/types.js';
-import type { Camera, CameraZone, DBCamera } from '../database/types.js';
+import type { CameraExtension } from '../../plugins/types.js';
+import type { Camera, CameraInputSettings, CameraZone, DBCamera } from '../database/types.js';
 type DeepPartial<T> = T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
@@ -12,11 +12,11 @@ export declare class CamerasService {
     private pluginsService;
     constructor();
     createCamera(cameraData: DBCamera): Promise<DBCamera>;
-    createTransformedCamera(cameraData: DBCamera): Promise<Camera>;
+    createTransformedCamera(cameraData: DBCamera, cameraSources: CameraInputSettings[]): Promise<Camera>;
     createZone(cameraname: string, zoneData: CameraZone): Promise<DBCamera | undefined>;
     patchZoneByName(cameraname: string, zonename: string, zoneData: CameraZone): Promise<DBCamera | undefined>;
     removeZoneByName(cameraname: string, zonename: string): Promise<void>;
-    createCameraSource(cameraname: string, sourceName: string, address: string): Promise<void>;
+    createCameraSource(cameraname: string, sourceName: string, source: string): Promise<void>;
     resetCameraSource(cameraname: string, sourceName: string): Promise<void>;
     list(): DBCamera[];
     listTransformed(): Camera[];
@@ -42,9 +42,11 @@ export declare class CamerasService {
     removeByPluginIdAndName(cameraname: string, pluginId: string): Promise<void>;
     removeAll(): Promise<void>;
     transformCamera(camera: DBCamera): Camera;
-    cameraSourcesChanged(oldCamera: DBCamera, newCamera: DBCamera): boolean;
-    private addCameraSources;
-    private removeCameraSources;
+    createEmptySource(cameraId: string, source: CameraInputSettings): CameraInputSettings;
+    addCameraSources(cameraname: string, sources: CameraInputSettings[]): Promise<void>;
+    removeCameraSources(cameraname: string, sources: CameraInputSettings[]): Promise<void>;
+    private sourceExistAndEqual;
+    private sourceResetted;
     private generateWsUrls;
     private generateRTSPUrls;
     private generateFFmpegUrls;

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

@@ -1,4 +1,4 @@
-import type { DBUser } from '../database/types.js';
+import type { DBCamviewLayout, DBUser } from '../database/types.js';
 export declare class UsersService {
     private dbs;
     constructor();
@@ -6,7 +6,11 @@ export declare class UsersService {
     findById(id: string): DBUser | undefined;
     findByName(username: string): DBUser | undefined;
     list(): DBUser[];
-    patchUser(username: string, userData: Partial<DBUser>): Promise<DBUser | undefined>;
+    patchUser(username: string, userData?: Partial<DBUser>): Promise<DBUser | undefined>;
     removeByName(username: string): Promise<void>;
     removeAll(): Promise<void>;
+    createView(username: string, viewData: DBCamviewLayout): Promise<DBCamviewLayout>;
+    patchViewById(username: string, viewId: string, viewData?: Partial<DBCamviewLayout>): Promise<DBCamviewLayout | undefined>;
+    removeViewById(username: string, viewId: string): Promise<DBCamviewLayout[] | undefined>;
+    removeAllViews(username: string): Promise<DBCamviewLayout[] | undefined>;
 }

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

@@ -7,7 +7,7 @@ import type { RestoreBackupInput } from '../schemas/backup.schema.js';
 import type { CreateCameraInput, PatchCameraInput, PreviewCameraInput } from '../schemas/cameras.schema.js';
 import type { PatchConfigInput } from '../schemas/config.schema.js';
 import type { PatchGo2RtcConfigInput } from '../schemas/go2rtc.schema.js';
-import type { CreateUserInput, LoginUserInput, PatchUserInput } from '../schemas/users.schema.js';
+import type { CreateUserInput, CreateViewInput, LoginUserInput, PatchUserInput, PatchViewInput } from '../schemas/users.schema.js';
 export interface BusboyFileStream extends Readable {
     truncated: boolean;
     bytesRead: number;
@@ -114,6 +114,10 @@ export interface UsersResponse {
     pagination: Pagination;
     result: DBUser[];
 }
+export interface ViewsResponse {
+    pagination: Pagination;
+    result: DBCamviewLayout[];
+}
 export interface CamerasResponse {
     pagination: Pagination;
     result: DBCamera[];
@@ -340,6 +344,17 @@ export type UsersPatchRequest = {
         avatar: string;
     };
 };
+export type ViewsParamsRequest = {
+    Params: {
+        viewId: string;
+    };
+};
+export type ViewsInsertRequest = {
+    Body: CreateViewInput;
+};
+export type ViewsPatchRequest = {
+    Body: PatchViewInput;
+};
 export type BackupCreateRequest = {
     Body: {
         localStorage: Partial<UiLocalStorage>;
@@ -348,6 +363,7 @@ export type BackupCreateRequest = {
 export type StreamsParamsNameRequest = {
     Params: {
         id: string;
+        name: string;
     };
 };
 export interface BackupInfo {
@@ -357,16 +373,28 @@ export interface BackupInfo {
 }
 export type SupportedLanguageAbbreviatons = 'de' | 'en';
 export type SupportedThemes = 'light' | 'dark';
+export interface ConfigSettings {
+    zoom: number;
+}
+export interface ConsoleSettings {
+    zoom: number;
+}
+export type CamviewSettingsLayoutMode = 'dnd' | 'view';
+export interface CamviewSettings {
+    dragDisabled?: boolean;
+    viewId?: string;
+}
+export interface UiSettingsLocalStorage {
+    config: ConfigSettings;
+    console: ConsoleSettings;
+    camview: CamviewSettings;
+}
 export interface ThemeLocalStorage {
     theme: SupportedThemes;
     autoMode: boolean;
 }
-export interface CamviewLocalStorage {
-    currentLayout: DBCamviewLayout;
-    preferences: DBCamviewLayout[];
-}
 export interface UiLocalStorage {
-    layout: CamviewLocalStorage;
+    ui: UiSettingsLocalStorage;
     theme: ThemeLocalStorage;
     locale: SupportedLanguageAbbreviatons;
 }

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

@@ -1,6 +1,6 @@
+import { RUNTIME_STATUS } from '../../../services/config/types.js';
 import type { Namespace, Server, Socket } from 'socket.io';
 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 {
     nsp: Namespace;

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

@@ -1,29 +1,36 @@
-import { CameraDevice } from './device.js';
+import { BaseCameraDevice } from './index.js';
+import { CameraAudioDetectionInterface } from './interfaces/audioDetection.js';
+import { CameraMotionDetectionInterface } from './interfaces/motionDetection.js';
+import { CameraObjectDetectionInterface } from './interfaces/objectDetection.js';
+import { CameraPrebufferInterface } from './interfaces/prebuffer.js';
+import { CameraPTZInterface } from './interfaces/ptz.js';
 import type { Camera } from '../api/database/types.js';
-import type { MotionFrame, VideoFrame } from '../decoder/types.js';
 import type { ProxyServer } from '../nats/index.js';
 import type { IceServer } from '../services/config/types.js';
-import type { BaseLogger, CameraSource, SetValues } from './types.js';
-export declare class CameraController extends CameraDevice {
-    private proxy;
+import type { BaseLogger, CameraConfigInputSettings, CameraSource, SetValues } from './types.js';
+export declare class CameraController extends BaseCameraDevice {
+    proxy: ProxyServer;
     private motionTimeout?;
     private objectTimeout?;
     private objectTimeoutDuration;
     private doorbellTimeout?;
     private doorbellTimeoutDuration;
     private prebufferStateSubscriptions;
+    protected prebufferDelegate: CameraPrebufferInterface;
+    ptzDelegate: CameraPTZInterface;
+    audioDetectorDelegate: CameraAudioDetectionInterface;
+    motionDetectorDelegate: CameraMotionDetectionInterface;
+    objectDetectorDelegate: CameraObjectDetectionInterface;
     get camera(): Camera;
     get sources(): CameraSource[];
     constructor(camera: Camera, logger: BaseLogger, proxy: ProxyServer);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    reboot(): Promise<void>;
-    getFrames(): AsyncIterableIterator<VideoFrame>;
-    getMotionFrames(): AsyncIterableIterator<MotionFrame>;
-    getPrebufferedFrames(): AsyncIterableIterator<VideoFrame>;
-    getFfmpegPath(): Promise<string>;
     getIceServers(): Promise<IceServer[]>;
     updateState<T extends keyof SetValues>(stateName: T, eventData: SetValues[T]): Promise<void>;
+    addCameraSource(source: CameraConfigInputSettings): Promise<void>;
+    updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>): Promise<void>;
+    removeCameraSource(sourceId: string): Promise<void>;
     updateCamera(updatedCamera: Camera): void;
     cleanup(): void;
     private subscribeToCameraState;

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

@@ -1,26 +1,18 @@
 import { BehaviorSubject } from 'rxjs';
 import { BaseCameraDevice } from './index.js';
-import { StreamingSession } from './streaming/streaming-session.js';
+import { WeriftSession } from './streaming/werift-session.js';
 import type { Observable } from 'rxjs';
 import type { MotionFrame, VideoFrame } from '../decoder/types.js';
 import type { StreamingConnectionOptions } from './streaming/peer-connection.js';
-import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions, FrameState } from './types.js';
+import type { CameraDelegates, FrameState } from './types.js';
 export declare abstract class CameraDevice extends BaseCameraDevice {
     protected readonly frameState: BehaviorSubject<FrameState>;
     protected readonly onFrame: Observable<FrameState>;
-    private _delegate?;
-    private _prebufferDelegate?;
-    get delegate(): CameraDelegate | undefined;
-    set delegate(delegate: CameraDelegate);
-    get prebufferDelegate(): CameraPrebufferDelegate | undefined;
-    set prebufferDelegate(delegate: CameraPrebufferDelegate);
+    abstract setDelegate<T extends keyof CameraDelegates>(name: T, delegate: CameraDelegates[T]): void;
+    createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<WeriftSession>;
+    removeAllListeners(): void;
     abstract getFrames(prebufferDuration?: number): AsyncIterableIterator<VideoFrame>;
     abstract getMotionFrames(): AsyncIterableIterator<MotionFrame>;
     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>;
-    removeAllListeners(): void;
     private createMotionFrameObservable;
 }

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

@@ -4,7 +4,7 @@ import type { Observable, Subscription } from 'rxjs';
 import type { Camera, CameraActivitySettings, CameraFrameWorkerSettings, CameraInformation, CameraType } from '../api/database/types.js';
 import type { VideoFrame } from '../decoder/types.js';
 import type { IceServer } from '../services/config/types.js';
-import type { AudioSetEvent, AudioState, BaseLogger, BatterySetEvent, BatteryState, CameraSource, Container, DetectionZone, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, PrebufferState, SetValues, Sets, SirenSetEvent, SirenState, StateValues, States } from './types.js';
+import type { AudioSetEvent, AudioState, BaseLogger, BatterySetEvent, BatteryState, CameraAudioDetectionDelegate, CameraConfigInputSettings, CameraMotionDetectionDelegate, CameraObjectDetectionDelegate, CameraPTZDelegate, CameraPrebufferDelegate, CameraSource, Container, DetectionZone, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, PrebufferState, SetValues, Sets, SirenSetEvent, SirenState, StateValues, States } from './types.js';
 declare class Subscribed {
     private readonly subscriptions;
     private readonly additionalSubscriptions;
@@ -38,6 +38,12 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     readonly onDoorbellPressed: Observable<DoorbellState>;
     readonly onSirenDetected: Observable<SirenState>;
     readonly onBatteryChanged: Observable<BatteryState>;
+    protected abstract prebufferDelegate: CameraPrebufferDelegate;
+    abstract ptzDelegate: CameraPTZDelegate;
+    abstract motionDetectorDelegate: CameraMotionDetectionDelegate;
+    abstract audioDetectorDelegate: CameraAudioDetectionDelegate;
+    abstract objectDetectorDelegate: CameraObjectDetectionDelegate;
+    protected get cameraObject(): Camera;
     get id(): string;
     get nativeId(): string | undefined;
     get pluginId(): string;
@@ -56,7 +62,6 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     get hasObjectDetector(): boolean;
     get hasPtz(): boolean;
     get hasPrebuffer(): boolean;
-    get hasIntercom(): boolean;
     get activityZones(): DetectionZone[];
     get activitySettings(): CameraActivitySettings;
     get frameWorkerSettings(): CameraFrameWorkerSettings;
@@ -66,13 +71,15 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     get recordingSource(): CameraSource;
     get detectionSource(): CameraSource;
     constructor(camera: Camera, logger: BaseLogger);
+    getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
+    onStateChange<T extends keyof StateValues>(stateName: T): Observable<{
+        newState: StateValues[T];
+        oldState: StateValues[T];
+    }>;
     abstract connect(): Promise<void>;
     abstract disconnect(): Promise<void>;
-    abstract reboot(): Promise<void>;
-    abstract snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     abstract getIceServers(): Promise<IceServer[]>;
-    protected abstract cleanup(): void;
-    getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
     abstract updateState(stateName: 'light', eventData: LightSetEvent): Promise<void>;
     abstract updateState(stateName: 'motion', eventData: MotionSetEvent, frame?: VideoFrame): Promise<void>;
     abstract updateState(stateName: 'audio', eventData: AudioSetEvent): Promise<void>;
@@ -80,11 +87,11 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     abstract updateState(stateName: 'doorbell', eventData: DoorbellSetEvent): Promise<void>;
     abstract updateState(stateName: 'siren', eventData: SirenSetEvent): Promise<void>;
     abstract updateState(stateName: 'battery', eventData: BatterySetEvent): Promise<void>;
+    abstract addCameraSource(source: CameraConfigInputSettings): Promise<void>;
+    abstract updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>): Promise<void>;
+    abstract removeCameraSource(sourceId: string): Promise<void>;
+    protected abstract cleanup(): void;
     protected updateStateInternal<T extends keyof SetValues>(stateName: T, eventData: SetValues[T], skipCheck?: boolean): void;
-    onStateChange<T extends keyof StateValues>(stateName: T): Observable<{
-        newState: StateValues[T];
-        oldState: StateValues[T];
-    }>;
     onPropertyChange<T extends keyof Camera>(property: T | T[]): Observable<{
         property: T;
         oldData: Camera[T];

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

@@ -0,0 +1,10 @@
+import { CameraAudioDetectionDelegate } from '../types.js';
+import type { BaseLogger } from '../types.js';
+export declare class CameraAudioDetectionInterface extends CameraAudioDetectionDelegate {
+    delegate?: CameraAudioDetectionDelegate;
+    private onRequest;
+    private logger;
+    constructor(onRequest: (client: any, fn: string, args?: any[], timeout?: number) => Promise<any>, logger: BaseLogger);
+    detectAudio(audio: Buffer): Promise<boolean>;
+    private _onRequest;
+}

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

@@ -0,0 +1,19 @@
+import { CameraDelegate } from '../types.js';
+import type { CameraDeviceProxy } from '../../polyglot/node/plugins/proxy/cameraDevice.js';
+import type { BaseLogger } from '../types.js';
+export declare class CameraInterface extends CameraDelegate {
+    delegate?: CameraDelegate;
+    private connections;
+    private cameraDevice;
+    private logger;
+    constructor(cameraDevice: CameraDeviceProxy, logger: BaseLogger);
+    snapshotRequest(requestId: string, sourceName: string): Promise<Buffer | undefined>;
+    startStream(requestId: string, sourceName: string, videoPort: number, audioPort: number): Promise<void>;
+    stopStream(requestId: string, sourceName: string): Promise<void>;
+    onTalkbackSdp(requestId: string, sourceName: string, sdp: string, codec: 'PCMU' | 'PCMA' | 'opus'): void;
+    onTalkbackRtp(requestId: string, sourceName: string, rtp: Buffer): void;
+    onOffer(requestId: string, sdp: string): Promise<string>;
+    onCandidates(requestId: string, candidate: string): Promise<void>;
+    private generateSdp;
+    private createPeerCoonection;
+}

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

@@ -0,0 +1,10 @@
+import { CameraMotionDetectionDelegate } from '../types.js';
+import type { BaseLogger, Detection } from '../types.js';
+export declare class CameraMotionDetectionInterface extends CameraMotionDetectionDelegate {
+    delegate?: CameraMotionDetectionDelegate;
+    private onRequest;
+    private logger;
+    constructor(onRequest: (client: any, fn: string, args?: any[], timeout?: number) => Promise<any>, logger: BaseLogger);
+    detectImage(image: Buffer): Promise<Detection[]>;
+    private _onRequest;
+}

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

@@ -0,0 +1,10 @@
+import { CameraObjectDetectionDelegate } from '../types.js';
+import type { BaseLogger, Detection } from '../types.js';
+export declare class CameraObjectDetectionInterface extends CameraObjectDetectionDelegate {
+    delegate?: CameraObjectDetectionDelegate;
+    private onRequest;
+    private logger;
+    constructor(onRequest: (client: any, fn: string, args?: any[], timeout?: number) => Promise<any>, logger: BaseLogger);
+    detectImage(image: Buffer): Promise<Detection[]>;
+    private _onRequest;
+}

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

@@ -0,0 +1,11 @@
+import { CameraPrebufferDelegate } from '../types.js';
+import type { BaseLogger, Container, StreamInfo } from '../types.js';
+export declare class CameraPrebufferInterface extends CameraPrebufferDelegate {
+    delegate?: CameraPrebufferDelegate;
+    private onRequest;
+    private logger;
+    constructor(onRequest: (client: any, fn: string, args?: Record<string, any> | any[], timeout?: number) => Promise<any>, logger: BaseLogger);
+    getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;
+    updatePrebufferState(sourceId: string, container: Container, state: boolean): Promise<void>;
+    private _onRequest;
+}

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

@@ -0,0 +1,13 @@
+import { CameraPTZDelegate } from '../types.js';
+import type { BaseLogger } from '../types.js';
+export declare class CameraPTZInterface extends CameraPTZDelegate {
+    delegate?: CameraPTZDelegate;
+    private onRequest;
+    private logger;
+    constructor(onRequest: (client: any, fn: string, args?: any[], timeout?: number) => Promise<any>, logger: BaseLogger);
+    moveAbsolute(pan: number, tilt: number, zoom: number): Promise<void>;
+    moveRelative(pan: number, tilt: number, zoom: number): Promise<void>;
+    moveContinuous(pan: number, tilt: number, zoom: number): Promise<void>;
+    stop(): Promise<void>;
+    private _onRequest;
+}

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

@@ -1,5 +1,6 @@
-import { ReplaySubject, Subject, type Observable } from 'rxjs';
+import { ReplaySubject, Subject } from 'rxjs';
 import { Subscribed } from '../../utils/subscribed.js';
+import type { Observable } from 'rxjs';
 import type { RtpPacket } from 'werift';
 import type { IceServer } from '../../services/config/types.js';
 import type { CameraDevice } from '../device.js';

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

@@ -4,7 +4,7 @@ import { Subscribed } from '../../utils/subscribed.js';
 import type { CameraDevice } from '../device.js';
 import type { BaseLogger, FfmpegOptions, SpawnInput } from '../types.js';
 import type { WebrtcConnection } from './webrtc-connection.js';
-export declare class StreamingSession extends Subscribed {
+export declare class WeriftSession extends Subscribed {
     readonly onCallEnded: ReplaySubject<void>;
     readonly onVideoRtp: Subject<RtpPacket>;
     readonly onAudioRtp: Subject<RtpPacket>;

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

@@ -1,6 +1,12 @@
 import type { Observable } from 'rxjs';
 import type { CameraInformation, CameraInput, CameraInputSettings, Point, ZoneFilter, ZoneType } from '../api/database/types.js';
 import type { FrameData, FrameMetadata } from '../decoder/types.js';
+import type { CameraAudioDetectionInterface } from './interfaces/audioDetection.js';
+import type { CameraInterface } from './interfaces/camera.js';
+import type { CameraMotionDetectionInterface } from './interfaces/motionDetection.js';
+import type { CameraObjectDetectionInterface } from './interfaces/objectDetection.js';
+import type { CameraPrebufferInterface } from './interfaces/prebuffer.js';
+import type { CameraPTZInterface } from './interfaces/ptz.js';
 export interface BaseLogger {
     log: (...args: any[]) => void;
     error: (...args: any[]) => void;
@@ -35,16 +41,6 @@ export interface CameraSource extends CameraInput {
     onPrebuffering(container: Container): Observable<PrebufferState>;
     getStreamInfo(): Promise<StreamInfo | undefined>;
 }
-export interface CameraPrebufferDelegate {
-    getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;
-}
-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>;
-    reboot(): Promise<void>;
-}
 export interface StreamInfo {
     audio: AudioStreamOptions;
     video: VideoStreamOptions;
@@ -94,11 +90,12 @@ export interface BaseCameraConfig {
     disabled?: boolean;
     info?: Partial<CameraInformation>;
 }
-export type CameraConfig = (BaseCameraConfig & {
-    sources?: Omit<CameraInputSettings, '_id'>[];
-}) | (BaseCameraConfig & {
-    delegate?: CameraDelegate;
-});
+export interface CameraConfigInputSettings extends Omit<CameraInputSettings, '_id' | 'urls'> {
+    urls?: string[];
+}
+export type CameraConfig = BaseCameraConfig & {
+    sources: CameraConfigInputSettings[];
+};
 export interface Detection {
     id?: string;
     label: ObjectClass;
@@ -185,3 +182,44 @@ export type CameraStateCallbacks = {
 export type StateValue<T extends keyof StateValues> = StateValues[T];
 export type SetValue<T extends keyof SetValues> = SetValues[T];
 export type OnChangeCallback<T extends keyof StateValues> = (newEvent: StateValues[T], oldEvent: StateValues[T]) => void;
+export declare abstract class CameraDelegate {
+    abstract snapshotRequest(requestId: string, sourceName: string): Promise<Buffer | undefined>;
+    abstract startStream(requestId: string, sourceName: string, videoPort: number, audioPort: number): Promise<void>;
+    abstract stopStream(requestId: string, sourceName: string): Promise<void>;
+    abstract onTalkbackSdp(requestId: string, sourceName: string, sdp: string, codec: 'PCMU' | 'PCMA' | 'opus'): void;
+    abstract onTalkbackRtp(requestId: string, sourceName: string, rtp: Buffer): void;
+}
+export declare abstract class CameraPrebufferDelegate {
+    abstract getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;
+}
+export declare abstract class CameraPTZDelegate {
+    abstract moveAbsolute(pan: number, tilt: number, zoom: number): Promise<void>;
+    abstract moveRelative(pan: number, tilt: number, zoom: number): Promise<void>;
+    abstract moveContinuous(pan: number, tilt: number, zoom: number): Promise<void>;
+    abstract stop(): Promise<void>;
+}
+export declare abstract class CameraMotionDetectionDelegate {
+    abstract detectImage(image: Buffer): Promise<Detection[]>;
+}
+export declare abstract class CameraObjectDetectionDelegate {
+    abstract detectImage(image: Buffer): Promise<Detection[]>;
+}
+export declare abstract class CameraAudioDetectionDelegate {
+    abstract detectAudio(audio: Buffer): Promise<boolean>;
+}
+export interface CameraInterfaces {
+    readonly cameraDelegate: CameraInterface;
+    readonly prebufferDelegate: CameraPrebufferInterface;
+    readonly ptzDelegate: CameraPTZInterface;
+    readonly motionDetectorDelegate: CameraMotionDetectionInterface;
+    readonly objectDetectorDelegate: CameraObjectDetectionInterface;
+    readonly audioDetectorDelegate: CameraAudioDetectionInterface;
+}
+export interface CameraDelegates {
+    readonly cameraDelegate: CameraDelegate;
+    readonly prebufferDelegate: CameraPrebufferDelegate;
+    readonly ptzDelegate: CameraPTZDelegate;
+    readonly motionDetectorDelegate: CameraMotionDetectionDelegate;
+    readonly objectDetectorDelegate: CameraObjectDetectionDelegate;
+    readonly audioDetectorDelegate: CameraAudioDetectionDelegate;
+}

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

@@ -1,6 +1,6 @@
+import { PLUGIN_STATUS } from '../plugins/types.js';
 import { Subscribed } from '../utils/subscribed.js';
 import type { CameraController } from '../camera/controller.js';
-import { PLUGIN_STATUS } from '../plugins/types.js';
 export declare class FrameWorker extends Subscribed {
     token: string;
     name: string;

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

@@ -1,7 +1,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 { NatsConnection, Subscription } from 'nats';
 import type { StateValues } from '../camera/types.js';
 import type { CameraDeviceListenerMessagePayload, DeviceManagerProxyEvents, PluginsManagerProxyEvents, ProxyAuth, SystemManagerProxyEvents } from './types.js';
 import type { WebsocketProxy } from './websocket.js';

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

@@ -1,6 +1,13 @@
 import type { Camera } from '../../api/database/types.js';
-import type { CameraDelegate, CameraPrebufferDelegate, Container, FfmpegOptions, PrebufferState, SetValues, StateValues, StreamInfo } from '../../camera/types.js';
+import type { CameraAudioDetectionInterface } from '../../camera/interfaces/audioDetection.js';
+import type { CameraInterface } from '../../camera/interfaces/camera.js';
+import type { CameraMotionDetectionInterface } from '../../camera/interfaces/motionDetection.js';
+import type { CameraObjectDetectionInterface } from '../../camera/interfaces/objectDetection.js';
+import type { CameraPrebufferInterface } from '../../camera/interfaces/prebuffer.js';
+import type { CameraPTZInterface } from '../../camera/interfaces/ptz.js';
+import type { CameraConfigInputSettings, Container, PrebufferState, SetValues, StateValues } from '../../camera/types.js';
 import type { IceServer } from '../../services/config/types.js';
+import type { MethodKeys, MethodType } from '../../types.js';
 import type { MessageQueue } from '../queue.js';
 import type { CameraDeviceProxyMethods, ProxyMessageStructure } from '../types.js';
 export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
@@ -18,45 +25,34 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): void;
-    reboot(data: {
-        cameraId: string;
-        pluginId: string;
-    }): Promise<void>;
-    getStreamInfo(data: {
-        sourceName: string;
-        cameraId: string;
-        pluginId: string;
-    }): Promise<StreamInfo | undefined>;
     getFfmpegPath(): string;
     getIceServers(): IceServer[];
-    snapshot(data: {
-        forceNew?: boolean;
+    updateState<T extends keyof SetValues>(data: {
+        stateName: T;
+        eventData: SetValues[T];
         cameraId: string;
         pluginId: string;
-    }): Promise<ArrayBuffer>;
-    streamVideo(data: {
-        sourceName: string;
-        options: FfmpegOptions;
+    }): Promise<void>;
+    updatePrebufferState(data: {
+        sourceId: string;
+        container: Container;
+        state: PrebufferState;
         cameraId: string;
         pluginId: string;
     }): Promise<void>;
-    recordToFile(data: {
-        sourceName: string;
-        outputPath: string;
-        duration?: number;
+    addCameraSource(data: {
+        source: CameraConfigInputSettings;
         cameraId: string;
         pluginId: string;
     }): Promise<void>;
-    updateState<T extends keyof SetValues>(data: {
-        stateName: T;
-        eventData: SetValues[T];
+    updateCameraSource(data: {
+        id: string;
+        source: Partial<CameraConfigInputSettings>;
         cameraId: string;
         pluginId: string;
     }): Promise<void>;
-    updatePrebufferState(data: {
-        sourceId: string;
-        container: Container;
-        state: PrebufferState;
+    removeCameraSource(data: {
+        id: string;
         cameraId: string;
         pluginId: string;
     }): Promise<void>;
@@ -68,11 +64,11 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
         states: StateValues;
         cameraState: boolean;
     };
-    onRequestReboot(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['reboot']>): Promise<Buffer>;
-    onRequestGetStreamInfo(pluginId: string, cameraId: string, ...args: Parameters<CameraPrebufferDelegate['getStreamInfo']>): Promise<StreamInfo | 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>;
+    onRequest<T extends MethodKeys<CameraInterface>>(delegateType: 'cameraDelegate', cameraId: string, fn: T, ...args: Parameters<MethodType<CameraInterface, T>>): Promise<ReturnType<MethodType<CameraInterface, T>>>;
+    onRequest<T extends MethodKeys<CameraPrebufferInterface>>(delegateType: 'prebufferDelegate', cameraId: string, fn: T, ...args: Parameters<MethodType<CameraPrebufferInterface, T>>): Promise<ReturnType<MethodType<CameraPrebufferInterface, T>>>;
+    onRequest<T extends MethodKeys<CameraPTZInterface>>(delegateType: 'ptzDelegate', cameraId: string, fn: T, ...args: Parameters<MethodType<CameraPTZInterface, T>>): Promise<ReturnType<MethodType<CameraPTZInterface, T>>>;
+    onRequest<T extends MethodKeys<CameraMotionDetectionInterface>>(delegateType: 'motionDetectorDelegate', cameraId: string, fn: T, ...args: Parameters<MethodType<CameraMotionDetectionInterface, T>>): Promise<ReturnType<MethodType<CameraMotionDetectionInterface, T>>>;
+    onRequest<T extends MethodKeys<CameraObjectDetectionInterface>>(delegateType: 'objectDetectorDelegate', cameraId: string, fn: T, ...args: Parameters<MethodType<CameraObjectDetectionInterface, T>>): Promise<ReturnType<MethodType<CameraObjectDetectionInterface, T>>>;
+    onRequest<T extends MethodKeys<CameraAudioDetectionInterface>>(delegateType: 'audioDetectorDelegate', cameraId: string, fn: T, ...args: Parameters<MethodType<CameraAudioDetectionInterface, T>>): Promise<ReturnType<MethodType<CameraAudioDetectionInterface, T>>>;
+    handleMessage(message: ProxyMessageStructure): Promise<void | ProxyMessageStructure>;
 }

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

@@ -27,5 +27,5 @@ export declare class DeviceManagerProxy implements DeviceManagerServerProxyMetho
         id: string;
         pluginId: string;
     }): Promise<void>;
-    handleMessage(message: ProxyMessageStructure): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void | ProxyMessageStructure>;
 }

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

@@ -8,5 +8,5 @@ export declare class PluginsManagerProxy implements PluginsManagerServerProxyMet
     constructor(messageQueue: MessageQueue);
     onRequestPluginFn<K extends keyof CallablePluginMethods>(pluginId: string, fn: K, ...args: Parameters<BasePlugin[K]>): Promise<ReturnType<BasePlugin[K]>>;
     onRequestStorageFn<K extends keyof CallablePluginStorageMethods>(pluginId: string, cameraId: string, fn: K, ...args: Parameters<CameraStorage[K]>): Promise<Awaited<ReturnType<CameraStorage[K]>>>;
-    handleMessage(message: ProxyMessageStructure): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void | ProxyMessageStructure>;
 }

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

@@ -4,5 +4,5 @@ export declare class SystemManagerProxy implements SystemManagerServerProxyMetho
     private pluginsService;
     private messageQueue;
     constructor(messageQueue: MessageQueue);
-    handleMessage(message: ProxyMessageStructure): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void | ProxyMessageStructure>;
 }