@camera.ui/browser 0.0.35 → 0.0.37

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

@@ -1,38 +1,47 @@
 import { Observable } from 'rxjs';
 import { StreamingSession } from './streaming/streaming-session';
-import type { Camera, CameraSource, CameraPrebufferInput, CameraPublicProperties, CameraZone } from '../api/database/types';
+import { BrowserStreamingSession } from './streaming/browser/browser-streaming-session';
+import type { Camera, CameraPublicProperties, CameraZone, CameraType, CameraInformation } from '../api/database/types';
 import type { ProxyServer } from '../proxy';
-import type { CameraDevice, BaseLogger, CameraDelegate } from './types';
+import type { CameraDevice, BaseLogger, CameraDelegate, CameraPrebufferDelegate } from './types';
 import type { IceServer } from '../services/config/types';
-import type { StateValues, OnSetEvent, LightState, MotionState, AudioState, ObjectState, DoorbellState, SirenState, StreamingConnectionOptions, FfmpegOptions, PrebufferType } from './types';
-export declare class CameraDeviceHub implements CameraDevice {
+import type { StateValues, OnSetEvent, LightState, MotionState, AudioState, ObjectState, DoorbellState, SirenState, BatteryState, StreamingConnectionOptions, FfmpegOptions, CameraSource } from './types';
+export declare class CameraController implements CameraDevice {
+    private log;
     private proxy?;
     private cameraSubject;
-    private prebufferSubject;
+    private cameraState;
     private lightState;
     private motionState;
     private audioState;
     private objectState;
     private doorbellState;
     private sirenState;
-    onLightDetected: Observable<LightState>;
+    private batteryState;
+    private snapshotCache;
+    onStarted: Observable<boolean>;
+    onLightSwitched: Observable<LightState>;
     onMotionDetected: Observable<MotionState>;
     onAudioDetected: Observable<AudioState>;
     onObjectDetected: Observable<ObjectState>;
     onDoorbellPressed: Observable<DoorbellState>;
     onSirenDetected: Observable<SirenState>;
-    logger: BaseLogger;
-    delegate?: CameraDelegate;
+    onBatteryChanged: Observable<BatteryState>;
+    private _delegate?;
+    private _prebufferDelegate?;
     get id(): string;
     get nativeId(): string | undefined;
     get pluginId(): string;
+    get state(): boolean;
     get disabled(): boolean;
     get name(): string;
-    get type(): string;
-    get model(): string;
+    get type(): CameraType;
+    get info(): CameraInformation;
     get isCloud(): boolean;
     get hasLight(): boolean;
     get hasSiren(): boolean;
+    get hasBinarySensor(): boolean;
+    get hasBattery(): boolean;
     get hasMotionDetector(): boolean;
     get hasAudioDetector(): boolean;
     get hasObjectDetector(): boolean;
@@ -40,19 +49,23 @@ export declare class CameraDeviceHub implements CameraDevice {
     get motionZones(): CameraZone[];
     get objectZones(): CameraZone[];
     get sources(): CameraSource[];
-    constructor(camera: Camera, logger?: BaseLogger, proxy?: ProxyServer);
-    getStreamSource(): CameraSource;
-    getSnapshotSource(): CameraSource;
-    getRecordingSource(): CameraSource;
-    getDetectionSource(): CameraSource;
-    configureDelegate(delegate: CameraDelegate): void;
-    snapshot(prebuffer?: boolean): Promise<ArrayBuffer>;
-    setPrebufferSource(sourceIdOrName: string, address: string, type: PrebufferType): Promise<void>;
-    removePrebufferSource(sourceIdOrName: string, type: 'recording' | 'stream'): Promise<void>;
-    removePrebufferSources(): Promise<void>;
+    get streamSource(): CameraSource;
+    get snapshotSource(): CameraSource;
+    get recordingSource(): CameraSource;
+    get detectionSource(): CameraSource;
+    get delegate(): CameraDelegate | undefined;
+    set delegate(delegate: CameraDelegate);
+    get prebufferDelegate(): CameraPrebufferDelegate | undefined;
+    set prebufferDelegate(delegate: CameraPrebufferDelegate);
+    constructor(camera: Camera, logger: BaseLogger, proxy?: ProxyServer);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    reboot(): Promise<void>;
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     getFfmpegPath(): Promise<string>;
     getIceServers(): Promise<IceServer[]>;
     createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<StreamingSession>;
+    createBrowserSession(): Promise<BrowserStreamingSession>;
     streamVideo(sourceName: string, options: FfmpegOptions): Promise<StreamingSession>;
     recordToFile(sourceName: string, outputPath: string, duration?: number): Promise<void>;
     getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
@@ -66,12 +79,12 @@ export declare class CameraDeviceHub implements CameraDevice {
         newData: Camera[T];
     }>;
     updateCamera(updatedCamera: Camera): void;
-    updatePrebufferSources(sources: CameraPrebufferInput[]): void;
+    updateCameraState(state: boolean): void;
     removeCamera(): void;
     removeAllListeners(): void;
     private createStateObservable;
+    private subscribeToCameraState;
     private subscribeToCameraChanges;
-    private subscribeToSourceChanges;
     private subscribeToStateChanges;
     private triggerProxyEvent;
 }

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

@@ -0,0 +1,22 @@
+import { ReplaySubject, Subject } from 'rxjs';
+import { Subscribed } from '../../utils/subscribed';
+import type { BasicBrowserPeerConnection, BaseLogger, CameraDevice } from '../../types';
+import type { IceServer } from '../../../services/config/types';
+export declare class BrowserPeerConnection extends Subscribed implements BasicBrowserPeerConnection {
+    onIceCandidate: Subject<RTCIceCandidate>;
+    onConnectionState: ReplaySubject<RTCPeerConnectionState>;
+    videoTransceiver: RTCRtpTransceiver;
+    audioTransceiver: RTCRtpTransceiver;
+    private cameraDevice;
+    private logger;
+    private pc;
+    constructor(cameraDevice: CameraDevice, iceServers: IceServer[], logger: BaseLogger);
+    createOffer(): Promise<RTCSessionDescriptionInit>;
+    acceptAnswer(answer: {
+        type: 'answer';
+        sdp: string;
+    }): Promise<void>;
+    addIceCandidate(candidate: RTCIceCandidateInit): Promise<void>;
+    close(): void;
+    private createPeerCoonection;
+}

package/dist/src/camera/streaming/browser/browser-streaming-session.d.ts

@@ -0,0 +1,17 @@
+import { ReplaySubject } from 'rxjs';
+import { Subscribed } from '../../utils/subscribed';
+import type { BaseLogger, CameraDevice } from '../../types';
+import type { WebrtcBrowserConnection } from './webrtc-browser-connection';
+export declare class BrowserStreamingSession extends Subscribed {
+    readonly onCallEnded: ReplaySubject<void>;
+    private readonly onUsingOpus;
+    private hasEnded;
+    private cameraDevice;
+    private connection;
+    private logger;
+    get isUsingOpus(): Promise<boolean>;
+    constructor(cameraDevice: CameraDevice, logger: BaseLogger, connection: WebrtcBrowserConnection);
+    stop(): void;
+    private bindToConnection;
+    private callEnded;
+}

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

@@ -0,0 +1,26 @@
+import { ReplaySubject, type Observable } from 'rxjs';
+import { Subscribed } from '../../utils/subscribed';
+import type { CameraDevice, BaseLogger } from '../../types';
+import type { IceServer } from '../../../services/config/types';
+export declare class WebrtcBrowserConnection extends Subscribed {
+    readonly onCameraConnected: ReplaySubject<void>;
+    readonly onCallAnswered: ReplaySubject<string>;
+    readonly onCallEnded: ReplaySubject<void>;
+    readonly onError: ReplaySubject<void>;
+    readonly onMessage: ReplaySubject<{
+        method: string;
+    }>;
+    readonly onWsOpen: Observable<unknown>;
+    private readonly pc;
+    private readonly ws;
+    private readonly onOfferSent;
+    private hasEnded;
+    private cameraDevice;
+    private logger;
+    constructor(cameraDevice: CameraDevice, sourceName: string, iceServers: IceServer[], logger: BaseLogger);
+    stop(): void;
+    private initiateCall;
+    private handleMessage;
+    private sendMessage;
+    private callEnded;
+}

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

@@ -1,9 +1,8 @@
 import { ReplaySubject, Subject } from 'rxjs';
 import { MediaStreamTrack, RTCSessionDescription } from 'werift';
-import { Subscribed } from '../subscribed';
-import type { WebSocket } from 'ws';
+import { Subscribed } from '../utils/subscribed';
 import type { RtpPacket, RtcpPacket, RTCIceCandidate } from 'werift';
-import type { BasicPeerConnection, CameraDevice } from '../types';
+import type { BasicPeerConnection, BaseLogger, CameraDevice } from '../types';
 import type { IceServer } from '../../services/config/types';
 export declare class WeriftPeerConnection extends Subscribed implements BasicPeerConnection {
     onAudioRtp: Subject<RtpPacket>;
@@ -13,12 +12,11 @@ export declare class WeriftPeerConnection extends Subscribed implements BasicPee
     onIceCandidate: Subject<RTCIceCandidate>;
     onConnectionState: ReplaySubject<"closed" | "failed" | "disconnected" | "new" | "connecting" | "connected">;
     returnAudioTrack: MediaStreamTrack;
-    private pc;
-    private ws?;
+    private onRequestKeyFrame;
     private cameraDevice;
     private logger;
-    private onRequestKeyFrame;
-    constructor(cameraDevice: CameraDevice, iceServers: IceServer[], ws?: WebSocket);
+    private pc;
+    constructor(cameraDevice: CameraDevice, iceServers: IceServer[], logger: BaseLogger);
     createOffer(): Promise<RTCSessionDescription>;
     acceptAnswer(answer: {
         type: 'answer';

package/dist/src/camera/streaming/streaming-session.d.ts

@@ -1,8 +1,8 @@
 import { RtpPacket } from 'werift';
 import { ReplaySubject, Subject } from 'rxjs';
-import { Subscribed } from '../subscribed';
+import { Subscribed } from '../utils/subscribed';
 import type { WebrtcConnection } from './webrtc-connection';
-import type { FfmpegOptions, SpawnInput, CameraDevice } from '../types';
+import type { FfmpegOptions, SpawnInput, BaseLogger, CameraDevice } from '../types';
 export declare class StreamingSession extends Subscribed {
     readonly onCallEnded: ReplaySubject<void>;
     readonly onVideoRtp: Subject<RtpPacket>;
@@ -16,7 +16,7 @@ export declare class StreamingSession extends Subscribed {
     private connection;
     private logger;
     get isUsingOpus(): Promise<boolean>;
-    constructor(cameraDevice: CameraDevice, connection: WebrtcConnection);
+    constructor(cameraDevice: CameraDevice, logger: BaseLogger, connection: WebrtcConnection);
     reservePort(bufferPorts?: number): Promise<number>;
     startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
     transcodeReturnAudio(ffmpegOptions: {

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

@@ -1,7 +1,7 @@
 import { ReplaySubject, Subject, type Observable } from 'rxjs';
-import { Subscribed } from '../subscribed';
+import { Subscribed } from '../utils/subscribed';
 import type { RtpPacket } from 'werift';
-import type { StreamingConnectionOptions, CameraDevice } from '../types';
+import type { StreamingConnectionOptions, BaseLogger, CameraDevice } from '../types';
 import type { IceServer } from '../../services/config/types';
 export declare class WebrtcConnection extends Subscribed {
     readonly onCameraConnected: ReplaySubject<void>;
@@ -18,9 +18,9 @@ export declare class WebrtcConnection extends Subscribed {
     private readonly ws;
     private readonly onOfferSent;
     private hasEnded;
-    private logger;
     private cameraDevice;
-    constructor(cameraDevice: CameraDevice, sourceName: string, iceServers: IceServer[], options: StreamingConnectionOptions);
+    private logger;
+    constructor(cameraDevice: CameraDevice, sourceName: string, iceServers: IceServer[], logger: BaseLogger, options: StreamingConnectionOptions);
     sendAudioPacket(rtp: RtpPacket): void;
     stop(): void;
     requestKeyFrame(): void;

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

@@ -1,16 +1,24 @@
 /// <reference types="pouchdb-core" />
 /// <reference types="node" />
 import type { Observable, Subject } from 'rxjs';
-import type { ConnectionState, RTCIceCandidate } from 'werift';
-import type { Camera, CameraPublicProperties, CameraInputSettings, CameraZone, CameraSource } from '../api/database/types';
+import type { ConnectionState, RTCIceCandidate as WeriftRTCICECandidate, RTCSessionDescription } from 'werift';
+import type { Camera, CameraPublicProperties, CameraInputSettings, CameraZone, CameraInput, CameraType, CameraInformation } from '../api/database/types';
+import type { IceServer } from '../services/config/types';
 import type { StreamingSession } from './streaming/streaming-session';
+import type { BrowserStreamingSession } from './streaming/browser/browser-streaming-session';
 export type SpawnInput = string | number;
 export type PrebufferType = 'recording' | 'stream';
+export interface CameraSource extends CameraInput {
+    isPrebuffering(type: PrebufferType): Promise<boolean>;
+    getPrebufferRawUrl(type: PrebufferType): Promise<string | undefined>;
+    getStreamInfo(): Promise<StreamInfo | undefined>;
+}
 export interface BaseLogger {
     log: (...args: any[]) => void;
     error: (...args: any[]) => void;
     warn: (...args: any[]) => void;
     debug: (...args: any[]) => void;
+    trace: (...args: any[]) => void;
 }
 export interface FfmpegOptions {
     input?: SpawnInput[];
@@ -22,56 +30,71 @@ export interface StreamingConnectionOptions {
     createPeerConnection?: () => BasicPeerConnection;
 }
 export interface BasicPeerConnection {
-    createOffer(): Promise<{
+    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;
+}
+export interface BasicBrowserPeerConnection {
+    createOffer(): Promise<RTCSessionDescriptionInit>;
     acceptAnswer(answer: {
         type: 'answer';
         sdp: string;
     }): Promise<void>;
     addIceCandidate(candidate: Partial<RTCIceCandidate>): Promise<void>;
     onIceCandidate: Subject<RTCIceCandidate>;
-    onConnectionState: Observable<ConnectionState>;
+    onConnectionState: Observable<RTCPeerConnectionState>;
     close(): void;
-    requestKeyFrame?: () => void;
 }
 export interface CameraDevice {
     id: string;
     pluginId: string;
     nativeId?: string;
+    state: boolean;
     disabled: boolean;
     name: string;
-    type: string;
-    model: string;
+    type: CameraType;
+    info: CameraInformation;
     sources: CameraSource[];
     motionZones: CameraZone[];
     objectZones: CameraZone[];
-    logger: BaseLogger;
     isCloud: boolean;
     hasLight: boolean;
     hasSiren: boolean;
+    hasBinarySensor: boolean;
+    hasBattery: boolean;
     hasMotionDetector: boolean;
     hasAudioDetector: boolean;
     hasObjectDetector: boolean;
     hasPtz: boolean;
-    onLightDetected: Observable<LightState>;
+    onStarted: Observable<boolean>;
+    onLightSwitched: Observable<LightState>;
     onMotionDetected: Observable<MotionState>;
     onAudioDetected: Observable<AudioState>;
     onObjectDetected: Observable<ObjectState>;
     onDoorbellPressed: Observable<DoorbellState>;
     onSirenDetected: Observable<SirenState>;
-    getStreamSource(): CameraSource;
-    getSnapshotSource(): CameraSource;
-    getRecordingSource(): CameraSource;
-    getDetectionSource(): CameraSource;
-    configureDelegate(delegate: CameraDelegate): void;
-    snapshot(prebuffer?: boolean): Promise<ArrayBuffer>;
-    setPrebufferSource(sourceName: string, address: string, type: 'recording' | 'stream'): Promise<void>;
-    removePrebufferSource(sourceName: string, type: 'recording' | 'stream'): Promise<void>;
-    removePrebufferSources(): Promise<void>;
+    onBatteryChanged: Observable<BatteryState>;
+    streamSource: CameraSource;
+    snapshotSource: CameraSource;
+    recordingSource: CameraSource;
+    detectionSource: CameraSource;
+    delegate?: CameraDelegate;
+    prebufferDelegate?: CameraPrebufferDelegate;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    reboot(): Promise<void>;
     getFfmpegPath(): Promise<string>;
-    getIceServers(): Promise<RTCIceServer[]>;
+    getIceServers(): Promise<IceServer[]>;
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<StreamingSession>;
+    createBrowserSession(sourceName: string): Promise<BrowserStreamingSession>;
     streamVideo(sourceName: string, options: FfmpegOptions): Promise<StreamingSession>;
     recordToFile(sourceName: string, outputPath: string, duration?: number): Promise<void>;
     getValue<T extends keyof StateValues>(stateName: T): StateValue<T>;
@@ -91,6 +114,30 @@ export interface CameraDelegate {
     prepareStream(requestId: string): Promise<void>;
     onOffer(requestId: string, sdp: string): Promise<string>;
     onCandidates(requestId: string, candidates: string): Promise<void>;
+    reboot(): Promise<void>;
+}
+export interface CameraPrebufferDelegate {
+    isPrebuffering(sourceName: string, type: PrebufferType): Promise<boolean>;
+    getPrebufferRawUrl(sourceName: string, type: PrebufferType): Promise<string | undefined>;
+    getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;
+}
+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 interface StreamInfo {
+    audio: AudioStreamOptions;
+    video: VideoStreamOptions;
 }
 export type Sdp = string;
 export type IceCandiate = string;
@@ -118,8 +165,10 @@ export interface BaseCameraConfig {
     isCloud?: boolean;
     hasLight?: boolean;
     hasSiren?: boolean;
+    hasBinarySensor?: boolean;
+    hasBattery?: boolean;
     disabled?: boolean;
-    model?: string;
+    info?: Partial<CameraInformation>;
 }
 export type CameraConfig = (BaseCameraConfig & {
     sources?: Omit<CameraInputSettings, '_id'>[];
@@ -149,6 +198,9 @@ export interface DoorbellSetEvent {
 export interface SirenSetEvent {
     state: boolean;
 }
+export interface BatterySetEvent {
+    state: number;
+}
 export interface DeviceSetEvent {
 }
 export type LightState = BaseState & LightSetEvent;
@@ -157,7 +209,8 @@ export type AudioState = BaseState & AudioSetEvent;
 export type DoorbellState = BaseState & DoorbellSetEvent;
 export type SirenState = BaseState & SirenSetEvent;
 export type ObjectState = BaseState & ObjectSetEvent;
-export type State = LightState | MotionState | AudioState | ObjectState | DoorbellState | SirenState;
+export type BatteryState = BaseState & BatterySetEvent;
+export type State = LightState | MotionState | AudioState | ObjectState | DoorbellState | SirenState | BatteryState;
 export interface StateValues {
     light: LightState;
     motion: MotionState;
@@ -165,10 +218,11 @@ export interface StateValues {
     object: ObjectState;
     doorbell: DoorbellState;
     siren: SirenState;
+    battery: BatteryState;
 }
 export type CameraStateCallbacks = {
     [K in keyof StateValues]: (event: StateValues[K]) => void;
 };
 export type StateValue<T extends keyof StateValues> = StateValues[T];
-export type OnSetEvent<T extends keyof StateValues> = T extends 'light' ? LightSetEvent : T extends 'motion' ? MotionSetEvent : T extends 'audio' ? AudioSetEvent : T extends 'doorbell' ? DoorbellSetEvent : T extends 'siren' ? SirenSetEvent : ObjectSetEvent;
+export type OnSetEvent<T extends keyof StateValues> = T extends 'light' ? LightSetEvent : T extends 'motion' ? MotionSetEvent : T extends 'audio' ? AudioSetEvent : T extends 'doorbell' ? DoorbellSetEvent : T extends 'siren' ? SirenSetEvent : T extends 'battery' ? BatterySetEvent : ObjectSetEvent;
 export type OnChangeCallback<T extends keyof StateValues> = (newEvent: StateValues[T], oldEvent: StateValues[T]) => void;

package/dist/src/go2rtc/index.d.ts

@@ -21,4 +21,5 @@ export declare class Go2Rtc {
     private handleClose;
     private setStatus;
     private processLogger;
+    private isIgnorableString;
 }

package/dist/src/plugins/api.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { DeviceManager, PluginsManager, SystemManager } from '../proxy/client';
+import { StorageController } from './storageController';
+import type { ZmqInfo } from './types';
+import type { Plugin } from './plugin';
+import type { PluginLogger } from '../services/logger';
+import type { BasePlugin } from './base';
+import type { PluginConfigService } from './config';
+export interface API {
+    on(event: 'finishLaunching', listener: () => void): this;
+    on(event: 'shutdown', listener: () => void): this;
+    readonly deviceManager: DeviceManager;
+    readonly pluginsManager: PluginsManager;
+    readonly systemManager: SystemManager;
+    readonly storageController: StorageController;
+    readonly configService: PluginConfigService;
+    readonly storagePath: string;
+    readonly configFile: string;
+}
+export declare class PluginAPI extends EventEmitter implements API {
+    readonly deviceManager: DeviceManager;
+    readonly pluginsManager: PluginsManager;
+    readonly systemManager: SystemManager;
+    readonly storageController: StorageController;
+    readonly configService: PluginConfigService;
+    readonly storagePath: string;
+    readonly configFile: string;
+    readonly plugin: BasePlugin;
+    constructor(plugin: Plugin, logger: PluginLogger, proxyData: ZmqInfo);
+}

package/dist/src/plugins/base.d.ts

@@ -1,19 +1,15 @@
-import type { API } from '../api';
+import type { API } from './api';
 import type { CameraDevice } from '../camera/types';
 import type { PluginLogger } from '../services/logger';
-import type { PluginConfigService } from './config';
-import type { BasePlugin as BasePluginMethods } from './types';
-import type { Storage } from './storageController';
-export declare class BasePlugin implements BasePluginMethods {
+import type { PluginContract } from './types';
+export declare abstract class BasePlugin {
+    static contract: PluginContract;
     id: string;
     api: API;
-    configService: PluginConfigService;
     logger: PluginLogger;
-    storage: Storage;
-    cameras: Map<string, CameraDevice>;
-    constructor(pluginId: string, log: PluginLogger, configService: PluginConfigService, storage: Storage, api: API);
-    onFormSubmit(actionId: string, payload: any): Promise<{
+    constructor(pluginId: string, log: PluginLogger, api: API);
+    abstract onFormSubmit(actionId: string, payload: any): Promise<{
         toast?: string;
     } | void>;
-    configureCameras(cameras: CameraDevice[]): void;
+    abstract configureCameras(cameras: CameraDevice[]): void;
 }

package/dist/src/plugins/cameraStorage.d.ts

@@ -1,12 +1,13 @@
-import type { API } from '../api';
-import type { PluginJsonSchemaForm, PluginJsonSchema, CameraStorage as CameraStorageMethods, SchemaConfig } from './types';
-export declare class CameraStorage implements CameraStorageMethods {
+import type { API } from './api';
+import type { PluginJsonSchemaForm, PluginJsonSchema, SchemaConfig } from './types';
+export declare class CameraStorage {
     private cameraId;
     private instance;
     private api;
     private db;
     private _schema;
     private _values;
+    get values(): Record<string, any>;
     constructor(api: API, instance: any, cameraId: string, schema?: PluginJsonSchemaForm);
     /**
      * Initialize the storage.
@@ -22,8 +23,8 @@ export declare class CameraStorage implements CameraStorageMethods {
      * @param path - The path to the configuration value.
      * @returns The value from the configuration.
      */
+    getValue<T = string>(path: string): Promise<T> | T | undefined;
     getValue<T = string>(path: string, defaultValue: T): Promise<T> | T;
-    getValue<T = string>(path: string, defaultValue?: T): Promise<T> | T | undefined;
     /**
      * Set a new value for a given key/path in the configuration.
      * If the schema of the value has an onSet function, and the value has changed, the onSet function will be called.

package/dist/src/plugins/index.d.ts

@@ -12,9 +12,7 @@ export declare class PluginManager {
     plugins: Map<string, Plugin>;
     pluginWorkers: Map<string, PluginWorker>;
     searchPaths: Set<string>;
-    private api;
     private configService;
-    private currentInitializingPlugin?;
     constructor();
     static isQualifiedPluginIdentifier(pluginName: string): boolean;
     static extractPluginScope(pluginName: string): string;
@@ -23,7 +21,6 @@ export declare class PluginManager {
     static loadPackageJSON(installPath: string): IPackageJson;
     initializeInstalledPlugins(): Promise<void>;
     initializeInstalledPlugin(plugin: Plugin, insertDb?: boolean): Promise<void>;
-    initializePlugin(plugin: Plugin, pluginName: string): Promise<void>;
     loadPlugin(absolutePath: string, pluginId?: string, storagePath?: string): Promise<Plugin>;
     removePlugin(plugin: Plugin, removeFromDb?: boolean, removeStorage?: boolean): Promise<void>;
     startPluginChilds(): Promise<void>;
@@ -31,7 +28,6 @@ export declare class PluginManager {
     stopPluginChild(pluginName: string): Promise<void>;
     private loadInstalledPlugins;
     private removeOrphanedPlugins;
-    private handlePluginRegistration;
     private loadDefaultPaths;
     private addNpmPrefixToSearchPaths;
     private isDependencyForOthers;

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

@@ -5,7 +5,7 @@
  *
  **/
 import { PluginConfigService } from './config';
-import type { CameraUiAPI, PluginConstructor } from '../api';
+import type { PluginConstructor } from '../api';
 import type { IPackageJson, CameraUiPlugin } from '../api/types';
 import type { PluginContract } from './types';
 export interface Context {
@@ -33,18 +33,14 @@ export declare class Plugin {
     readonly storagePath: string;
     private readonly main;
     private loadContext?;
-    private pluginInitializer?;
-    private pluginConstructor;
+    pluginConstructor?: PluginConstructor;
     get contract(): PluginContract;
     get info(): CameraUiPlugin;
     set info(value: CameraUiPlugin);
     get disabled(): boolean;
     set disabled(value: boolean);
     constructor(pluginName: string, installPath: string, packageJSON: IPackageJson, pluginId: string, scope?: string, storagePath?: string);
-    getPluginConstructor(pluginName: string): PluginConstructor;
-    initialize(api: CameraUiAPI): void | Promise<void>;
     load(): Promise<void>;
-    registerPlugin(constructor: PluginConstructor, contract: PluginContract): void;
     reparsePackageJson(): CameraUiPlugin;
     private parsePackageJson;
 }

package/dist/src/plugins/schema.d.ts

@@ -18,8 +18,8 @@ type OptionalZodZobject = z.ZodOptional<z.ZodObject<Record<string, z.ZodTypeAny>
     [x: string]: any;
 }> | z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>> | z.ZodRecord<z.ZodString, z.ZodAny>;
 type OptionalZodArray = z.ZodOptional<z.ZodType<any, any, any>> | z.ZodType<any, any, any>;
-type OptionalZodEnum = z.ZodOptional<z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>> | z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>;
-type OptionalZodEnumMultiple = z.ZodOptional<z.ZodArray<z.ZodUnion<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>, 'many'>> | z.ZodArray<z.ZodUnion<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>, 'many'>;
+type OptionalZodEnum = z.ZodOptional<z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>> | z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]> | z.ZodEffects<z.ZodAny, any, any> | z.ZodUnion<any>;
+type OptionalZodEnumMultiple = z.ZodOptional<z.ZodArray<z.ZodUnion<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>, 'many'>> | z.ZodArray<z.ZodUnion<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>, 'many'> | z.ZodEffects<z.ZodAny, any, any> | z.ZodUnion<any>;
 type ZodAny = z.ZodType<any, any, any>;
 /**
  * Generate root JSON schema from value.
@@ -137,7 +137,7 @@ export declare const generateStringSchema: (value: string) => JsonSchemaString;
  * @param type - The type of the enum.
  * @returns - The generated JSON schema for the enum.
  */
-export declare const generateEnumSchema: (value: (string | number | boolean)[], type: 'string' | 'number' | 'boolean') => JsonSchemaEnum;
+export declare const generateEnumSchema: (value: string[]) => JsonSchemaEnum;
 /**
  * Generates a JSON schema for an object.
  *

package/dist/src/plugins/storageController.d.ts

@@ -1,7 +1,7 @@
 import { CameraStorage } from './cameraStorage';
-import type { API } from '../api';
+import type { API } from './api';
 import type { PluginJsonSchemaForm } from './types';
-export declare class Storage {
+export declare class StorageController {
     private api;
     private cameraStorages;
     constructor(api: API);