@camera.ui/browser 0.0.94 → 0.0.95

package/dist/types/packages/types/src/index.d.ts

@@ -0,0 +1,657 @@
+import type { Observable, ReplaySubject, Subject, Subscription } from 'rxjs';
+import type sharp from 'sharp';
+import type { ConnectionState, RTCIceCandidate, RTCSessionDescription, RtpPacket } from 'werift';
+export type { ConnectionState, RTCIceCandidate, RTCSessionDescription, RtpPacket, sharp };
+export type JSONValue = string | number | boolean | JSONObject | JSONArray;
+export interface JSONObject {
+    [key: string]: JSONValue;
+}
+export type JSONArray = JSONValue[];
+export type Path = Array<number | string> | number | string;
+export type CameraType = 'camera' | 'doorbell';
+export type ZoneType = 'intersect' | 'contain';
+export type ZoneFilter = 'include' | 'exclude';
+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 type CameraRoles = 'high-resolution' | 'mid-resolution' | 'low-resolution' | 'snapshot';
+export type Container = 'mp4' | 'mpegts';
+export type DecoderFormat = 'yuv' | 'rgb';
+export type ImageInputFormat = 'yuv' | 'rgb' | 'rgba' | 'gray';
+export type ImageOutputFormat = 'rgb' | 'rgba' | 'gray';
+export type CameraExtension = 'hub' | 'prebuffer' | 'motionDetection' | 'objectDetection' | 'audioDetection' | 'ptz';
+export type CameraFrameWorkerDecoder = 'pillow' | 'wasm';
+export type CameraFrameWorkerResolution = 640 | 480 | 320;
+export type AudioCodec = 'PCMU' | 'PCMA' | 'MPEG4-GENERIC' | 'opus' | 'G722' | 'MPA' | 'PCM' | 'FLAC';
+export type AudioFFmpegCodec = 'pcm_mulaw' | 'pcm_alaw' | 'aac' | 'libopus' | 'g722' | 'mp3' | 'pcm_s16be' | 'pcm_s16le' | 'flac';
+export type VideoCodec = 'H264' | 'H265' | 'VP8' | 'VP9' | 'AV1' | 'JPEG' | 'RAW';
+export type VideoFFmpegCodec = 'h264' | 'hevc' | 'vp8' | 'vp9' | 'av1' | 'mjpeg' | 'rawvideo';
+export interface CameraInformation {
+    model?: string;
+    manufacturer?: string;
+    hardware?: string;
+    serialNumber?: string;
+    firmwareVersion?: string;
+    supportUrl?: string;
+}
+export type Point = [number, number];
+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 ZoneCoord {
+    _id: string;
+    points: Point;
+}
+export interface ZoneRegion {
+    _id: string;
+    coords: ZoneCoord[];
+    type: ZoneType;
+    filter: ZoneFilter;
+    classes: ObjectClass[];
+    isPrivacyMask: boolean;
+}
+export interface CameraZone {
+    name: string;
+    regions: ZoneRegion[];
+}
+export interface DetectionZone {
+    name: string;
+    points: Point[];
+    type: ZoneType;
+    filter: ZoneFilter;
+    classes: ObjectClass[];
+    isPrivacyMask: boolean;
+}
+export interface MotionDetectionSettings {
+    timeout: number;
+}
+export interface ObjectDetectionSettings {
+    confidence: number;
+}
+export interface CameraActivitySettings {
+    motion: MotionDetectionSettings;
+    object: ObjectDetectionSettings;
+}
+export interface CameraFrameWorkerSettings {
+    decoder: CameraFrameWorkerDecoder;
+    fps: number;
+    resolution: CameraFrameWorkerResolution;
+}
+export interface CameraInput {
+    readonly _id: string;
+    name: string;
+    roles: CameraRoles[];
+    urls: StreamUrls;
+    internal: boolean;
+}
+export interface PrebufferState {
+    url?: string;
+    duration?: number;
+}
+export interface AudioCodecProperties {
+    sampleRate: number;
+    channels: number;
+    payloadType: number;
+}
+export interface VideoCodecProperties {
+    clockRate: number;
+    payloadType: number;
+}
+export interface AudioStreamInfo {
+    codec: AudioCodec;
+    ffmpegCodec: AudioFFmpegCodec;
+    properties: AudioCodecProperties;
+    direction: 'sendonly' | 'recvonly';
+}
+export interface VideoStreamInfo {
+    codec: VideoCodec;
+    ffmpegCodec: VideoFFmpegCodec;
+    properties: VideoCodecProperties;
+    direction: 'sendonly';
+}
+export interface ProbeStream {
+    sdp: string;
+    audio: AudioStreamInfo[];
+    video: VideoStreamInfo;
+}
+export interface StreamUrls {
+    ws: Go2RtcWSSource;
+    rtsp: Go2RtcRTSPSource;
+    www: Go2RtcEndpoint;
+}
+export interface Go2RtcRTSPSource {
+    single: string;
+    default: string;
+    mp4: string;
+}
+export interface Go2RtcEndpoint {
+    webrtc: string;
+    mse: string;
+    lmp4: string;
+    mmp4: string;
+    mp4: string;
+    mp4Snapshot: string;
+    jpegSnapshot: string;
+    lHlsTs: string;
+    lHlsFmp4: string;
+    mHlsFmp4: string;
+    mjpeg: string;
+    mjpegHtml: string;
+}
+export interface Go2RtcSource {
+    name: string;
+    src: string;
+    ws: string;
+}
+export interface Go2RtcWSSource {
+    webrtc: string;
+}
+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;
+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 interface FrameData {
+    frameId: string;
+    timestamp: number;
+}
+export interface FrameMetadata {
+    format: DecoderFormat;
+    frameSize: number;
+    width: number;
+    origWidth: number;
+    height: number;
+    origHeight: number;
+}
+export interface ImageInformation {
+    width: number;
+    height: number;
+    channels: 1 | 3 | 4;
+    format: ImageInputFormat;
+}
+export interface ImageCrop {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export interface ImageResize {
+    width?: number;
+    height?: number;
+}
+export interface ImageFormat {
+    to: ImageOutputFormat;
+}
+export interface ImageOptions {
+    format?: ImageFormat;
+    crop?: ImageCrop;
+    resize?: ImageResize;
+}
+export interface FrameImage {
+    image: sharp.Sharp;
+    info: ImageInformation;
+}
+export interface FrameBuffer {
+    image: Uint8Array;
+    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 {
+    readonly motion: MotionState;
+}
+export interface CameraInputSettings {
+    readonly _id: string;
+    name: string;
+    roles: CameraRoles[];
+    urls: string[];
+    internal: boolean;
+}
+export interface CameraConfigInputSettings extends Omit<CameraInputSettings, '_id' | 'internal'> {
+}
+export interface BaseCameraConfig {
+    name: string;
+    nativeId?: string;
+    isCloud?: boolean;
+    hasLight?: boolean;
+    hasSiren?: boolean;
+    hasBinarySensor?: boolean;
+    hasBattery?: boolean;
+    disabled?: boolean;
+    info?: Partial<CameraInformation>;
+}
+export type CameraConfig = BaseCameraConfig & {
+    sources: CameraConfigInputSettings[];
+};
+export interface CameraDelegate {
+    snapshot(): Promise<ArrayBuffer | undefined>;
+}
+export interface CameraPrebufferDelegate {
+    getPrebufferingState(sourceName: string, container: Container): Promise<PrebufferState | undefined>;
+}
+export interface CameraPTZDelegate {
+    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>;
+}
+export interface CameraDelegates {
+    cameraDelegate: CameraDelegate;
+    prebufferDelegate: CameraPrebufferDelegate;
+    ptzDelegate: CameraPTZDelegate;
+}
+export interface CameraSource extends CameraInput {
+    getPrebufferingState(container: Container): Promise<PrebufferState | undefined>;
+    probeStream(): Promise<ProbeStream | undefined>;
+}
+export interface CameraInternalSource extends CameraSource {
+    type: 'aac' | 'opus' | 'pcma';
+}
+export interface CameraDeviceSource extends CameraSource {
+    createSession(options?: StreamingConnectionOptions): WeriftSession;
+}
+export interface CameraDeviceInternalSource extends CameraDeviceSource, CameraInternalSource {
+}
+export interface StreamingConnectionOptions {
+    createPeerConnection?: () => BasicPeerConnection;
+    iceServers?: IceServer[];
+}
+export interface Subscribed {
+    addSubscriptions(...subscriptions: Subscription[]): void;
+    addAdditionalSubscriptions(...subscriptions: Subscription[]): void;
+    unsubscribe(): void;
+    unsubscribeAdditional(): void;
+}
+export interface WeriftSession extends Subscribed {
+    readonly onCallEnded: ReplaySubject<void>;
+    readonly onVideoRtp: Subject<RtpPacket>;
+    readonly onAudioRtp: Subject<RtpPacket>;
+    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 type SpawnInput = string | number;
+export interface FfmpegOptions {
+    ffmpegPath: string;
+    input?: SpawnInput[];
+    video?: SpawnInput[];
+    audio?: SpawnInput[];
+    output: SpawnInput[];
+    logger?: {
+        error: (...args: any[]) => void;
+        info: (...args: any[]) => void;
+    };
+}
+export interface BasicPeerConnection {
+    createOffer(): Promise<RTCSessionDescription>;
+    acceptAnswer(answer: {
+        type: 'answer';
+        sdp: string;
+    }): Promise<void>;
+    addIceCandidate(candidate: Partial<RTCIceCandidate>): Promise<void>;
+    onIceCandidate: Subject<RTCIceCandidate>;
+    onConnectionState: Observable<ConnectionState>;
+    close(): void;
+    requestKeyFrame?: () => void;
+}
+export interface BaseCamera {
+    readonly _id: string;
+    nativeId?: string;
+    pluginId: string;
+    name: string;
+    disabled: boolean;
+    isCloud: boolean;
+    hasLight: boolean;
+    hasSiren: boolean;
+    hasBinarySensor: boolean;
+    hasBattery: boolean;
+    info: CameraInformation;
+    type: CameraType;
+    activityZones: CameraZone[];
+    activitySettings: CameraActivitySettings;
+    frameWorkerSettings: CameraFrameWorkerSettings;
+}
+export interface Camera extends Omit<BaseCamera, 'activityZones'> {
+    hasAudioDetector: boolean;
+    hasMotionDetector: boolean;
+    hasObjectDetector: boolean;
+    hasPtz: boolean;
+    hasPrebuffer: boolean;
+    sources: CameraInput[];
+    activityZones: DetectionZone[];
+}
+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 ptz: CameraPTZDelegate;
+    readonly streamSource: CameraDeviceSource;
+    readonly highResolutionSource: CameraDeviceSource | undefined;
+    readonly midResolutionSource: CameraDeviceSource | undefined;
+    readonly lowResolutionSource: CameraDeviceSource | undefined;
+    readonly snapshotSource: CameraSource | undefined;
+    readonly sources: CameraDeviceSource[];
+    readonly internalSources: CameraDeviceInternalSource[];
+    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>(delegateName: T, delegate: CameraDelegates[T]): void;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getFrames(prebufferDuration?: number): AsyncIterableIterator<VideoFrame>;
+    getMotionFrames(): AsyncIterableIterator<MotionFrame>;
+    updateState<T extends keyof Omit<SetValues, 'motion'>>(stateName: T, eventData: SetValues[T]): Promise<void>;
+    updateState(stateName: 'motion', eventData: MotionSetEvent, frame?: VideoFrame): Promise<void>;
+    addCameraSource(source: CameraConfigInputSettings): Promise<void>;
+    updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>): Promise<void>;
+    removeCameraSource(sourceId: string): Promise<void>;
+}
+export interface DeviceManager {
+    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>;
+    on(event: 'cameraSelected', listener: (camera: CameraDevice, extension: CameraExtension) => void): this;
+    on(event: 'cameraDeselected', listener: (cameraId: string, extension: CameraExtension) => void): this;
+    once(event: 'cameraSelected', listener: (camera: CameraDevice, extension: CameraExtension) => void): this;
+    once(event: 'cameraDeselected', listener: (cameraId: string, extension: CameraExtension) => void): this;
+    off(event: 'cameraSelected', listener: (camera: CameraDevice, extension: CameraExtension) => void): this;
+    off(event: 'cameraDeselected', listener: (cameraId: string, extension: CameraExtension) => void): this;
+    removeListener(event: 'cameraSelected', listener: (camera: CameraDevice, extension: CameraExtension) => void): this;
+    removeListener(event: 'cameraDeselected', listener: (cameraId: string, extension: CameraExtension) => void): this;
+    removeAllListeners(event?: 'cameraSelected' | 'cameraDeselected'): this;
+}
+export interface CoreManager {
+    getFFmpegPath(): Promise<string>;
+    getHwaccelInfo(): Promise<FfmpegArgs>;
+    getServerAddresses(): Promise<string[]>;
+    getIceServers(): Promise<IceServer[]>;
+}
+export interface FfmpegArgs {
+    hwaccel: string;
+    hwaccelArgs: string[];
+    hwaccelFilter: string;
+    threads: string;
+}
+export interface IceServer {
+    urls: string[];
+    username?: string;
+    credential?: string;
+}
+export type PluginConfig<T = Record<string, any>> = T;
+export type JsonSchemaType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'button';
+export interface JsonBaseSchema<T = any> {
+    type: JsonSchemaType;
+    key?: string;
+    title?: string;
+    description?: string;
+    required?: boolean;
+    readonly?: boolean;
+    placeholder?: string;
+    hidden?: boolean;
+    group?: string;
+    defaultValue?: T;
+    store?: boolean;
+    onSet?: (newValue: any, oldValue: any) => Promise<void>;
+    onGet?: () => Promise<any>;
+}
+export interface JsonSchemaString extends JsonBaseSchema<string> {
+    type: 'string';
+    format?: 'date-time' | 'date' | 'time' | 'email' | 'uuid' | 'ipv4' | 'ipv6' | 'password' | 'qrCode' | 'image';
+    minLength?: number;
+    maxLength?: number;
+}
+export interface JsonSchemaNumber extends JsonBaseSchema<number> {
+    type: 'number';
+    minimum?: number;
+    maximum?: number;
+    step?: number;
+}
+export interface JsonSchemaBoolean extends JsonBaseSchema<boolean> {
+    type: 'boolean';
+}
+export interface JsonSchemaEnum extends JsonBaseSchema<string> {
+    type: 'string';
+    enum: string[];
+    multiple?: boolean;
+}
+export interface JsonSchemaObject extends JsonBaseSchema {
+    type: 'object';
+    opened?: boolean;
+    properties?: JsonSchemaForm;
+}
+export interface JsonSchemaArray extends JsonBaseSchema {
+    type: 'array';
+    opened?: boolean;
+    items?: JsonSchema;
+}
+export interface JsonSchemaButton extends JsonBaseSchema {
+    type: 'button';
+}
+export interface JsonSchemaObjectButton {
+    label: string;
+    onSubmit: string;
+}
+export interface JsonSchemaObjectWithButtons extends JsonSchemaObject {
+    buttons: JsonSchemaObjectButton[];
+}
+export type JsonSchema = JsonSchemaString | JsonSchemaNumber | JsonSchemaBoolean | JsonSchemaEnum | JsonSchemaObject | JsonSchemaObjectWithButtons | JsonSchemaArray | JsonSchemaButton;
+export interface JsonSchemaForm {
+    [key: string]: JsonSchema;
+}
+export interface RootSchema {
+    schema: JsonSchemaForm;
+}
+export interface ToastMessage {
+    type: 'info' | 'success' | 'warning' | 'error';
+    message: string;
+}
+export interface FormSubmitSchema {
+    config: JsonSchemaObjectWithButtons;
+}
+export interface FormSubmitResponse {
+    toast?: ToastMessage;
+    schema?: FormSubmitSchema;
+}
+export interface SchemaConfig {
+    rootSchema: RootSchema;
+    config: Record<string, any>;
+}
+export interface ImageMetadata {
+    width: number;
+    height: number;
+}
+export interface AudioMetadata {
+    mimeType: 'audio/mpeg' | 'audio/wav' | 'audio/ogg';
+}
+export interface MotionDetectionPluginResponse {
+    filePath: string;
+}
+export interface ObjectDetectionPluginResponse {
+    detections: Detection[];
+}
+export interface AudioDetectionPluginResponse {
+    detected: boolean;
+}
+export interface BasePlugin {
+    onFormSubmit(actionId: string, payload: any): Promise<FormSubmitResponse | void>;
+    configureCameras(cameras: CameraDevice[]): void;
+}
+export interface AudioDetectionPlugin extends BasePlugin {
+    interfaceSchema(): RootSchema | void;
+    detectAudio(audioPath: string, metadata: AudioMetadata, config: Record<string, any>): Promise<AudioDetectionPluginResponse>;
+}
+export interface MotionDetectionPlugin extends BasePlugin {
+    interfaceSchema(): RootSchema | void;
+    detectMotion(videoPath: string, config: Record<string, any>): Promise<MotionDetectionPluginResponse>;
+}
+export interface ObjectDetectionPlugin extends BasePlugin {
+    interfaceSchema(): RootSchema | void;
+    detectObjects(imagePath: string, metadata: ImageMetadata, config: Record<string, any>): Promise<ObjectDetectionPluginResponse>;
+}
+export interface LoggerService {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    trace: (...args: any[]) => void;
+    attention: (...args: any[]) => void;
+}
+export interface PluginAPI {
+    readonly coreManager: CoreManager;
+    readonly deviceManager: DeviceManager;
+    readonly storageController: StorageController;
+    readonly configService: ConfigService;
+    readonly storagePath: string;
+    readonly configFile: string;
+    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?: 'shutdown' | 'finishLaunching'): this;
+}
+export interface ConfigService {
+    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 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;
+}