@camera.ui/browser 0.0.91 → 0.0.93

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

@@ -1,5 +1,5 @@
+import type { AuthConfig } from '@camera.ui/common';
 import type { Readable } from 'node:stream';
-import type { AuthConfig } from '../../decoder/types.js';
 import type { CameraExtension, PLUGIN_STATUS, PluginContract, RootSchema } from '../../plugins/types.js';
 import type { LoggingLevel } from '../../services/config/types.js';
 import type { CameraExtensions, CameraZone, DBCamera, DBCamviewLayout, DBRoles, DBUser } from '../database/types.js';
@@ -50,7 +50,7 @@ export interface ClientData {
     address?: string;
     device?: string;
 }
-export declare enum REFRESH_TOKEN {
+export declare const enum REFRESH_TOKEN {
     EXPIRES_IN = "7d"
 }
 export declare const PAGINATION_DEFAULTS: PaginationQuery;

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

@@ -3,14 +3,8 @@ import { EventEmitter } from 'node:events';
 import { CameraController } from './camera/controller.js';
 import type { Camera, CameraExtensions } from './api/database/types.js';
 import type { FrameWorker } from './decoder/worker.js';
-import type { BasePlugin } from './plugins/interfaces/base.js';
 import type { CameraExtension } from './plugins/types.js';
-import type { API } from './polyglot/node/plugins/pluginApi.js';
-import type { PluginLogger } from './polyglot/node/plugins/pluginLogger.js';
-export interface PluginConstructor {
-    new (logger: PluginLogger, api: API): BasePlugin;
-}
-export declare const enum API_EVENT {
+export declare enum API_EVENT {
     FINISH_LAUNCHING = "finishLaunching",
     SHUTDOWN = "shutdown"
 }

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

@@ -1,10 +1,8 @@
-import { CameraDevice } from './device.js';
-import { CameraPrebufferInterface } from './interfaces/prebuffer.js';
-import { CameraPTZInterface } from './interfaces/ptz.js';
+import { CameraDevice, CameraPrebufferInterface, CameraPTZInterface } from '@camera.ui/plugineer';
+import type { Logger } from '@camera.ui/common/logger';
 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 { BaseLogger, CameraConfigInputSettings, CameraDelegate, CameraSource, SetValues } from './types.js';
+import type { CameraConfigInputSettings, CameraDelegate, CameraSource, MotionFrame, SetValues, VideoFrame } from './types.js';
 export declare class CameraController extends CameraDevice {
     proxy: ProxyServer;
     private motionTimeout?;
@@ -17,7 +15,7 @@ export declare class CameraController extends CameraDevice {
     protected prebufferDelegate: CameraPrebufferInterface;
     get camera(): Camera;
     get sources(): CameraSource[];
-    constructor(camera: Camera, logger: BaseLogger, proxy: ProxyServer);
+    constructor(camera: Camera, logger: Logger, proxy: ProxyServer);
     setDelegate(): void;
     getFrames(): AsyncIterableIterator<VideoFrame>;
     getMotionFrames(): AsyncIterableIterator<MotionFrame>;

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

@@ -1,16 +1,9 @@
-import type { CameraInformation, CameraInput, CameraInputSettings, Point, ZoneFilter, ZoneType } from '../api/database/types.js';
-import type { FrameData, FrameMetadata } from '../decoder/types.js';
-import type { CameraInterface } from './interfaces/camera.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;
-    warn: (...args: any[]) => void;
-    debug: (...args: any[]) => void;
-    trace: (...args: any[]) => void;
-    attention: (...args: any[]) => void;
-}
+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;
@@ -199,3 +192,137 @@ export interface CameraDelegates {
     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,5 +1,5 @@
+import type { AuthConfig } from '@camera.ui/common';
 import type { Sharp } from 'sharp';
-import type { MotionState } from '../camera/types.js';
 export type DecoderFormat = 'yuv' | 'rgb';
 export interface ImageMetadata {
     width: number;
@@ -56,23 +56,6 @@ export interface FrameImage {
     image: Sharp;
     info: ImageInformation;
 }
-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 {
-    motion: MotionState;
-}
-export interface AuthConfig {
-    user: string;
-    password: string;
-}
 export interface BaseFrameWorkerConfig {
     frameWorkerId: string;
     cameraId: string;

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

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

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

@@ -1,12 +1,11 @@
-import { ProxyConnection } from './connection.js';
+import { ProxyConnection } from '@camera.ui/common';
 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 { StateValues } from '../camera/types.js';
-import type { CameraStorage } from '../polyglot/node/plugins/cameraStorage.js';
+import type { ProxySubscription } from '@camera.ui/common/nats';
+import type { CameraStorage, StateValues } from '../camera/types.js';
 import type { MethodKeys, MethodType } from '../types.js';
-import type { ProxySubscription } from './subscription.js';
 import type { CameraDeviceListenerMessagePayload, CoreManagerProxyEvents, DeviceManagerProxyEvents, PluginMap, ProxyAuth } 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 @@
+import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/common';
 import type { CameraConfigInputSettings, CameraInterfaces, SetValues } from '../../camera/types.js';
 import type { MethodKeys, MethodType } from '../../types.js';
-import type { MessageQueue } from '../messageQueue.js';
-import type { CameraDeviceProxyMethods, ProxyMessageStructure, RefreshedStates } from '../types.js';
+import type { CameraDeviceProxyMethods, RefreshedStates } from '../types.js';
 export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     private api;
     private configService;

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

@@ -1,6 +1,6 @@
+import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/common';
 import type { IceServer } from '../../services/config/types.js';
-import type { MessageQueue } from '../messageQueue.js';
-import type { CoreManagerProxyMethods, ProxyMessageStructure } from '../types.js';
+import type { CoreManagerProxyMethods } from '../types.js';
 export declare class CoreManagerProxy implements CoreManagerProxyMethods {
     private configService;
     private pluginsService;

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

@@ -1,14 +1,14 @@
+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 { MessageQueue } from '../messageQueue.js';
-import type { DeviceManagerServerProxyMethods, ProxyMessageStructure } from '../types.js';
-export declare class DeviceManagerProxy implements DeviceManagerServerProxyMethods {
+import type { DeviceManagerProxyMethods } from '../types.js';
+export declare class DeviceManagerProxy implements DeviceManagerProxyMethods {
     private camerasService;
     private pluginsService;
     private messageQueue;
     constructor(messageQueue: MessageQueue);
-    getCameraByName(cameraName: string): Camera | undefined;
-    getCameraById(cameraId: string): Camera | void;
+    getCameraByName(cameraName: string): Promise<any>;
+    getCameraById(cameraId: string): Promise<any>;
     createCamera(cameraConfig: CameraConfig, pluginId: string): Promise<Camera>;
     removeCameraByName(cameraName: string, pluginId: string): Promise<void>;
     removeCameraById(cameraId: string, pluginId: string): Promise<void>;

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

@@ -1,35 +1,13 @@
+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 { CameraDevice } from '../camera/device.js';
-import type { CameraConfig, CameraConfigInputSettings, CameraDelegates, SetValues, StateValues } from '../camera/types.js';
-import type { AuthConfig } from '../decoder/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 { DeserializedError, RemoteError } from './error.js';
-export interface QueueItem {
-    message: ProxyMessageStructure;
-    resolve: (response: any) => void;
-    reject: (error: RemoteError) => void;
-}
-export interface ProxyMessageStructure {
-    requestId: string;
-    cameraId?: string;
-    targetId: string;
-    targetName?: string;
-    pluginId: string;
-    type: 'request' | 'reply';
-    proxy: 'device' | 'camera' | 'plugin' | 'core';
-    client: 'cameraFn' | 'pluginFn' | 'deviceFn' | 'storageFn' | 'coreFn' | keyof CameraDelegates;
-    fn: string;
-    args: any[];
-    timeout: number;
-    timestamp: number;
-    response?: any;
-    error?: DeserializedError;
-}
 export interface ProxyAuth {
     cluster: AuthConfig;
     server: AuthConfig;
@@ -64,17 +42,17 @@ export interface CameraDeviceListenerMessagePayload {
     type: 'removed' | 'updated' | 'cameraState';
     data?: any;
 }
-export interface DeviceManagerServerProxyMethods {
-    createCamera(camera: CameraConfig): Promise<Camera>;
-    getCameraByName(name: string): Camera | void;
-    getCameraById(id: string): Camera | void;
-    removeCameraByName(name: string): Promise<void>;
-    removeCameraById(id: string): Promise<void>;
+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>;
-    createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
     removeCameraByName(cameraName: string): Promise<void>;
     removeCameraById(cameraId: string): Promise<void>;
 }
@@ -100,6 +78,13 @@ export interface DeviceManagerProxyGenericEvent<K extends keyof DeviceManagerPro
     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[]>;

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

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

package/dist/types/server/src/plugins/interfaces/base.d.ts

@@ -1,4 +1,4 @@
-import type { CameraDevice } from '../../camera/device.js';
+import type { CameraDevice } from '@camera.ui/plugineer';
 import type { FormSubmitResponse } from '../types.js';
 export declare abstract class BasePlugin {
     abstract onFormSubmit(actionId: string, payload: any): Promise<FormSubmitResponse | void>;

package/dist/types/server/src/plugins/plugin.d.ts

@@ -1,4 +1,4 @@
-import { PythonInstaller } from '../utils/pythonInstaller.js';
+import { PythonInstaller } from '@camera.ui/common/python';
 import type { CameraUiPlugin, IPackageJson } from '../api/types/index.js';
 import type { PluginContract } from './types.js';
 export declare class Plugin {

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

@@ -1,5 +1,7 @@
+import type { Path } from 'object-path';
 import type { Camera } from '../api/database/types.js';
-import type { Detection } from '../camera/types.js';
+import type { Detection, StorageController } from '../camera/types.js';
+import type { CoreManager, DeviceManager } from '../nats/types.js';
 export interface Context {
     engines?: Record<string, string>;
     dependencies?: Record<string, string>;
@@ -31,7 +33,7 @@ export interface PluginContractBase {
     pythonVersion?: string;
 }
 export type PluginContract = PluginContractBase & ExtensionOrSupport;
-export declare const enum PLUGIN_STATUS {
+export declare enum PLUGIN_STATUS {
     READY = "ready",
     STARTING = "starting",
     STARTED = "started",
@@ -40,7 +42,7 @@ export declare const enum PLUGIN_STATUS {
     UNKNOWN = "unknown",
     DISABLED = "disabled"
 }
-export declare const enum PLUGIN_COMMAND {
+export declare enum PLUGIN_COMMAND {
     START = "start",
     STOP = "stop"
 }
@@ -151,4 +153,35 @@ export interface ObjectDetectionPluginResponse {
 export interface AudioDetectionPluginResponse {
     detected: boolean;
 }
+export interface PluginAPI {
+    on(event: 'finishLaunching', listener: () => void): this;
+    on(event: 'shutdown', listener: () => void): this;
+    once(event: 'finishLaunching', listener: () => void): this;
+    once(event: 'shutdown', listener: () => void): this;
+    off(event: 'finishLaunching', listener: () => void): this;
+    off(event: 'shutdown', listener: () => void): this;
+    removeListener(event: 'finishLaunching', listener: () => void): this;
+    removeListener(event: 'shutdown', listener: () => void): this;
+    removeAllListeners(event?: string): this;
+    readonly coreManager: CoreManager;
+    readonly deviceManager: DeviceManager;
+    readonly storageController: StorageController;
+    readonly configService: PluginConfigService;
+    readonly storagePath: string;
+    readonly configFile: string;
+}
+export interface PluginConfigService {
+    get(key: Path, defaultValue: JSONValue, validate: Function, refresh?: boolean, writeIfNotValid?: boolean): any;
+    get(key: Path, defaultValue?: unknown, validate?: Function, refresh?: boolean, writeIfNotValid?: boolean): any;
+    has(key: Path, refresh?: boolean): boolean;
+    ensureExists(key: Path, defaultValue: JSONValue, write?: boolean): void;
+    set(key: Path, value: any, write?: boolean): void;
+    insert(key: Path, value: any, at?: number, write?: boolean): void;
+    push(key: Path, write?: boolean, ...items: any[]): void;
+    delete(key: Path, write?: boolean): void;
+    all(refresh?: boolean): PluginConfig;
+    replace(config: PluginConfig, write?: boolean): void;
+    updateValue(path: string, searchKey: string, searchValue: any, targetKey: string, newValue: any, write?: boolean): void;
+    replaceOrAddItem(path: string, searchKey: string, searchValue: any, newItem: any, write?: boolean): void;
+}
 export {};

package/dist/types/server/src/services/config/index.d.ts

@@ -1,4 +1,5 @@
 import 'reflect-metadata';
+import type { LoggerOptions } from '@camera.ui/common/logger';
 import type { DeepPartial } from '../../types.js';
 import type { Go2RtcConfig, IConfig, Secrets } from './types.js';
 export declare class ConfigService {
@@ -38,6 +39,7 @@ export declare class ConfigService {
     set config(newConfig: IConfig);
     get go2rtcConfig(): Go2RtcConfig;
     set go2rtcConfig(newConfig: Go2RtcConfig);
+    get loggerOptions(): LoggerOptions;
     constructor(homePath?: string);
     static extractVersion(str: string): string | null;
     read(): void;

package/dist/types/server/src/services/logger/index.d.ts

@@ -1,23 +1,11 @@
 import 'reflect-metadata';
+import { Logger } from '@camera.ui/common/logger';
+import type { LoggerOptions } from '@camera.ui/common/logger';
 import type { UiNotification } from '../../api/types/index.js';
 import type { LoggingLevel } from '../config/types.js';
-export declare class Logger {
-    private _loggerPrefix;
-    debugEnabled: boolean;
-    traceEnabled: boolean;
-    disableTimestamps: boolean;
+export declare class LoggerService extends Logger {
     notifications: UiNotification[];
-    get prefix(): string;
-    constructor();
-    log(...args: any[]): void;
-    error(...args: any[]): void;
-    warn(...args: any[]): void;
-    attention(...args: any[]): void;
-    debug(...args: any[]): void;
-    trace(...args: any[]): void;
+    constructor(options?: LoggerOptions);
     notify(title: string, text: string, type: LoggingLevel, link: string): Promise<void>;
-    formatMessage(level: 'log' | 'warn' | 'error' | 'debug' | 'trace' | 'attention', ...args: any[]): string[];
-    private formattedArgs;
-    private formatDateTime;
     private checkIfNotificationExists;
 }

package/dist/types/shared/types/index.d.ts

@@ -1,3 +1,7 @@
+export type * from '../../packages/common/src/messaging/index.js';
+export * from '../../packages/common/src/utils/subscribed.js';
+export * from '../../packages/plugineer/src/polyglot/node/camera/polygon.js';
+export * from '../../packages/plugineer/src/polyglot/node/plugins/schema.js';
 export type * from '../../server/src/api/database/types.js';
 export * from '../../server/src/api/schemas/cameras.schema.js';
 export * from '../../server/src/api/schemas/plugins.schema.js';
@@ -5,14 +9,12 @@ export * from '../../server/src/api/schemas/system.schema.js';
 export * from '../../server/src/api/schemas/users.schema.js';
 export type * from '../../server/src/api/types/index.js';
 export type * from '../../server/src/api/websocket/types.js';
-export * from '../../server/src/camera/polygon.js';
 export type * from '../../server/src/camera/types.js';
 export type * from '../../server/src/decoder/types.js';
 export * from '../../server/src/go2rtc/types.js';
 export type * from '../../server/src/nats/types.js';
+export * from '../../server/src/plugins/interfaces/base.js';
 export * from '../../server/src/plugins/types.js';
-export * from '../../server/src/polyglot/node/plugins/schema.js';
 export * from '../../server/src/services/config/types.js';
 export type * from '../../server/src/types.js';
 export { names as cocoLabels } from '../../server/src/utils/cocoLabels.json';
-export * from '../../server/src/utils/subscribed.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camera.ui/browser",
-  "version": "0.0.91",
+  "version": "0.0.93",
   "description": "camera.ui browser client",
   "author": "seydx (https://github.com/seydx/camera.ui)",
   "module": "./dist/bundle.js",
@@ -25,7 +25,7 @@
     "prepublishOnly": "npm i --package-lock-only && npm run lint && npm run format && npm run build"
   },
   "dependencies": {
-    "lru-cache": "^11.0.0",
+    "lru-cache": "^11.0.1",
     "rxjs": "^7.8.1",
     "socket.io-client": "^4.7.5"
   },

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

@@ -1,29 +0,0 @@
-import { BehaviorSubject } from 'rxjs';
-import { BaseCameraDevice } from './index.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 { AudioSetEvent, BatterySetEvent, CameraConfigInputSettings, CameraDelegates, DoorbellSetEvent, FrameState, LightSetEvent, MotionSetEvent, ObjectSetEvent, SirenSetEvent } from './types.js';
-export declare abstract class CameraDevice extends BaseCameraDevice {
-    protected readonly frameState: BehaviorSubject<FrameState>;
-    protected readonly onFrame: Observable<FrameState>;
-    abstract setDelegate<T extends keyof CameraDelegates>(name: T, delegate: CameraDelegates[T]): void;
-    abstract connect(): Promise<void>;
-    abstract disconnect(): Promise<void>;
-    abstract getFrames(prebufferDuration?: number): AsyncIterableIterator<VideoFrame>;
-    abstract getMotionFrames(): AsyncIterableIterator<MotionFrame>;
-    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>;
-    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>;
-    createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<WeriftSession>;
-    protected removeAllListeners(): void;
-    private createMotionFrameObservable;
-}

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

@@ -1,10 +0,0 @@
-import { CameraDelegate } from '../types.js';
-import type { BaseLogger } from '../types.js';
-export declare class CameraInterface extends CameraDelegate {
-    delegate?: CameraDelegate;
-    private onRequest;
-    private logger;
-    constructor(onRequest: (client: any, fn: string, args?: any[], timeout?: number) => Promise<any>, logger: BaseLogger);
-    snapshot(): Promise<ArrayBuffer | undefined>;
-    private _onRequest;
-}