@camera.ui/browser 0.0.77 → 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/plugins.service.d.ts

@@ -21,4 +21,5 @@ export declare class PluginsService {
     removePluginDbById(id: string): Promise<void>;
     removeAllPluginsDb(): Promise<void>;
     removeOrphanPluginsDb(): Promise<void>;
+    handleDisabledPlugins(): Promise<void>;
 }

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

@@ -1,5 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import type { Readable } from 'node:stream';
 import type { CameraExtension, PLUGIN_STATUS, PluginContract, PluginRootSchema } from '../../plugins/types.js';
 import type { LoggingLevel } from '../../services/config/types.js';
@@ -9,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;
@@ -116,6 +114,10 @@ export interface UsersResponse {
     pagination: Pagination;
     result: DBUser[];
 }
+export interface ViewsResponse {
+    pagination: Pagination;
+    result: DBCamviewLayout[];
+}
 export interface CamerasResponse {
     pagination: Pagination;
     result: DBCamera[];
@@ -342,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>;
@@ -350,6 +363,7 @@ export type BackupCreateRequest = {
 export type StreamsParamsNameRequest = {
     Params: {
         id: string;
+        name: string;
     };
 };
 export interface BackupInfo {
@@ -359,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/utils/fetch.d.ts

@@ -0,0 +1,2 @@
+declare const fetchWithTimeout: (url: string, options?: RequestInit) => Promise<Response>;
+export default fetchWithTimeout;

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/api/websocket/types.d.ts

@@ -1,8 +1,6 @@
 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' | '/frameWorker';
+export type SocketNsp = '/camera.ui' | '/metrics' | '/logs' | '/status' | '/notifications' | '/plugins' | '/proxy' | '/frame' | '/frameWorker';
 export interface SocketNspMap {
     nsp: Namespace;
     [key: string]: any;
@@ -86,15 +84,3 @@ export interface PluginRuntime {
     name: string;
     status: PLUGIN_STATUS;
 }
-export interface StreamPayload {
-    type: Exclude<VideoStreamingMode, 'webrtc' | 'webrtc/tcp'> | 'webrtc/offer' | 'webrtc/candidate';
-    value: string;
-}
-export interface Go2RtcWs {
-    id: string;
-    ws?: WebSocket;
-    connect: () => void;
-    reconnect: () => void;
-    close: (destroy?: boolean) => void;
-    send: (data: StreamPayload) => void;
-}

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

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import 'reflect-metadata';
 import { EventEmitter } from 'node:events';
 import { CameraController } from './camera/controller.js';
@@ -37,7 +36,7 @@ export declare class CameraUiAPI extends EventEmitter {
         controller: CameraController;
         worker: FrameWorker;
     }[];
-    updateCamera(camera: Camera, extensions: CameraExtensions): void;
+    updateCamera(camera: Camera): 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/controller.d.ts

@@ -1,34 +1,45 @@
-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;
     private subscribeToCameraSourcesState;
-    private subscribeToMotionState;
-    private subscribeToDoorbellState;
     private subscribeToCameraChanges;
     private subscribeToStateChanges;
+    private subscribeToMotionState;
+    private subscribeToObjectState;
+    private subscribeToDoorbellState;
     private triggerProxyEvent;
     private isCameraEvent;
 }

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

@@ -1,27 +1,18 @@
-import type { Observable } from 'rxjs';
 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 getFrames(): AsyncIterableIterator<VideoFrame>;
+    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 getPrebufferedFrames(): AsyncIterableIterator<VideoFrame>;
     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

@@ -1,10 +1,10 @@
-/// <reference types="node" resolution-mode="require"/>
 import { LRUCache } from 'lru-cache';
 import { BehaviorSubject } from 'rxjs';
 import type { Observable, Subscription } from 'rxjs';
-import type { Camera, CameraActivitySettings, CameraInformation, CameraPublicProperties, CameraType } from '../api/database/types.js';
+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,35 +62,38 @@ 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;
     get sources(): CameraSource[];
     get streamSource(): CameraSource;
     get snapshotSource(): CameraSource;
     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?: Buffer): Promise<void>;
+    abstract updateState(stateName: 'motion', eventData: MotionSetEvent, frame?: VideoFrame): Promise<void>;
     abstract updateState(stateName: 'audio', eventData: AudioSetEvent): Promise<void>;
     abstract updateState(stateName: 'object', eventData: ObjectSetEvent): Promise<void>;
     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 CameraPublicProperties>(property: T): Observable<{
+    onPropertyChange<T extends keyof Camera>(property: T | T[]): Observable<{
+        property: T;
         oldData: Camera[T];
         newData: Camera[T];
     }>;
@@ -93,16 +102,16 @@ export declare abstract class BaseCameraDevice extends Subscribed {
         changed: boolean;
         event: StateValues[T];
     };
-    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;
+    protected getAudioState(event: AudioSetEvent, ignoreLastEvet?: boolean): AudioState;
+    protected getMotionState(event: MotionSetEvent, ignoreLastEvet?: boolean): MotionState;
+    protected getObjectState(event: ObjectSetEvent, ignoreLastEvet?: boolean): ObjectState;
+    protected getDoorbellState(event: DoorbellSetEvent, ignoreLastEvet?: boolean): DoorbellState;
+    protected getLightState(event: LightSetEvent, ignoreLastEvet?: boolean): LightState;
+    protected getSirenState(event: SirenSetEvent, ignoreLastEvet?: boolean): SirenState;
+    protected getBatteryState(event: BatterySetEvent, ignoreLastEvet?: boolean): BatteryState;
     protected updateCamera(updatedCamera: Camera): void;
     protected updatePrebuffer(sourceId: string, container: Container, state: PrebufferState): Promise<void>;
-    private updateCameraSourcesState;
+    protected updateCameraSourcesState(): void;
     protected updateCameraState(state: boolean): void;
     protected cameraSourcePrebufferState(sourceId: string, container: Container): PrebufferState;
     private createStateObservable;

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/polygon.d.ts

@@ -1,5 +1,6 @@
+import type { CameraActivitySettings } from '../api/database/types.js';
 import type { Detection, DetectionZone } from './types.js';
 export declare const convertZonePointsToPixels: (zone: DetectionZone, detection: Detection) => DetectionZone;
 export declare const convertBoundingBoxToPixels: (detection: Detection) => Detection;
-export declare const areObjectDetectionsValid: (detections: Detection[], zones: DetectionZone[]) => Detection[];
-export declare const areMotionDetectionsValid: (detections: Detection[], zones: DetectionZone[]) => Detection[];
+export declare const areObjectDetectionsValid: (detections: Detection[], zones: DetectionZone[], activitySettings: CameraActivitySettings) => Detection[];
+export declare const areMotionDetectionsValid: (detections: Detection[], zones: DetectionZone[], activitySettings: CameraActivitySettings) => Detection[];

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

@@ -27,7 +27,7 @@ export declare class WeriftPeerConnection extends Subscribed implements BasicPee
     onVideoRtp: Subject<RtpPacket>;
     onVideoRtcp: Subject<RtcpPacket>;
     onIceCandidate: Subject<RTCIceCandidate>;
-    onConnectionState: ReplaySubject<"connected" | "disconnected" | "closed" | "failed" | "new" | "connecting">;
+    onConnectionState: ReplaySubject<"closed" | "failed" | "disconnected" | "new" | "connecting" | "connected">;
     returnAudioTrack: MediaStreamTrack;
     private onRequestKeyFrame;
     private cameraDevice;

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>;