@camera.ui/browser 0.0.93 → 0.0.95

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

@@ -1,328 +1,11 @@
-import type { CameraInterface, CameraPrebufferInterface, CameraPTZInterface, StreamingConnectionOptions } from '@camera.ui/plugineer';
-import type { Observable, ReplaySubject, Subject, Subscription } from 'rxjs';
-import type { ConnectionState, RTCSessionDescription, RtpPacket, RTCIceCandidate as WeriftRTCICECandidate } from 'werift';
-import type { Camera, CameraActivitySettings, CameraFrameWorkerSettings, CameraInformation, CameraInput, CameraInputSettings, CameraType, Point, ZoneFilter, ZoneType } from '../api/database/types.js';
-import type { DecoderFormat, FrameBuffer, FrameData, FrameImage, FrameMetadata, ImageOptions } from '../decoder/types.js';
-import type { JsonSchema, JsonSchemaForm, SchemaConfig } from '../plugins/types.js';
-export type SpawnInput = string | number;
-export interface FfmpegOptions {
-    ffmpegPath: string;
-    input?: SpawnInput[];
-    video?: SpawnInput[];
-    audio?: SpawnInput[];
-    output: SpawnInput[];
-}
-export type Container = 'mp4' | 'mpegts';
-export interface BasePrebufferState {
-    duration: number;
-}
-export interface PrebufferStateTrue extends BasePrebufferState {
-    state: true;
-    url: string;
-}
-export interface PrebufferStateFalse extends BasePrebufferState {
-    state: false;
-}
-export type PrebufferState = PrebufferStateTrue | PrebufferStateFalse;
-export interface CameraSource extends CameraInput {
-    getPrebufferingState(container: Container): Promise<PrebufferState | undefined>;
-    getStreamInfo(): Promise<StreamInfo | undefined>;
-}
-export interface StreamInfo {
-    audio: AudioStreamOptions;
-    video: VideoStreamOptions;
-}
-export interface AudioStreamOptions {
-    enabled?: boolean;
-    codec?: string;
-    bitrate?: number;
-    sampleRate?: number;
-}
-export interface VideoStreamOptions {
-    codec?: string;
-    width?: number;
-    height?: number;
-    bitrate?: number;
-    fps?: number;
-    idrInterval?: number;
-}
-export type Sdp = string;
-export type IceCandiate = string;
-export interface Go2RtcOfferMessage {
-    type: 'webrtc/offer';
-    value: Sdp;
-}
-export interface Go2RtcAnswerMessage {
-    type: 'webrtc/answer';
-    value: Sdp;
-}
-export interface Go2RtcIceCandidateMessage {
-    type: 'webrtc/candidate';
-    value: IceCandiate;
-}
-export interface ErrorMessage {
-    type: 'error';
-    value: string;
-}
-export type Go2RtcIncomingMessage = Go2RtcAnswerMessage | Go2RtcIceCandidateMessage | ErrorMessage;
-export type Go2RtcOutgoingMessage = Go2RtcOfferMessage | Go2RtcIceCandidateMessage;
-export interface BaseCameraConfig {
-    name: string;
-    nativeId?: string;
-    isCloud?: boolean;
-    hasLight?: boolean;
-    hasSiren?: boolean;
-    hasBinarySensor?: boolean;
-    hasBattery?: boolean;
-    disabled?: boolean;
-    info?: Partial<CameraInformation>;
-}
-export interface CameraConfigInputSettings extends Omit<CameraInputSettings, '_id'> {
-}
-export type CameraConfig = BaseCameraConfig & {
-    sources: CameraConfigInputSettings[];
-};
-export type BoundingBox = [number, number, number, number];
-export interface Detection {
-    id?: string;
-    label: ObjectClass;
-    confidence: number;
-    boundingBox: BoundingBox;
-    inputWidth: number;
-    inputHeight: number;
-    origWidth: number;
-    origHeight: number;
-}
-export interface DetectionZone {
-    name: string;
-    points: Point[];
-    type: ZoneType;
-    filter: ZoneFilter;
-    classes: ObjectClass[];
-    isPrivacyMask: boolean;
-}
-export type ObjectClass = 'person' | 'bicycle' | 'car' | 'motorcycle' | 'airplane' | 'bus' | 'train' | 'truck' | 'boat' | 'traffic light' | 'fire hydrant' | 'stop sign' | 'parking meter' | 'bench' | 'bird' | 'cat' | 'dog' | 'horse' | 'sheep' | 'cow' | 'elephant' | 'bear' | 'zebra' | 'giraffe' | 'backpack' | 'umbrella' | 'handbag' | 'tie' | 'suitcase' | 'frisbee' | 'skis' | 'snowboard' | 'sports ball' | 'kite' | 'baseball bat' | 'baseball glove' | 'skateboard' | 'surfboard' | 'tennis racket' | 'bottle' | 'wine glass' | 'cup' | 'fork' | 'knife' | 'spoon' | 'bowl' | 'banana' | 'apple' | 'sandwich' | 'orange' | 'broccoli' | 'carrot' | 'hot dog' | 'pizza' | 'donut' | 'cake' | 'chair' | 'couch' | 'potted plant' | 'bed' | 'dining table' | 'toilet' | 'tv' | 'laptop' | 'mouse' | 'remote' | 'keyboard' | 'cell phone' | 'microwave' | 'oven' | 'toaster' | 'sink' | 'refrigerator' | 'book' | 'clock' | 'vase' | 'scissors' | 'teddy bear' | 'hair drier' | 'toothbrush' | 'motion';
-export interface BaseState<T extends LightState | AudioState | MotionState | ObjectState | SirenState | BatteryState | DoorbellState> {
-    timestamp: number;
-    lastEvent?: Omit<T, 'lastEvent'>;
-}
-export interface MotionSetEvent {
-    state?: boolean;
-    detections: Detection[];
-}
-export interface AudioSetEvent {
-    state: boolean;
-    db?: number;
-}
-export interface ObjectSetEvent {
-    detections: Detection[];
-}
-export interface LightSetEvent {
-    state: boolean;
-}
-export interface DoorbellSetEvent {
-    state: boolean;
-}
-export interface SirenSetEvent {
-    state: boolean;
-    level?: number;
-}
-export interface 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;
+import type { FrameData, FrameMetadata, MotionState, SetValues, StateValues } from '@camera.ui/types';
 export interface FrameState extends MotionState {
     frameData: FrameData;
     metadata: FrameMetadata;
 }
-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;
-    audio: AudioState;
-    object: ObjectState;
-    doorbell: DoorbellState;
-    siren: SirenState;
-    battery: BatteryState;
-}
-export interface SetValues {
-    light: LightSetEvent;
-    motion: MotionSetEvent;
-    audio: AudioSetEvent;
-    object: ObjectSetEvent;
-    doorbell: DoorbellSetEvent;
-    siren: SirenSetEvent;
-    battery: BatterySetEvent;
-}
 export type CameraStateCallbacks = {
     [K in keyof StateValues]: (event: StateValues[K]) => void;
 };
 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 snapshot(): Promise<ArrayBuffer | undefined>;
-}
-export declare abstract class CameraPrebufferDelegate {
-    abstract getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;
-    abstract getPrebufferingState(sourceName: string, container: Container): Promise<PrebufferState | 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 interface CameraInterfaces {
-    readonly cameraDelegate: CameraInterface;
-    readonly prebufferDelegate: CameraPrebufferInterface;
-    readonly ptzDelegate: CameraPTZInterface;
-}
-export interface CameraDelegates {
-    readonly cameraDelegate: CameraDelegate;
-    readonly prebufferDelegate: CameraPrebufferDelegate;
-    readonly ptzDelegate: CameraPTZDelegate;
-}
-export interface CameraStorage<T extends Record<string, any> = Record<string, any>> {
-    schema: JsonSchemaForm;
-    values: T;
-    initializeStorage(): void;
-    getValue<U = string>(path: string): Promise<U> | undefined;
-    getValue<U = string>(path: string, defaultValue: U): Promise<U>;
-    setValue<U = string>(path: string, newValue: U): Promise<void>;
-    hasValue(path: string): boolean;
-    getConfig(): Promise<SchemaConfig>;
-    setConfig(newConfig: T): Promise<void>;
-    addSchema(schema: JsonSchemaForm): Promise<void>;
-    addSchema(path: string, schema: JsonSchema): Promise<void>;
-    removeSchema(path: string): void;
-    changeSchema(path: string, newSchema: Partial<JsonSchema>): Promise<void>;
-    getSchema<U>(path: string): U | undefined;
-    hasSchema(path: string): boolean;
-}
-export interface StorageController {
-    createCameraStorage<T extends Record<string, any> = Record<string, any>>(instance: any, cameraId: string, schema?: JsonSchemaForm): CameraStorage<T>;
-    getCameraStorage<T extends Record<string, any> = Record<string, any>>(cameraId: string): CameraStorage<T> | undefined;
-    removeCameraStorage(cameraId: string): void;
-}
-export interface WeriftSession extends Subscribed {
-    readonly onCallEnded: ReplaySubject<void>;
-    readonly onVideoRtp: Subject<RtpPacket>;
-    readonly onAudioRtp: Subject<RtpPacket>;
-    readonly isUsingOpus: Promise<boolean>;
-    reservePort(bufferPorts?: number): Promise<number>;
-    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
-    transcodeReturnAudio(ffmpegOptions: {
-        ffmpegPath: string;
-        input: SpawnInput[];
-    }): Promise<void>;
-    stop(): void;
-    sendAudioPacket(rtp: RtpPacket): void;
-    requestKeyFrame(): void;
-}
-export interface CameraDevice {
-    readonly id: string;
-    readonly nativeId: string | undefined;
-    readonly pluginId: string;
-    readonly connected: boolean;
-    readonly disabled: boolean;
-    readonly name: string;
-    readonly type: CameraType;
-    readonly info: CameraInformation;
-    readonly isCloud: boolean;
-    readonly hasLight: boolean;
-    readonly hasSiren: boolean;
-    readonly hasBinarySensor: boolean;
-    readonly hasBattery: boolean;
-    readonly hasMotionDetector: boolean;
-    readonly hasAudioDetector: boolean;
-    readonly hasObjectDetector: boolean;
-    readonly hasPtz: boolean;
-    readonly hasPrebuffer: boolean;
-    readonly activityZones: DetectionZone[];
-    readonly activitySettings: CameraActivitySettings;
-    readonly frameWorkerSettings: CameraFrameWorkerSettings;
-    readonly streamSource: CameraSource;
-    readonly snapshotSource: CameraSource | undefined;
-    readonly highResolutionSource: CameraSource | undefined;
-    readonly midResolutionSource: CameraSource | undefined;
-    readonly lowResolutionSource: CameraSource | undefined;
-    readonly ptz: CameraPTZDelegate;
-    readonly sources: CameraSource[];
-    readonly onConnected: Observable<boolean>;
-    readonly onLightSwitched: Observable<LightState>;
-    readonly onMotionDetected: Observable<MotionState>;
-    readonly onAudioDetected: Observable<AudioState>;
-    readonly onObjectDetected: Observable<ObjectState>;
-    readonly onDoorbellPressed: Observable<DoorbellState>;
-    readonly onSirenDetected: Observable<SirenState>;
-    readonly onBatteryChanged: Observable<BatteryState>;
-    snapshot(forceNew?: boolean): Promise<ArrayBuffer | undefined>;
-    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];
-        newData: Camera[T];
-    }>;
-    getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
-    setDelegate<T extends keyof CameraDelegates>(name: T, delegate: CameraDelegates[T]): void;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    getFrames(prebufferDuration?: number): AsyncIterableIterator<VideoFrame>;
-    getMotionFrames(): AsyncIterableIterator<MotionFrame>;
-    updateState(stateName: 'light', eventData: LightSetEvent): Promise<void>;
-    updateState(stateName: 'motion', eventData: MotionSetEvent, frame?: VideoFrame): Promise<void>;
-    updateState(stateName: 'audio', eventData: AudioSetEvent): Promise<void>;
-    updateState(stateName: 'object', eventData: ObjectSetEvent): Promise<void>;
-    updateState(stateName: 'doorbell', eventData: DoorbellSetEvent): Promise<void>;
-    updateState(stateName: 'siren', eventData: SirenSetEvent): Promise<void>;
-    updateState(stateName: 'battery', eventData: BatterySetEvent): Promise<void>;
-    addCameraSource(source: CameraConfigInputSettings): Promise<void>;
-    updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>): Promise<void>;
-    removeCameraSource(sourceId: string): Promise<void>;
-    createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<WeriftSession>;
-}
-export interface VideoFrame {
-    readonly frameData: FrameData;
-    readonly metadata: FrameMetadata;
-    readonly inputWidth: number;
-    readonly inputHeight: number;
-    readonly inputFormat: DecoderFormat;
-    toBuffer(options?: ImageOptions): Promise<FrameBuffer>;
-    toImage(options?: ImageOptions): Promise<FrameImage>;
-    save(path: string, options?: ImageOptions): Promise<void>;
-}
-export interface MotionFrame extends VideoFrame {
-    readonly motion: MotionState;
-}
-export interface BasicPeerConnection {
-    createOffer(): Promise<RTCSessionDescription>;
-    acceptAnswer(answer: {
-        type: 'answer';
-        sdp: string;
-    }): Promise<void>;
-    addIceCandidate(candidate: Partial<WeriftRTCICECandidate>): Promise<void>;
-    onIceCandidate: Subject<WeriftRTCICECandidate>;
-    onConnectionState: Observable<ConnectionState>;
-    close(): void;
-    requestKeyFrame?: () => void;
-}
-interface Subscribed {
-    addSubscriptions(...subscriptions: Subscription[]): void;
-    addAdditionalSubscriptions(...subscriptions: Subscription[]): void;
-    unsubscribe(): void;
-    unsubscribeAdditional(): void;
-}
-export {};

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

@@ -1,109 +1,3 @@
-import type { AuthConfig } from '@camera.ui/common';
-import type { Sharp } from 'sharp';
-export type DecoderFormat = 'yuv' | 'rgb';
-export interface ImageMetadata {
-    width: number;
-    height: number;
-}
-export interface AudioMetadata {
-    mimeType: 'audio/mpeg' | 'audio/wav' | 'audio/ogg';
-}
-export interface FrameMetadata {
-    format: DecoderFormat;
-    frameSize: number;
-    width: number;
-    origWidth: number;
-    height: number;
-    origHeight: number;
-}
-export interface ImageCrop {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-}
-export interface ImageResize {
-    width?: number;
-    height?: number;
-}
-export interface ImageFormat {
-    to: ImageOutputFormat;
-}
-export type ImageInputFormat = 'yuv' | 'rgb' | 'rgba' | 'gray';
-export type ImageOutputFormat = 'rgb' | 'rgba' | 'gray';
-export interface ImageOptions {
-    format?: ImageFormat;
-    crop?: ImageCrop;
-    resize?: ImageResize;
-}
-export interface ProcessPrebufferedImageRequest {
-    frameData: FrameData;
-    metadata: FrameMetadata;
-    options: ImageOptions;
-    prebufferDuration: number;
-}
-export interface ImageInformation {
-    width: number;
-    height: number;
-    channels: 1 | 3 | 4;
-    format: ImageInputFormat;
-}
-export interface FrameBuffer {
-    image: Uint8Array;
-    info: ImageInformation;
-}
-export interface FrameImage {
-    image: Sharp;
-    info: ImageInformation;
-}
-export interface BaseFrameWorkerConfig {
-    frameWorkerId: string;
-    cameraId: string;
-    cameraName: string;
-    ffmpegPath: string;
-    logLevel: string;
-    disableTimestamps: boolean;
-    auth: AuthConfig;
-    proxyEndpoints: string[];
-    fps: number;
-    resolution: number;
-}
-export type WorkerMessage = 'started' | 'getFFmpegArgs' | 'updateClient' | 'removeClient';
-export type MainMessage = 'setCameraName' | 'recoverClients';
-export interface MainToWorkerMessage {
-    message: MainMessage;
-    data: Record<string, any>;
-}
-export interface WorkerToMainResponse {
-    response?: Record<string, any>;
-}
-export interface WorkerToMainMessage {
-    message: WorkerMessage;
-    data: Record<string, any>;
-}
-export interface MainToWorkerResponse {
-    response?: Record<string, any>;
-}
-export type SignalingMessageType = 'connect' | 'disconnect' | 'metadata';
-export interface SignalingRequest {
-    type: SignalingMessageType;
-    pluginId: string;
-    cameraId: string;
-    requestId: string;
-}
-export interface SignalingResponse {
-    type: SignalingMessageType;
-    requestId: string;
-    metadata?: FrameMetadata;
-}
-export interface PingMessage {
-    type: 'ping';
-    requestId: string;
-}
-export interface PongMessage {
-    type: 'pong';
-    requestId: string;
-}
 export interface HardwareSource {
     name: string;
     url: string;
@@ -111,24 +5,3 @@ export interface HardwareSource {
 export interface HardwareResponse {
     sources: HardwareSource[];
 }
-export interface FfmpegArgs {
-    hwaccel: string;
-    hwaccelArgs: string[];
-    hwaccelFilter: string;
-    threads: string;
-}
-export interface FrameWorkerClient {
-    pluginId: string;
-    requestIds: string[];
-}
-export interface RecoveredClient extends FrameWorkerClient {
-}
-export interface PrebufferContainer {
-    frameId: string;
-    time: number;
-    frame: Buffer;
-}
-export interface FrameData {
-    frameId: string;
-    timestamp: number;
-}

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

@@ -1,6 +1,6 @@
-import type { AuthConfig } from '@camera.ui/common';
 import { Subscribed } from '@camera.ui/common';
-import { PLUGIN_STATUS } from '../plugins/types.js';
+import { PLUGIN_STATUS } from '@camera.ui/plugineer';
+import type { AuthConfig } from '@camera.ui/plugineer';
 import type { CameraController } from '../camera/controller.js';
 export declare class FrameWorker extends Subscribed {
     readonly frameWorkerId: string;
@@ -10,6 +10,7 @@ export declare class FrameWorker extends Subscribed {
     private ipcSubject;
     private publisher?;
     private subscriber?;
+    private coreManager;
     private logger;
     private configService;
     private socketService;

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

@@ -1,12 +1,12 @@
-import { ProxyConnection } from '@camera.ui/common';
+import { ProxyConnection } from '@camera.ui/plugineer';
 import { CameraDeviceProxy } from './proxy/cameraDevice.js';
 import { CoreManagerProxy } from './proxy/coreManager.js';
 import { DeviceManagerProxy } from './proxy/deviceManager.js';
 import { NatsServer } from './server.js';
-import type { ProxySubscription } from '@camera.ui/common/nats';
-import type { CameraStorage, StateValues } from '../camera/types.js';
+import type { CameraDeviceListenerMessagePayload, CoreManagerProxyEvents, DeviceManagerProxyEvents, ProxySubscription } from '@camera.ui/plugineer';
+import type { CameraStorage, StateValues } from '@camera.ui/types';
 import type { MethodKeys, MethodType } from '../types.js';
-import type { CameraDeviceListenerMessagePayload, CoreManagerProxyEvents, DeviceManagerProxyEvents, PluginMap, ProxyAuth } from './types.js';
+import type { PluginMap, ProxyAuth } from './types.js';
 import type { WebsocketProxy } from './websocket.js';
 export declare class ProxyServer {
     private api;

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

@@ -1,7 +1,6 @@
-import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/common';
-import type { CameraConfigInputSettings, CameraInterfaces, SetValues } from '../../camera/types.js';
+import type { CameraDeviceProxyMethods, CameraInterfaces, MessageQueue, ProxyMessageStructure, RefreshedStates } from '@camera.ui/plugineer';
+import type { CameraConfigInputSettings, ProbeStream, SetValues } from '@camera.ui/types';
 import type { MethodKeys, MethodType } from '../../types.js';
-import type { CameraDeviceProxyMethods, RefreshedStates } from '../types.js';
 export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     private api;
     private configService;
@@ -12,6 +11,7 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     connect(cameraId: string, pluginId: string): void;
     disconnect(cameraId: string, pluginId: string): void;
     updateState<T extends keyof SetValues>(stateName: T, eventData: SetValues[T], cameraId: string, pluginId: string): Promise<void>;
+    probeStream(sourceId: string, cameraId: string): Promise<ProbeStream | undefined>;
     addCameraSource(source: CameraConfigInputSettings, cameraId: string, pluginId: string): Promise<void>;
     updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>, cameraId: string, pluginId: string): Promise<void>;
     removeCameraSource(sourceId: string, cameraId: string, pluginId: string): Promise<void>;

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

@@ -1,13 +1,13 @@
-import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/common';
-import type { IceServer } from '../../services/config/types.js';
-import type { CoreManagerProxyMethods } from '../types.js';
-export declare class CoreManagerProxy implements CoreManagerProxyMethods {
+import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/plugineer';
+import type { CoreManager, FfmpegArgs, IceServer } from '@camera.ui/types';
+export declare class CoreManagerProxy implements CoreManager {
     private configService;
     private pluginsService;
     private systemService;
     private messageQueue;
     constructor(messageQueue: MessageQueue);
     getFFmpegPath(): Promise<string>;
+    getHwaccelInfo(): Promise<FfmpegArgs>;
     getServerAddresses(): Promise<string[]>;
     getIceServers(): Promise<IceServer[]>;
     requestHandler(message: ProxyMessageStructure): Promise<void | ProxyMessageStructure>;

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

@@ -1,8 +1,6 @@
-import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/common';
-import type { Camera } from '../../api/database/types.js';
-import type { CameraConfig } from '../../camera/types.js';
-import type { DeviceManagerProxyMethods } from '../types.js';
-export declare class DeviceManagerProxy implements DeviceManagerProxyMethods {
+import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/plugineer';
+import type { Camera, CameraConfig, DeviceManager } from '@camera.ui/types';
+export declare class DeviceManagerProxy implements DeviceManager {
     private camerasService;
     private pluginsService;
     private messageQueue;

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

@@ -1,13 +1,6 @@
-import type { AuthConfig } from '@camera.ui/common';
-import type { CameraDevice } from '@camera.ui/plugineer';
-import type { Camera, DBSystem, VideoStreamingMode } from '../api/database/types.js';
-import type { CameraConfig, CameraConfigInputSettings, SetValues, StateValues } from '../camera/types.js';
-import type { AudioDetectionPlugin } from '../plugins/interfaces/audioDetection.js';
-import type { BasePlugin } from '../plugins/interfaces/base.js';
-import type { MotionDetectionPlugin } from '../plugins/interfaces/motionDetection.js';
-import type { ObjectDetectionPlugin } from '../plugins/interfaces/objectDetection.js';
-import type { CameraExtension } from '../plugins/types.js';
-import type { IceServer } from '../services/config/types.js';
+import type { AuthConfig } from '@camera.ui/plugineer';
+import type { AudioDetectionPlugin, BasePlugin, MotionDetectionPlugin, ObjectDetectionPlugin } from '@camera.ui/types';
+import type { VideoStreamingMode } from '../api/database/types.js';
 export interface ProxyAuth {
     cluster: AuthConfig;
     server: AuthConfig;
@@ -17,95 +10,6 @@ export interface StreamPayload {
     type: Exclude<VideoStreamingMode, 'webrtc' | 'webrtc/tcp'> | 'webrtc/offer' | 'webrtc/candidate';
     value: string;
 }
-export interface RefreshedStates {
-    camera: Camera;
-    states: StateValues;
-    cameraState: boolean;
-}
-export interface CameraDeviceProxyMethods {
-    connect(): void;
-    disconnect(): void;
-    updateState<T extends keyof SetValues>(stateName: T, eventData: SetValues[T]): void;
-    refreshStates(): RefreshedStates;
-    addCameraSource(source: CameraConfigInputSettings): Promise<void>;
-    updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>): Promise<void>;
-    removeCameraSource(sourceId: string): Promise<void>;
-}
-export interface CameraDeviceListenerStatePayload<K extends keyof StateValues> {
-    stateName: K;
-    data: {
-        newEvent: StateValues[K];
-        oldEvent: StateValues[K];
-    };
-}
-export interface CameraDeviceListenerMessagePayload {
-    type: 'removed' | 'updated' | 'cameraState';
-    data?: any;
-}
-export interface DeviceManager extends DeviceManagerProxyMethods {
-    on<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
-    once<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
-    off<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
-    removeListener<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
-    removeAllListeners<E extends keyof DeviceManagerProxyEventCallbacks>(event?: E): this;
-}
-export interface DeviceManagerProxyMethods {
-    createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
-    getCameraByName(cameraName: string): Promise<CameraDevice | undefined>;
-    getCameraById(cameraId: string): Promise<CameraDevice | undefined>;
-    removeCameraByName(cameraName: string): Promise<void>;
-    removeCameraById(cameraId: string): Promise<void>;
-}
-export interface DeviceManagerListenerMessagePayload {
-    type: keyof DeviceManagerProxyEventCallbacks;
-    data: DeviceManagerProxyEvents[keyof DeviceManagerProxyEvents];
-}
-export interface DeviceManagerProxyEvents {
-    cameraSelected: {
-        camera: Camera;
-        extension: CameraExtension;
-    };
-    cameraDeselected: {
-        camera: Camera;
-        extension: CameraExtension;
-    };
-}
-export interface DeviceManagerProxyEventCallbacks {
-    cameraSelected: (camera: CameraDevice, extension: CameraExtension) => void;
-    cameraDeselected: (cameraId: string, extension: CameraExtension) => void;
-}
-export interface DeviceManagerProxyGenericEvent<K extends keyof DeviceManagerProxyEvents> {
-    type: K;
-    data: DeviceManagerProxyEvents[K];
-}
-export declare interface CoreManager extends CoreManagerProxyMethods {
-    on<E extends keyof CoreManagerProxyEventCallbacks>(event: E, listener: CoreManagerProxyEventCallbacks[E]): this;
-    once<E extends keyof CoreManagerProxyEventCallbacks>(event: E, listener: CoreManagerProxyEventCallbacks[E]): this;
-    off<E extends keyof CoreManagerProxyEventCallbacks>(event: E, listener: CoreManagerProxyEventCallbacks[E]): this;
-    removeListener<E extends keyof CoreManagerProxyEventCallbacks>(event: E, listener: CoreManagerProxyEventCallbacks[E]): this;
-    removeAllListeners<E extends keyof CoreManagerProxyEventCallbacks>(event?: E): this;
-}
-export interface CoreManagerProxyMethods {
-    getFFmpegPath(): Promise<string>;
-    getServerAddresses(): Promise<string[]>;
-    getIceServers(): Promise<IceServer[]>;
-}
-export interface CoreManagerListenerMessagePayload {
-    type: keyof CoreManagerProxyEventCallbacks;
-    data: CoreManagerProxyEvents[keyof CoreManagerProxyEvents];
-}
-export interface CoreManagerProxyEvents {
-    systemUpdated: {
-        system: DBSystem;
-    };
-}
-export interface CoreManagerProxyEventCallbacks {
-    systemUpdated: (system: DBSystem) => void;
-}
-export interface CoreManagerProxyGenericEvent<K extends keyof CoreManagerProxyEvents> {
-    type: K;
-    data: CoreManagerProxyEvents[K];
-}
 export interface PluginMap {
     base: BasePlugin;
     motionDetection: MotionDetectionPlugin;

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

@@ -1,2 +1,2 @@
-import type { AuthConfig } from '@camera.ui/common';
+import type { AuthConfig } from '@camera.ui/plugineer';
 export declare function generateCredentials(): AuthConfig;

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

@@ -1,7 +1,7 @@
+import type { CameraDeviceListenerMessagePayload } from '@camera.ui/plugineer';
+import type { StateValues } from '@camera.ui/types';
 import type { Namespace, Server } from 'socket.io';
 import type { SocketNsp } from '../api/websocket/types.js';
-import type { StateValues } from '../camera/types.js';
-import type { CameraDeviceListenerMessagePayload } from './types.js';
 export declare class WebsocketProxy {
     nsp: Namespace;
     nspName: SocketNsp;