@camera.ui/browser 0.0.68 → 0.0.70

package/dist/types/server/src/plugins/node/proxy/cameraDevice.d.ts

@@ -0,0 +1,44 @@
+import { CameraDevice } from '../../../camera/base/cameraDevice.js';
+import type { Camera } from '../../../api/database/types.js';
+import type { CameraSource, OnSetEvent, StateValues } from '../../../camera/types.js';
+import type { Frame } from '../../../decoder/types.js';
+import type { IceServer } from '../../../services/config/types.js';
+import type { PluginAPI } from '../api.js';
+import type { PluginLogger } from '../logger.js';
+export declare class CameraDeviceProxy extends CameraDevice {
+    private api;
+    private initialized;
+    private publisher;
+    private client;
+    private cameraSubscriber;
+    private cameraPluginSubscriber;
+    private frameSubscriber?;
+    private activeSockets;
+    private messageQueue;
+    private auth;
+    private pluginID;
+    private pluginName;
+    private clientSubject;
+    private cameraSubscriberSubject;
+    private cameraPluginSubscriberSubject;
+    private frameSubject;
+    get sources(): CameraSource[];
+    constructor(api: PluginAPI, logger: PluginLogger, camera: Camera, pluginId: string, pluginName: string, auth: {
+        user: string;
+        pass: string;
+    });
+    init(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    reboot(): Promise<void>;
+    generateFrames(): AsyncIterableIterator<Frame>;
+    getFfmpegPath(): Promise<string>;
+    getIceServers(): Promise<IceServer[]>;
+    updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): Promise<void>;
+    refreshStates(): Promise<void>;
+    cleanup(): Promise<void>;
+    private connectToServer;
+    private requestHandler;
+    private listenToMessages;
+    private onRequest;
+}

package/dist/types/server/src/plugins/node/proxy/deviceManager.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'node:events';
+import { CameraDeviceProxy } from './cameraDevice.js';
+import type { CameraDevice } from '../../../camera/base/cameraDevice.js';
+import type { CameraConfig } from '../../../camera/types.js';
+import type { DeviceManagerProxyEventCallbacks, DeviceManagerProxyMethods } from '../../../nats/types.js';
+import type { PluginAPI } from '../api.js';
+import type { PluginLogger } from '../logger.js';
+export declare 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 declare class DeviceManager extends EventEmitter implements DeviceManager {
+    private api;
+    private logger;
+    private initialized;
+    private publisher;
+    private client;
+    private subscriber;
+    private messageQueue;
+    private auth;
+    private pluginId;
+    private pluginName;
+    private clientSubject;
+    private subscriberSubject;
+    private devices;
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, auth: {
+        user: string;
+        pass: string;
+    });
+    init(): Promise<void>;
+    getCameraById(id: string): Promise<CameraDevice | undefined>;
+    getCameraByName(name: string): Promise<CameraDevice | undefined>;
+    createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
+    removeCameraByName(name: string): Promise<void>;
+    removeCameraById(id: string): Promise<void>;
+    emit(): boolean;
+    configureCameras(cameraDevices: CameraDeviceProxy[]): void;
+    private requestHandler;
+    private listenToMessages;
+    private onRequest;
+    private addOrGetCamera;
+    private close;
+}

package/dist/types/server/src/plugins/node/proxy/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cameraDevice.js';
+export * from './deviceManager.js';
+export * from './pluginsManager.js';
+export * from './systemManager.js';

package/dist/types/server/src/plugins/node/proxy/pluginsManager.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'node:events';
+import type { PluginsManagerProxyEventCallbacks, PluginsManagerProxyMethods } from '../../../nats/types.js';
+import type { PluginAPI } from '../api.js';
+import type { PluginLogger } from '../logger.js';
+export declare interface PluginsManager extends PluginsManagerProxyMethods {
+    on<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    once<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    off<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    removeListener<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    removeAllListeners<E extends keyof PluginsManagerProxyEventCallbacks>(event?: E): this;
+}
+export declare class PluginsManager extends EventEmitter implements PluginsManager {
+    private api;
+    private logger;
+    private initialized;
+    private publisher;
+    private client;
+    private subscriber;
+    private messageQueue;
+    private auth;
+    private pluginId;
+    private pluginName;
+    private clientSubject;
+    private subscriberSubject;
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, auth: {
+        user: string;
+        pass: string;
+    });
+    init(): Promise<void>;
+    emit(): boolean;
+    private requestHandler;
+    private listenToMessages;
+    private onRequest;
+    private isPluginMessage;
+    private isStorageMessage;
+    private close;
+}

package/dist/types/server/src/plugins/node/proxy/queue.d.ts

@@ -0,0 +1,18 @@
+import { type NatsConnection, type Subscription } from 'nats';
+import type { BaseLogger } from '../../../camera/types.js';
+import type { ProxyMessageStructure } from '../../../nats/types.js';
+export declare class ClientMessageQueue {
+    private logger;
+    private publisher;
+    private subscriber;
+    private requestHandler;
+    private aborted;
+    private isProcessing;
+    private queue;
+    private pendingResponses;
+    constructor(logger: BaseLogger, publisher: NatsConnection, subscriber: Subscription, requestHandler: (message: ProxyMessageStructure) => void);
+    abortQueue(): void;
+    enqueue(message: ProxyMessageStructure): Promise<any>;
+    private processQueue;
+    private listenToMessages;
+}

package/dist/types/server/src/plugins/node/proxy/systemManager.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'node:events';
+import type { SystemManagerProxyEventCallbacks, SystemManagerProxyMethods } from '../../../nats/types.js';
+import type { PluginAPI } from '../api.js';
+import type { PluginLogger } from '../logger.js';
+export declare interface SystemManager extends SystemManagerProxyMethods {
+    on<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    once<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    off<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    removeListener<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    removeAllListeners<E extends keyof SystemManagerProxyEventCallbacks>(event?: E): this;
+}
+export declare class SystemManager extends EventEmitter implements SystemManager {
+    private api;
+    private logger;
+    private initialized;
+    private publisher;
+    private client;
+    private subscriber;
+    private messageQueue;
+    private auth;
+    private pluginId;
+    private pluginName;
+    private clientSubject;
+    private subscriberSubject;
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, auth: {
+        user: string;
+        pass: string;
+    });
+    init(): Promise<void>;
+    emit(): boolean;
+    private requestHandler;
+    private listenToMessages;
+    private onRequest;
+    private close;
+}

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

@@ -0,0 +1,268 @@
+import { z, type ZodTypeAny } from 'zod';
+import type { JsonSchema, JsonSchemaAnyOf, JsonSchemaArray, JsonSchemaBoolean, JsonSchemaButton, JsonSchemaEnum, JsonSchemaNumber, JsonSchemaObject, JsonSchemaObjectWithButtons, JsonSchemaString, PluginJsonSchema, PluginJsonSchemaForm, PluginRootSchema, RootSchema } from '../types.js';
+type RootZodSchema = z.ZodObject<Record<string, ZodTypeAny>, 'strict', ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;
+type OptionalZodString = z.ZodOptional<z.ZodString> | z.ZodString | z.ZodOptional<z.ZodEffects<z.ZodString, string, string>> | z.ZodEffects<z.ZodString, string, string>;
+type OptionalZodNumber = z.ZodOptional<z.ZodNumber> | z.ZodNumber | z.ZodOptional<z.ZodEffects<z.ZodNumber, number, number>> | z.ZodEffects<z.ZodNumber, number, number>;
+type OptionalZodBoolean = z.ZodOptional<z.ZodBoolean> | z.ZodBoolean;
+type OptionalZodZobject = z.ZodOptional<z.ZodObject<Record<string, z.ZodTypeAny>, 'strict', z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>> | z.ZodObject<Record<string, z.ZodTypeAny>, 'strict', z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [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[]]> | 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.
+ *
+ * @param value - Value.
+ * @returns - Root JSON schema.
+ */
+export declare const generateRootSchema: (value: Record<string, any>) => RootSchema;
+/**
+ * Generate JSON schema from value.
+ *
+ * @param value - Value.
+ * @returns - JSON schema.
+ */
+export declare const generateSchema: (value: any) => JsonSchema;
+/**
+ * Generate a JSON object from a given Root JSON schema.
+ *
+ * @param rootSchema - The Root JSON schema.
+ * @returns - The generated JSON object.
+ */
+export declare const generateJsonFromRootSchema: (rootSchema: RootSchema | PluginRootSchema) => Record<string, any>;
+/**
+ * Generate a JSON object from a JSON schema.
+ *
+ * @param jsonSchema - The JSON schema.
+ * @returns - The generated JSON object.
+ */
+export declare const generateJsonFromSchema: (jsonSchema: JsonSchema | PluginJsonSchema) => any;
+/**
+ * Generate a JSON object from a given JSON schema and use values from a config file.
+ *
+ * @param jsonSchema - The JSON schema.
+ * @param config - The config file with values to use.
+ * @returns - The generated JSON object.
+ */
+export declare const generateJsonFromSchemaWithConfig: (jsonSchema: JsonSchema | PluginJsonSchema, config: Record<string, any>, path?: string) => any;
+/**
+ * Removes all functions from a given Plugin JSON schema form.
+ *
+ * @param schemaForm - The Plugin JSON schema form from which the functions should be removed.
+ * @returns - The Plugin JSON schema form without functions.
+ */
+export declare const removeFunctionsFromSchemaForm: (schemaForm: PluginJsonSchemaForm) => PluginJsonSchemaForm;
+/**
+ * Removes all functions from a given Plugin JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the functions should be removed.
+ * @returns - The JSON schema without functions.
+ */
+export declare const removeFunctionsFromSchema: (jsonSchema: PluginJsonSchema) => PluginJsonSchema;
+/**
+ * Converts a config path to a schema path.
+ *
+ * @param configPath - The config path to be converted.
+ * @returns - The converted schema path.
+ */
+export declare const configPathToSchemaPath: (configPath: string) => string;
+/**
+ * Converts a schema path to a config path.
+ *
+ * @param schemaPath - The schema path to be converted.
+ * @returns - The converted config path.
+ */
+export declare const schemaPathToConfigPath: (schemaPath: string) => string;
+/**
+ * Recursively searches a JSON object for a specific, potentially nested key path and returns its value.
+ *
+ * @param obj - The JSON object to be searched.
+ * @param path - The key path to search for.
+ * @returns - The value of the searched key path, if found, otherwise undefined.
+ */
+export declare const getValueByPath: (obj: any, path: string) => any;
+/**
+ * Generates a Zod schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be generated.
+ * @returns - The generated Zod schema.
+ */
+export declare const generateZodSchemaFromRoot: (rootSchema: RootSchema) => RootZodSchema;
+/**
+ * Generates a Zod schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be generated.
+ * @param initial - A boolean indicating whether this is the initial call to the function.
+ *                  This is used for handling nested schemas.
+ * @returns - The generated Zod schema.
+ */
+export declare const generateZodSchema: (jsonSchema: JsonSchema) => ZodAny;
+/**
+ * Generates a JSON schema for a number.
+ *
+ * @param value - The number for which the JSON schema should be generated.
+ * @returns - The generated JSON schema for the number.
+ */
+export declare const generateNumberSchema: () => JsonSchemaNumber;
+/**
+ * Generates a JSON schema for a boolean.
+ *
+ * @param value - The boolean for which the JSON schema should be generated.
+ * @returns - The generated JSON schema for the boolean.
+ */
+export declare const genereateBooleanSchema: () => JsonSchemaBoolean;
+/**
+ * Generates a JSON schema for a string.
+ *
+ * @param value - The string for which the JSON schema should be generated.
+ * @returns - The generated JSON schema for the string.
+ */
+export declare const generateStringSchema: (value: string) => JsonSchemaString;
+/**
+ * Generates a JSON schema for an enum.
+ *
+ * @param value - The enum for which the JSON schema should be generated.
+ * @param type - The type of the enum.
+ * @returns - The generated JSON schema for the enum.
+ */
+export declare const generateEnumSchema: (value: string[]) => JsonSchemaEnum;
+/**
+ * Generates a JSON schema for an object.
+ *
+ * @param value - The object for which the JSON schema should be generated.
+ * @returns - The generated JSON schema for the object.
+ */
+export declare const generateObjectSchema: (value: Record<string, any>) => JsonSchemaObject;
+/**
+ * Generates a JSON schema for an object including up to two buttons.
+ *
+ * @param value - The object for which the JSON schema should be generated.
+ * @param buttons - Array of min one button and up to two buttons to be included in the schema.
+ * @returns - The generated JSON schema for the object.
+ */
+export declare const generateObjectSchemaWithButtons: (value: Record<string, any>, buttons: [JsonSchemaButton, JsonSchemaButton?]) => JsonSchemaObjectWithButtons;
+/**
+ * Generates a JSON schema for an array.
+ *
+ * @param array - The array for which the JSON schema should be generated.
+ * @returns - The generated JSON schema for the array.
+ */
+export declare const generateArraySchema: (array: any[]) => JsonSchemaArray;
+/**
+ * Checks if the given JSON schema is of string type.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of string type, false otherwise.
+ */
+export declare const isStringType: (jsonSchema: Partial<JsonSchema>) => jsonSchema is JsonSchemaString;
+/**
+ * Checks if the given JSON schema is of number type.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of number type, false otherwise.
+ */
+export declare const isNumberType: (jsonSchema: Partial<JsonSchema>) => jsonSchema is JsonSchemaNumber;
+/**
+ * Checks if the given JSON schema is of boolean type.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of boolean type, false otherwise.
+ */
+export declare const isBooleanType: (jsonSchema: Partial<JsonSchema>) => jsonSchema is JsonSchemaBoolean;
+/**
+ * Checks if the given JSON schema is of enum type.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of enum type, false otherwise.
+ */
+export declare const isEnumType: (jsonSchema: Partial<JsonSchema>) => jsonSchema is JsonSchemaEnum;
+/**
+ * Checks if the given JSON schema is of object type.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of object type, false otherwise.
+ */
+export declare const isObjectType: (jsonSchema: Partial<JsonSchema>) => jsonSchema is JsonSchemaObject;
+/**
+ * Checks if the given JSON schema is of object type with buttons.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of object type with buttons, false otherwise.
+ */
+export declare const isObjectTypeWithButtons: (jsonSchema: Partial<JsonSchema>) => jsonSchema is JsonSchemaObjectWithButtons;
+/**
+ * Checks if the given JSON schema is of array type.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of array type, false otherwise.
+ */
+export declare const isArrayType: (jsonSchema: Partial<JsonSchema>) => jsonSchema is JsonSchemaArray;
+/**
+ * Checks if the given value is a JSON AnyOf Schema.
+ *
+ * @param value - The value to check.
+ * @returns - True if the value is a JSON AnyOf schema, false otherwise.
+ */
+export declare const isAnyOfSchema: (value: any) => value is JsonSchemaAnyOf;
+/**
+ * Checks if the given value is a JSON Primitive schema.
+ *
+ * @param value - The value to check.
+ * @returns - True if the value is a JSON schema, false otherwise.
+ */
+export declare const isPrimitiveType: (value: any) => value is JsonSchemaString | JsonSchemaNumber | JsonSchemaBoolean | JsonSchemaEnum;
+/**
+ * Creates a Zod string schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be created.
+ * @returns - The created Zod string schema.
+ */
+export declare const createZodStringSchema: (jsonSchema: JsonSchemaString) => OptionalZodString;
+/**
+ * Creates a Zod number schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be created.
+ * @returns - The created Zod number schema.
+ */
+export declare const createZodNumberSchema: (jsonSchema: JsonSchemaNumber) => OptionalZodNumber;
+/**
+ * Creates a Zod boolean schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be created.
+ * @returns - The created Zod boolean schema.
+ */
+export declare const createZodBooleanSchema: (jsonSchema: JsonSchemaBoolean) => OptionalZodBoolean;
+/**
+ * Creates a Zod union schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be created.
+ * @returns - The created Zod union schema.
+ */
+export declare const createEnumSchema: (jsonSchema: JsonSchemaEnum) => OptionalZodEnum | OptionalZodEnumMultiple;
+/**
+ * Creates a Zod object schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be created.
+ * @returns - The created Zod object schema.
+ */
+export declare const createZodObjectSchema: (jsonSchema: JsonSchemaObject) => OptionalZodZobject;
+/**
+ * Creates a Zod array schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be created.
+ * @returns - The created Zod array schema.
+ */
+export declare const createZodArraySchema: (jsonSchema: JsonSchemaArray) => OptionalZodArray;
+export {};

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

@@ -0,0 +1,28 @@
+import { CameraStorage } from './cameraStorage.js';
+import type { PluginJsonSchemaForm } from '../types.js';
+import type { PluginAPI } from './api.js';
+export declare class StorageController {
+    private api;
+    private cameraStorages;
+    constructor(api: PluginAPI);
+    /**
+     * Create a camera storage instance
+     *
+     * @param instance - The plugin instance
+     * @param cameraId - The camera id
+     * @param schema - The plugin schema
+     */
+    createCameraStorage(instance: any, cameraId: string, schema?: PluginJsonSchemaForm): Promise<CameraStorage>;
+    /**
+     * Get a camera storage instance
+     *
+     * @param cameraId - The camera id
+     */
+    getCameraStorage(cameraId: string): CameraStorage | undefined;
+    /**
+     * Remove a camera storage instance
+     *
+     * @param cameraId - The camera id
+     */
+    removeCameraStorage(cameraId: string): void;
+}

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

@@ -0,0 +1,42 @@
+import { PythonInstaller } from '../../bin/python.js';
+import { PluginConfigService } from './node/config.js';
+import type { PluginConstructor } from '../api.js';
+import type { CameraUiPlugin, IPackageJson } from '../api/types/index.js';
+import type { PluginContract } from './types.js';
+export interface Context {
+    engines?: Record<string, string>;
+    dependencies?: Record<string, string>;
+}
+export declare class Plugin {
+    private logger;
+    private configService;
+    private _disabled;
+    private _info;
+    private _contract;
+    readonly main: string;
+    readonly id: string;
+    readonly pluginName: string;
+    readonly displayName: string;
+    readonly scope?: string;
+    readonly isPython: boolean;
+    readonly isESM: boolean;
+    readonly isSymLink: boolean;
+    readonly installPath: string;
+    readonly pythonInstallPath: string;
+    readonly configFile: string;
+    readonly storagePath: string;
+    readonly py: PythonInstaller;
+    readonly config: PluginConfigService;
+    pluginConstructor?: PluginConstructor;
+    private loadContext?;
+    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);
+    load(): Promise<void>;
+    reparsePackageJson(): void;
+    private parsePackageJson;
+    private parseContract;
+}

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

@@ -1,4 +1,4 @@
-import type { Camera } from '../api/database/types';
+import type { Camera } from '../api/database/types.js';
 export interface SchemaConfig {
     rootSchema: PluginRootSchema;
     config: Record<string, any>;
@@ -72,8 +72,8 @@ export interface JsonBaseSchema<T = any> {
 }
 export interface PluginJsonBaseSchema<T = any> extends JsonBaseSchema<T> {
     store?: boolean;
-    onSet?: (newValue: any, oldValue: any) => Promise<void> | void;
-    onGet?: () => any | Promise<any>;
+    onSet?: (newValue: any, oldValue: any) => Promise<void>;
+    onGet?: () => Promise<any>;
 }
 export interface JsonSchemaString extends JsonBaseSchema<string> {
     type: 'string';

package/dist/types/server/src/plugins/worker-ipc.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'node:events';
+import type { ProcessMessage, ProcessResponse } from './types.js';
+export declare interface WorkerIPC {
+    on(event: 'message', listener: (message: ProcessResponse) => void): this;
+}
+export declare class WorkerIPC extends EventEmitter {
+    private publisher?;
+    private subscriber?;
+    private id;
+    private subject;
+    private targetSubject;
+    private auth;
+    constructor(id: string, auth: {
+        user: string;
+        pass: string;
+    });
+    listen(): Promise<void>;
+    close(): Promise<void>;
+    sendMessage(message: ProcessMessage): void;
+    private listenToMessages;
+}

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

@@ -0,0 +1,30 @@
+import { PLUGIN_STATUS } from './types.js';
+import type { Plugin } from './plugin.js';
+export declare class PluginWorker {
+    plugin: Plugin;
+    private pluginWorker?;
+    private proxyServer;
+    private ipc;
+    private api;
+    private logger;
+    private configService;
+    private socketService;
+    private started;
+    private shuttingDown;
+    private _status;
+    get status(): PLUGIN_STATUS;
+    constructor(plugin: Plugin);
+    start(): Promise<void>;
+    teardown(): Promise<void>;
+    restart(): Promise<void>;
+    getPID(): number;
+    isRunning(): boolean;
+    private gatherDevices;
+    private kill;
+    private setStatus;
+    private sendMessage;
+    private handleClose;
+    private reset;
+    private updatePython;
+    private cleanedProcessEnv;
+}

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

@@ -0,0 +1,6 @@
+import type { RTCIceServer } from 'werift';
+import type { Go2RtcConfig, IConfig, IceServer } from './types.js';
+export declare const DEFAULT_ICE_SERVERS: IceServer[];
+export declare const DEFAULT_WERIFT_ICE_SERVERS: RTCIceServer[];
+export declare const DEFAULT_CONFIG: IConfig;
+export declare const DEFAULT_GO2RTC_CONFIG: Go2RtcConfig;

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

@@ -0,0 +1,60 @@
+import 'reflect-metadata';
+import type { Go2RtcConfig, IConfig, Secrets } from './types.js';
+export declare class ConfigService {
+    private logger;
+    private _config;
+    private _go2rtcConfig;
+    CAMERAS_ID: string;
+    DATABASE_ID: string;
+    PLUGINS_ID: string;
+    USER_PLUGINS_ID: string;
+    SETTINGS_ID: string;
+    TOKENS_ID: string;
+    USERS_ID: string;
+    SECRETS: Secrets;
+    static IS_DEV: boolean;
+    static IS_DOCKER: boolean;
+    static IS_ELECTRON: boolean;
+    static IS_HA: boolean;
+    static IS_STANDARD: boolean;
+    static IS_SERVICE: boolean;
+    SERVER_PATH: string;
+    INTERFACE_PATH: string;
+    static VERSION: string;
+    static MIN_NODE_VERSION: string;
+    static NODE_VERSION: string;
+    HOME_PATH: string;
+    STORAGE_PATH: string;
+    DATABASE_PATH: string;
+    USERS_STORAGE_PATH: string;
+    PLUGINS_STORAGE_PATH: string;
+    PLUGINS_INSTALL_PATH: string;
+    PLUGINS_PJSON_FILE: string;
+    LOG_FILE: string;
+    CONFIG_FILE: string;
+    SECRETS_FILE: string;
+    PYTHON_BINARY: string;
+    GO2RTC_BINARY: string;
+    GO2RTC_CONFIG_FILE: string;
+    NATS_BINARY: string;
+    UI_PORT: number;
+    UI_ELECTRON_PORT: number;
+    get config(): IConfig;
+    set config(newConfig: IConfig);
+    get go2rtcConfig(): Go2RtcConfig;
+    set go2rtcConfig(newConfig: Go2RtcConfig);
+    constructor();
+    read(): void;
+    writeConfig(newConfig?: IConfig): void;
+    writeGo2RtcConfigFile(newConfig?: Go2RtcConfig): void;
+    writeGo2RtcConfigApi(newConfig?: Go2RtcConfig): Promise<void>;
+    mergeGo2RtcConfig(): Promise<void>;
+    private defaultConfig;
+    private defaultGo2RtcConfig;
+    private readConfig;
+    private readGo2RtcConfig;
+    private updateConfig;
+    private updateGo2RtcConfig;
+    private updateSecrets;
+    static extractVersion(str: string): string | null;
+}