@camera.ui/browser 0.0.68 → 0.0.70

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

@@ -0,0 +1,96 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Camera } from '../../api/database/types.js';
+import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions, OnSetEvent, PrebufferType, StateValues, StreamInfo } from '../../camera/types.js';
+import type { FrameMetadata, FrameSession } from '../../decoder/types.js';
+import type { IceServer } from '../../services/config/types.js';
+import type { MessageQueue } from '../queue.js';
+import type { CameraDeviceProxyMethods, ProxyMessageStructure } from '../types.js';
+export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
+    private api;
+    private configService;
+    private camerasService;
+    private pluginsService;
+    private socketService;
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
+    connect(data: {
+        cameraId: string;
+        pluginId: string;
+    }): void;
+    disconnect(data: {
+        cameraId: string;
+        pluginId: string;
+    }): void;
+    reboot(data: {
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    getStreamInfo(data: {
+        sourceName: string;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<StreamInfo | undefined>;
+    isPrebuffering(data: {
+        sourceName: string;
+        type: PrebufferType;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<boolean>;
+    getPrebufferRawUrl(data: {
+        sourceName: string;
+        type: PrebufferType;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<string | undefined>;
+    getFrameMetadata(data: {
+        cameraId: string;
+        pluginId: string;
+    }): Promise<FrameMetadata>;
+    getFrameSession(data: {
+        cameraId: string;
+        pluginId: string;
+    }): Promise<FrameSession>;
+    getFfmpegPath(): string;
+    getIceServers(): IceServer[];
+    snapshot(data: {
+        forceNew?: boolean;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<ArrayBuffer>;
+    streamVideo(data: {
+        sourceName: string;
+        options: FfmpegOptions;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    recordToFile(data: {
+        sourceName: string;
+        outputPath: string;
+        duration?: number;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    updateState<T extends keyof StateValues>(data: {
+        stateName: T;
+        eventData: OnSetEvent<T>;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
+    refreshStates(data: {
+        cameraId: string;
+        pluginId: string;
+    }): {
+        camera: Camera;
+        states: StateValues;
+        cameraState: boolean;
+    };
+    onRequestReboot(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['reboot']>): Promise<Buffer>;
+    onRequestGetStreamInfo(pluginId: string, cameraId: string, ...args: Parameters<CameraPrebufferDelegate['getStreamInfo']>): Promise<StreamInfo | undefined>;
+    onRequestIsPrebuffering(pluginId: string, cameraId: string, ...args: Parameters<CameraPrebufferDelegate['isPrebuffering']>): Promise<boolean>;
+    onRequestGetRawUrl(pluginId: string, cameraId: string, ...args: Parameters<CameraPrebufferDelegate['getPrebufferRawUrl']>): Promise<string | undefined>;
+    onRequestSnapshotRequest(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['snapshotRequest']>): Promise<Buffer>;
+    onRequestPrepareStream(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['prepareStream']>): Promise<void>;
+    onRequestWebRTCOffer(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['onOffer']>): Promise<string>;
+    onRequestWebRTCIceCandidates(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['onCandidates']>): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
+}

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

@@ -0,0 +1,31 @@
+import type { Camera } from '../../api/database/types.js';
+import type { CameraConfig } from '../../camera/types.js';
+import type { MessageQueue } from '../queue.js';
+import type { DeviceManagerServerProxyMethods, ProxyMessageStructure } from '../types.js';
+export declare class DeviceManagerProxy implements DeviceManagerServerProxyMethods {
+    private camerasService;
+    private pluginsService;
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
+    getCameraByName(data: {
+        name: string;
+        pluginId: string;
+    }): Camera | undefined;
+    getCameraById(data: {
+        id: string;
+        pluginId: string;
+    }): Camera | void;
+    createCamera(data: {
+        camera: CameraConfig;
+        pluginId: string;
+    }): Promise<Camera>;
+    removeCameraByName(data: {
+        name: string;
+        pluginId: string;
+    }): Promise<void>;
+    removeCameraById(data: {
+        id: string;
+        pluginId: string;
+    }): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
+}

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

@@ -0,0 +1,4 @@
+export { CameraDeviceProxy } from './cameraDevice.js';
+export { DeviceManagerProxy } from './deviceManager.js';
+export { PluginsManagerProxy } from './pluginsManager.js';
+export { SystemManagerProxy } from './systemManager.js';

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

@@ -0,0 +1,12 @@
+import type { BasePlugin } from '../../plugins/base.js';
+import type { CameraStorage } from '../../plugins/node/cameraStorage.js';
+import type { MessageQueue } from '../queue.js';
+import type { CallablePluginMethods, CallablePluginStorageMethods, PluginsManagerServerProxyMethods, ProxyMessageStructure } from '../types.js';
+export declare class PluginsManagerProxy implements PluginsManagerServerProxyMethods {
+    private pluginsService;
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
+    onRequestPluginFn<K extends keyof CallablePluginMethods>(pluginId: string, fn: K, ...args: Parameters<BasePlugin[K]>): Promise<ReturnType<BasePlugin[K]>>;
+    onRequestStorageFn<K extends keyof CallablePluginStorageMethods>(pluginId: string, cameraId: string, fn: K, ...args: Parameters<CameraStorage[K]>): Promise<Awaited<ReturnType<CameraStorage[K]>>>;
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import type { MessageQueue } from '../queue.js';
+import type { ProxyMessageStructure, SystemManagerServerProxyMethods } from '../types.js';
+export declare class SystemManagerProxy implements SystemManagerServerProxyMethods {
+    private pluginsService;
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
+}

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

@@ -0,0 +1,17 @@
+import type { ProxyServer } from './index.js';
+import type { ProxyMessageStructure } from './types.js';
+export declare class MessageQueue {
+    private logger;
+    private proxyServer;
+    private publisher;
+    private subscriber;
+    private aborted;
+    private isProcessing;
+    private queue;
+    private pendingResponses;
+    constructor(proxyServer: ProxyServer);
+    abortQueue(): void;
+    enqueue(message: ProxyMessageStructure): Promise<any>;
+    private processQueue;
+    private listenToMessages;
+}

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

@@ -0,0 +1,33 @@
+import { RUNTIME_STATUS } from '../services/config/types.js';
+import type { ProxyAuth } from './types.js';
+export declare class NatsServer {
+    readonly serverPort = 4222;
+    readonly websocketPort = 8223;
+    private readonly clusterAmount;
+    private readonly serverClusterPort;
+    private readonly auth;
+    private serverProcess?;
+    private clusterProcesses;
+    private logger;
+    private configService;
+    private tmpDir;
+    private manuallyKilled;
+    private shuttingDown;
+    private _status;
+    get status(): RUNTIME_STATUS;
+    constructor(auth: ProxyAuth);
+    start(): Promise<void>;
+    private startServer;
+    private startClusterServer;
+    private setupProcess;
+    stop(): Promise<void>;
+    restart(): Promise<void>;
+    getPID(): number;
+    private writeConfigFile;
+    private stringifyConfig;
+    private kill;
+    private handleClose;
+    private setStatus;
+    private processLogger;
+    private isIgnorableString;
+}

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

@@ -1,10 +1,12 @@
-import type { Camera } from '../api/database/types';
-import type { CameraDevice } from '../camera/base/cameraDevice';
-import type { BrowserCameraDevice } from '../camera/base/cameraDeviceBrowser';
-import type { CameraConfig, FfmpegOptions, OnSetEvent, PrebufferType, StateValues, StreamInfo } from '../camera/types';
-import type { FrameMetadata } from '../decoder/types';
-import type { CameraExtension } from '../plugins/types';
-import type { IceServer } from '../services/config/types';
+import type { Camera } from '../api/database/types.js';
+import type { CameraDevice } from '../camera/base/cameraDevice.js';
+import type { BrowserCameraDevice } from '../camera/base/cameraDeviceBrowser.js';
+import type { CameraConfig, FfmpegOptions, OnSetEvent, PrebufferType, StateValues, StreamInfo } from '../camera/types.js';
+import type { FrameMetadata, FrameSession } from '../decoder/types.js';
+import type { BasePlugin } from '../plugins/base.js';
+import type { CameraStorage } from '../plugins/node/cameraStorage.js';
+import type { CameraExtension } from '../plugins/types.js';
+import type { IceServer } from '../services/config/types.js';
 export type MethodKeys<T> = {
     [K in keyof T]: T[K] extends Function ? K : never;
 }[keyof T];
@@ -60,11 +62,11 @@ export interface DeviceManagerServerProxyMethods {
     getCameraByName(data: {
         name: string;
         pluginId: string;
-    }): Promise<Camera | undefined>;
+    }): Camera | void;
     getCameraById(data: {
         id: string;
         pluginId: string;
-    }): Promise<Camera | undefined>;
+    }): Camera | void;
     removeCameraByName(data: {
         name: string;
         pluginId: string;
@@ -82,11 +84,11 @@ export interface CameraDeviceProxyMethods {
     connect(data: {
         cameraId: string;
         pluginId: string;
-    }): Promise<void>;
+    }): void;
     disconnect(data: {
         cameraId: string;
         pluginId: string;
-    }): Promise<void>;
+    }): void;
     reboot(data: {
         cameraId: string;
         pluginId: string;
@@ -112,6 +114,10 @@ export interface CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): Promise<FrameMetadata>;
+    getFrameSession(data: {
+        cameraId: string;
+        pluginId: string;
+    }): Promise<FrameSession>;
     getFfmpegPath(data: {
         cameraId: string;
         pluginId: string;
@@ -147,11 +153,11 @@ export interface CameraDeviceProxyMethods {
     refreshStates(data: {
         cameraId: string;
         pluginId: string;
-    }): Promise<{
+    }): {
         camera: Camera;
         states: StateValues;
         cameraState: boolean;
-    }>;
+    };
 }
 export type CameraDeviceProxyMethodNames = MethodKeys<CameraDeviceProxyMethods>;
 export interface DeviceManagerListenerMessagePayload {
@@ -235,6 +241,8 @@ export interface PluginsManagerProxyGenericEvent<K extends keyof PluginsManagerP
     type: K;
     data: PluginsManagerProxyEvents[K];
 }
+export type CallablePluginStorageMethods = Pick<CameraStorage, 'getConfig' | 'setConfig'>;
+export type CallablePluginMethods = Pick<BasePlugin, 'onFormSubmit'>;
 export interface CameraDeviceListenerStatePayload<K extends keyof StateValues> {
     stateName: K;
     data: {

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

@@ -0,0 +1,4 @@
+export declare function generateSecureCredentials(): {
+    user: string;
+    pass: string;
+};

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

@@ -0,0 +1,22 @@
+import type { Namespace, Server } from 'socket.io';
+import type { SocketNsp } from '../api/websocket/types.js';
+import { StateValues } from '../camera/types.js';
+import type { CameraDeviceListenerMessagePayload } from './types.js';
+export declare class WebsocketProxy {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private proxy;
+    constructor(io: Server);
+    init(): void;
+    publishCameraEvent<K extends keyof StateValues>(cameraId: string, stateName: K, data: {
+        newEvent: StateValues[K];
+        oldEvent: StateValues[K];
+    }): void;
+    publishCameraEvent(cameraId: string, type: CameraDeviceListenerMessagePayload['type'], data?: any): void;
+    private setupEventListeners;
+    private isSystemManagerMethod;
+    private isDeviceManagerMethod;
+    private isPluginsManagerMethod;
+    private isCameraManagerMethod;
+    private isCameraState;
+}

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

@@ -0,0 +1,7 @@
+import type { CameraDevice } from '../camera/base/cameraDevice.js';
+export declare abstract class BasePlugin {
+    abstract onFormSubmit(actionId: string, payload: any): Promise<{
+        toast?: string;
+    }>;
+    abstract configureCameras(cameras: CameraDevice[]): Promise<void>;
+}

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

@@ -0,0 +1,29 @@
+import 'reflect-metadata';
+import { Plugin } from './plugin.js';
+import { PluginWorker } from './worker.js';
+import type { IPackageJson } from '../api/types/index.js';
+export declare class PluginManager {
+    private logger;
+    private api;
+    private configService;
+    plugins: Map<string, Plugin>;
+    pluginWorkers: Map<string, PluginWorker>;
+    searchPaths: Set<string>;
+    constructor();
+    static isQualifiedPluginIdentifier(pluginName: string): boolean;
+    static extractPluginScope(pluginName: string): string;
+    static extractPluginName(pluginName: string): string;
+    static transformDisplaName(pluginName: string): string;
+    static loadPackageJSON(installPath: string): IPackageJson;
+    initializeInstalledPlugins(): Promise<void>;
+    initializeInstalledPlugin(plugin: Plugin): Promise<void>;
+    loadPlugin(absolutePath: string, pluginId?: string, storagePath?: string): Promise<Plugin>;
+    removePlugin(plugin: Plugin, removeFromDb?: boolean, removeStorage?: boolean): Promise<void>;
+    startPluginChild(pluginName: string): Promise<void>;
+    stopPluginChild(pluginName: string): Promise<void>;
+    initializePlugins(): Promise<void>;
+    private loadInstalledPlugins;
+    private removeOrphanedPlugins;
+    private loadDefaultPaths;
+    private addNpmPrefixToSearchPaths;
+}

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

@@ -0,0 +1,42 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'node:events';
+import { DeviceManager, PluginsManager, SystemManager } from './proxy/index.js';
+import { StorageController } from './storageController.js';
+import type { BasePlugin } from '../base.js';
+import type { Plugin } from '../plugin.js';
+import type { PluginConfigService } from './config.js';
+import type { PluginLogger } from './logger.js';
+export declare interface API {
+    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 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 {
+    private initialized;
+    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, auth: {
+        user: string;
+        pass: string;
+    });
+    init(): Promise<void>;
+}

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

@@ -0,0 +1,108 @@
+import type { PluginJsonSchema, PluginJsonSchemaForm, SchemaConfig } from '../types.js';
+import type { PluginAPI } from './api.js';
+export declare class CameraStorage {
+    private cameraId;
+    private instance;
+    private api;
+    private db;
+    private _schema;
+    private _values;
+    get values(): Record<string, any>;
+    constructor(api: PluginAPI, instance: any, cameraId: string, schema?: PluginJsonSchemaForm);
+    /**
+     * Initialize the storage.
+     * This will load the configuration from the database.
+     */
+    initializeStorage(): Promise<void>;
+    /**
+     * Get a value from the configuration by its key/path.
+     * If the schema has an onGet function, the onGet function will be called.
+     * If the onGet functions is undefined, the value from the configuration will be returned.
+     * If the schema has a default value, and the configuration value is undefined, the default value will be returned.
+     *
+     * @param path - The path to the configuration value.
+     * @returns The value from the configuration.
+     */
+    getValue<T = string>(path: string): Promise<T> | undefined;
+    getValue<T = string>(path: string, defaultValue: T): Promise<T>;
+    /**
+     * 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.
+     * If the schema of the value is declared as storable, the value will be saved to the database.
+     *
+     * @param path - The path to the configuration value.
+     * @param newValue - The new value to set.
+     */
+    setValue<T = string>(path: string, newValue: T): Promise<void>;
+    /**
+     * Check if a value exists by its config path/key.
+     *
+     * @param path - The path to the value to check.
+     * @returns True if the value exists, false otherwise.
+     */
+    hasValue(path: string): boolean;
+    /**
+     * Get the root schema and configuration.
+     * This will also call the onGet functions for the schema.
+     *
+     * @returns The root schema and configuration.
+     */
+    getConfig(): Promise<SchemaConfig>;
+    /**
+     * Set a new configuration.
+     * If the schema of a value which has been changed has an onSet function, the onSet function will be called.
+     *
+     * @param newConfig - The new configuration to set.
+     */
+    setConfig(newConfig: Record<string, any>): Promise<void>;
+    /**
+     * Add a new schema to the existing schema.
+     * It will also add the value to the configuration.
+     * If the schema is declared as storable, the value will be saved to the database.
+     *
+     * @param schema - The new schema to add.
+     * @param path - The path to the schema to add.
+     */
+    addSchema(schema: PluginJsonSchemaForm): Promise<void>;
+    addSchema(path: string, schema: PluginJsonSchema): Promise<void>;
+    /**
+     * Remove a schema by its config path/key from the existing schema.
+     * It will also remove the value from the configuration.
+     * If the schema is declared as storable, the value will be removed from the database.
+     *
+     * @param path - The path to the schema to remove.
+     */
+    removeSchema(path: string): Promise<void>;
+    /**
+     * Change a schema by its config path/key from the existing schema.
+     * It will also change the value from the configuration.
+     * If the schema is declared as storable, the value will be saved to the database.
+     *
+     * @param path - The path to the schema to change.
+     * @param schema - The new schema to set.
+     */
+    changeSchema(path: string, newSchema: Partial<PluginJsonSchema>): Promise<void>;
+    /**
+     * Get a schema by its config path/key.
+     *
+     * @param path - The path to the schema to get.
+     * @returns The schema.
+     */
+    getSchema<T>(path: string): T | undefined;
+    /**
+     * Check if a schema exists by its config path/key.
+     *
+     * @param path - The path to the schema to check.
+     * @returns True if the schema exists, false otherwise.
+     */
+    hasSchema(path: string): boolean;
+    private resolveOnGetFunctions;
+    private resolveOnGetFunctionsForObject;
+    private resolveOnGetFunctionsForSchema;
+    private triggerOnSetForChanges;
+    private filterStorableValues;
+    private containsStorableSchema;
+    private saveDb;
+    private removeDb;
+    private close;
+}

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

@@ -0,0 +1,104 @@
+import { type Path } from 'object-path';
+import type { JSONValue, PluginConfig } from '../types.js';
+export declare class PluginConfigService {
+    private config;
+    private configFile;
+    constructor(configFile: string);
+    /**
+     * Get key (Path) from config.json
+     *
+     * @param key - Key to lookup for
+     * @param defaultValue - Default value if `key` not exist
+     * @param validate - Validate the value of the `key` and replace with `defaultValue` if it is not valid
+     * @param refresh - Re-Read config.json before lookup for the `key`
+     * @param writeIfNotValid - Optional parameter, if true, the changes will be written to the file, if the value of the `key` is not valid and is replaced by the `defaultValue`
+     *
+     * @returns `value` for the given `key` or `defaultValue`
+     */
+    get(key: Path, defaultValue: JSONValue, validate: Function, refresh?: boolean, writeIfNotValid?: boolean): any;
+    get(key: Path, defaultValue?: unknown, validate?: Function, refresh?: boolean, writeIfNotValid?: boolean): any;
+    /**
+     * Test key (Path) existence
+     *
+     * @param key - Key to lookup for
+     * @param refresh - Re-Read config.json before lookup for the `key`
+     */
+    has(key: Path, refresh?: boolean): boolean;
+    /**
+     * Set a value if it doesn't exist, do nothing if it does
+     *
+     * @param key - Key whose existence is to be checked
+     * @param defaultValue - Default value if `key` not exist
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    ensureExists(key: Path, defaultValue: JSONValue, write?: boolean): void;
+    /**
+     * Set a key (Path) to a value
+     *
+     * @param key - Key
+     * @param value - Value to set for they given `key`
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    set(key: Path, value: any, write?: boolean): void;
+    /**
+     * Insert an item in an array path
+     *
+     * @param key - Key to the array
+     * @param value - Value to insert in the array
+     * @param at - Index
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    insert(key: Path, value: any, at?: number, write?: boolean): void;
+    /**
+     * Create (if path isn't an array) and push the value to it. Can push unlimited number of values
+     *
+     * @param key - Key to the array
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     * @param items - Values to push in to the array
+     */
+    push(key: Path, write?: boolean, ...items: any[]): void;
+    /**
+     * Deletes a member from object or array
+     *
+     * @param key - Key to lookup for
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    delete(key: Path, write?: boolean): void;
+    /**
+     * @param refresh - Re-Read config.json
+     *
+     * @returns config.json
+     */
+    all(refresh?: boolean): PluginConfig;
+    /**
+     * @param config - New config.json
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    replace(config: PluginConfig, write?: boolean): void;
+    /**
+     * Updates a specific value in a nested object structure by a given path and key.
+     *
+     * @param path - The path to the nested object.
+     * @param searchKey - The key to search for.
+     * @param searchValue - The value to match the searchKey.
+     * @param targetKey - The key of the value to be updated.
+     * @param newValue - The new value to be set.
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    updateValue(path: string, searchKey: string, searchValue: any, targetKey: string, newValue: any, write?: boolean): void;
+    /**
+     * Replaces a specific item in a nested object structure by a given path and key.
+     * If the item does not exist, it will be added.
+     * If the path does not exist, it will be created.
+     *
+     * @param path - The path to the nested object.
+     * @param searchKey - The key to search for.
+     * @param searchValue - The value to match the searchKey.
+     * @param newItem - The new item to replace the old one. If the item does not exist, it will be added.
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    replaceOrAddItem(path: string, searchKey: string, searchValue: any, newItem: any, write?: boolean): void;
+    private init;
+    private read;
+    private write;
+}

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

@@ -0,0 +1,14 @@
+export declare class PluginLogger {
+    private _prefix;
+    private _loggerPrefix;
+    private _disableTimestamps;
+    private get prefix();
+    constructor(prefix: string, disableTimestamps: boolean);
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    attention(...args: any[]): void;
+    debug(...args: any[]): void;
+    trace(...args: any[]): void;
+    private formatDateTime;
+}