@matterbridge/core 3.7.4-dev-20260414-33cae46 → 3.7.4-dev-20260416-fabcd3f

package/dist/jestutils/jestBroadcastServerSpy.d.ts

@@ -0,0 +1,12 @@
+export declare const closeBroadcastServerSpy: import("jest-mock").SpiedFunction<() => void>;
+export declare const getUniqueIdBroadcastServerSpy: import("jest-mock").SpiedFunction<() => number>;
+export declare const isWorkerRequestBroadcastServerSpy: import("jest-mock").SpiedFunction<(value: unknown) => value is import("@matterbridge/types").WorkerMessageRequest>;
+export declare const isWorkerRequestOfTypeBroadcastServerSpy: import("jest-mock").SpiedFunction<(<K extends keyof import("@matterbridge/types").WorkerMessageTypes>(value: unknown, type: K) => value is import("@matterbridge/types").WorkerMessageRequest<K>)>;
+export declare const isWorkerResponseBroadcastServerSpy: import("jest-mock").SpiedFunction<(value: unknown) => value is import("@matterbridge/types").WorkerMessageResponse>;
+export declare const isWorkerResponseOfTypeBroadcastServerSpy: import("jest-mock").SpiedFunction<(<K extends keyof import("@matterbridge/types").WorkerMessageTypes>(value: unknown, type: K) => value is import("@matterbridge/types").WorkerMessageResponse<K>)>;
+export declare const broadcastBroadcastServerSpy: import("jest-mock").SpiedFunction<(message: import("@matterbridge/types").WorkerMessage) => void>;
+export declare const requestBroadcastServerSpy: import("jest-mock").SpiedFunction<(<K extends keyof import("@matterbridge/types").WorkerMessageTypes>(message: import("@matterbridge/types").WorkerMessageRequest<K>) => void)>;
+export declare const respondBroadcastServerSpy: import("jest-mock").SpiedFunction<(<K extends keyof import("@matterbridge/types").WorkerMessageTypes>(message: import("@matterbridge/types").WorkerMessageResponse<K>) => void)>;
+export declare const fetchBroadcastServerSpy: import("jest-mock").SpiedFunction<(<T extends import("@matterbridge/types").WorkerMessageRequestAny, K extends Extract<keyof import("@matterbridge/types").WorkerMessageTypes, T["type"]>>(message: T, timeout?: number) => Promise<import("@matterbridge/types").WorkerMessageResponseSuccess<K>>)>;
+export declare const broadcastMessageHandlerBroadcastServerSpy: import("jest-mock").SpiedSetter<import("@matterbridge/types").WorkerSrcType> | import("jest-mock").SpiedGetter<import("@matterbridge/types").WorkerSrcType>;
+export declare const broadcastMessageErrorHandlerBroadcastServerSpy: import("jest-mock").SpiedSetter<import("@matterbridge/types").WorkerSrcType> | import("jest-mock").SpiedGetter<import("@matterbridge/types").WorkerSrcType>;

package/dist/jestutils/jestBroadcastServerSpy.js

@@ -0,0 +1,14 @@
+import { jest } from '@jest/globals';
+import { BroadcastServer } from '@matterbridge/thread/server';
+export const closeBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'close');
+export const getUniqueIdBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'getUniqueId');
+export const isWorkerRequestBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'isWorkerRequest');
+export const isWorkerRequestOfTypeBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'isWorkerRequestOfType');
+export const isWorkerResponseBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'isWorkerResponse');
+export const isWorkerResponseOfTypeBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'isWorkerResponseOfType');
+export const broadcastBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'broadcast');
+export const requestBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'request');
+export const respondBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'respond');
+export const fetchBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'fetch');
+export const broadcastMessageHandlerBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'broadcastMessageHandler');
+export const broadcastMessageErrorHandlerBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'broadcastMessageErrorHandler');

package/dist/jestutils/jestDeviceManagerSpy.d.ts

@@ -0,0 +1,13 @@
+export declare const destroyDeviceManagerSpy: import("jest-mock").SpiedFunction<() => void>;
+export declare const lengthDeviceManagerSpy: import("jest-mock").SpiedGetter<number>;
+export declare const sizeDeviceManagerSpy: import("jest-mock").SpiedGetter<number>;
+export declare const hasDeviceManagerSpy: import("jest-mock").SpiedFunction<(uniqueId: string) => boolean>;
+export declare const getDeviceManagerSpy: import("jest-mock").SpiedFunction<(uniqueId: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
+export declare const setDeviceManagerSpy: import("jest-mock").SpiedFunction<(device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint>;
+export declare const removeDeviceManagerSpy: import("jest-mock").SpiedFunction<(device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => boolean>;
+export declare const clearDeviceManagerSpy: import("jest-mock").SpiedFunction<() => void>;
+export declare const arrayDeviceManagerSpy: import("jest-mock").SpiedFunction<() => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint[]>;
+export declare const baseArrayDeviceManagerSpy: import("jest-mock").SpiedFunction<(pluginName?: string) => import("@matterbridge/types").BaseDevice[]>;
+export declare const iteratorDeviceManagerSpy: import("jest-mock").SpiedFunction<() => MapIterator<import("../matterbridgeEndpoint.js").MatterbridgeEndpoint>>;
+export declare const forEachDeviceManagerSpy: import("jest-mock").SpiedFunction<(callback: (device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>) => Promise<void>>;
+export declare const logLevelDeviceManagerSpy: import("jest-mock").SpiedSetter<import("node-ansi-logger").LogLevel>;

package/dist/jestutils/jestDeviceManagerSpy.js

@@ -0,0 +1,15 @@
+import { jest } from '@jest/globals';
+import { DeviceManager } from '../deviceManager.js';
+export const destroyDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'destroy');
+export const lengthDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'length', 'get');
+export const sizeDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'size', 'get');
+export const hasDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'has');
+export const getDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'get');
+export const setDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'set');
+export const removeDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'remove');
+export const clearDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'clear');
+export const arrayDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'array');
+export const baseArrayDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'baseArray');
+export const iteratorDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, Symbol.iterator);
+export const forEachDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'forEach');
+export const logLevelDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'logLevel', 'set');

package/dist/jestutils/jestFrontendSpy.d.ts

@@ -0,0 +1,9 @@
+export declare const wssSendSnackbarMessageFrontendSpy: import("jest-mock").SpiedFunction<(message: string, timeout?: number, severity?: "info" | "warning" | "error" | "success") => void>;
+export declare const wssSendCloseSnackbarMessageFrontendSpy: import("jest-mock").SpiedFunction<(message: string) => void>;
+export declare const wssSendUpdateRequiredFrontendSpy: import("jest-mock").SpiedFunction<(devVersion?: boolean) => void>;
+export declare const wssSendRefreshRequiredFrontendSpy: import("jest-mock").SpiedFunction<(changed: import("@matterbridge/types").RefreshRequiredChanged, params?: {
+    matter?: import("@matterbridge/types").ApiMatter;
+    lock?: string;
+}) => void>;
+export declare const wssSendRestartRequiredFrontendSpy: import("jest-mock").SpiedFunction<(snackbar?: boolean, fixed?: boolean) => void>;
+export declare const wssSendRestartNotRequiredFrontendSpy: import("jest-mock").SpiedFunction<(snackbar?: boolean) => void>;

package/dist/jestutils/jestFrontendSpy.js

@@ -0,0 +1,8 @@
+import { jest } from '@jest/globals';
+import { Frontend } from '../frontend.js';
+export const wssSendSnackbarMessageFrontendSpy = jest.spyOn(Frontend.prototype, 'wssSendSnackbarMessage');
+export const wssSendCloseSnackbarMessageFrontendSpy = jest.spyOn(Frontend.prototype, 'wssSendCloseSnackbarMessage');
+export const wssSendUpdateRequiredFrontendSpy = jest.spyOn(Frontend.prototype, 'wssSendUpdateRequired');
+export const wssSendRefreshRequiredFrontendSpy = jest.spyOn(Frontend.prototype, 'wssSendRefreshRequired');
+export const wssSendRestartRequiredFrontendSpy = jest.spyOn(Frontend.prototype, 'wssSendRestartRequired');
+export const wssSendRestartNotRequiredFrontendSpy = jest.spyOn(Frontend.prototype, 'wssSendRestartNotRequired');

package/dist/jestutils/jestHelpers.d.ts

@@ -5,14 +5,12 @@ import { AggregatorEndpoint } from '@matter/node/endpoints';
 import { ColorControl } from '@matter/types/clusters/color-control';
 import { LevelControl } from '@matter/types/clusters/level-control';
 import { DeviceTypeId } from '@matter/types/datatype';
-import { BroadcastServer } from '@matterbridge/thread/server';
 import { AnsiLogger } from 'node-ansi-logger';
-import { DeviceManager } from '../deviceManager.js';
-import { Frontend } from '../frontend.js';
+import type { DeviceManager } from '../deviceManager.js';
+import type { Frontend } from '../frontend.js';
 import { Matterbridge } from '../matterbridge.js';
-import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-import { MatterbridgePlatform } from '../matterbridgePlatform.js';
-import { PluginManager } from '../pluginManager.js';
+import type { MatterbridgePlatform } from '../matterbridgePlatform.js';
+import type { PluginManager } from '../pluginManager.js';
 export declare const originalProcessArgv: readonly string[];
 export declare const originalProcessEnv: Readonly<Record<string, string | undefined>>;
 export declare let loggerLogSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.log>;
@@ -27,37 +25,6 @@ export declare let consoleDebugSpy: jest.SpiedFunction<typeof console.debug>;
 export declare let consoleInfoSpy: jest.SpiedFunction<typeof console.info>;
 export declare let consoleWarnSpy: jest.SpiedFunction<typeof console.warn>;
 export declare let consoleErrorSpy: jest.SpiedFunction<typeof console.error>;
-export declare let addBridgedEndpointSpy: jest.SpiedFunction<typeof Matterbridge.prototype.addBridgedEndpoint>;
-export declare let removeBridgedEndpointSpy: jest.SpiedFunction<typeof Matterbridge.prototype.removeBridgedEndpoint>;
-export declare let removeAllBridgedEndpointsSpy: jest.SpiedFunction<typeof Matterbridge.prototype.removeAllBridgedEndpoints>;
-export declare let addVirtualEndpointSpy: jest.SpiedFunction<typeof Matterbridge.prototype.addVirtualEndpoint>;
-export declare let setAttributeSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.setAttribute>;
-export declare let updateAttributeSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.updateAttribute>;
-export declare let triggerEventSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.triggerEvent>;
-export declare let triggerSwitchEventSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.triggerSwitchEvent>;
-export declare let installPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.install>;
-export declare let uninstallPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.uninstall>;
-export declare let addPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.add>;
-export declare let loadPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.load>;
-export declare let startPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.start>;
-export declare let configurePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.configure>;
-export declare let shutdownPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.shutdown>;
-export declare let removePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.remove>;
-export declare let enablePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.enable>;
-export declare let disablePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.disable>;
-export declare let wssSendSnackbarMessageSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendSnackbarMessage>;
-export declare let wssSendCloseSnackbarMessageSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendCloseSnackbarMessage>;
-export declare let wssSendUpdateRequiredSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendUpdateRequired>;
-export declare let wssSendRefreshRequiredSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendRefreshRequired>;
-export declare let wssSendRestartRequiredSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendRestartRequired>;
-export declare let wssSendRestartNotRequiredSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendRestartNotRequired>;
-export declare let broadcastServerIsWorkerRequestSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.isWorkerRequest>;
-export declare let broadcastServerIsWorkerResponseSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.isWorkerResponse>;
-export declare let broadcastServerBroadcastSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.broadcast>;
-export declare let broadcastServerRequestSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.request>;
-export declare let broadcastServerRespondSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.respond>;
-export declare let broadcastServerFetchSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.fetch>;
-export declare let broadcastMessageHandlerSpy: jest.SpiedFunction<(this: BroadcastServer, event: MessageEvent) => void>;
 export declare let NAME: string;
 export declare let HOMEDIR: string;
 export declare let matterbridge: Matterbridge;
@@ -86,8 +53,9 @@ export declare function logKeepAlives(log?: AnsiLogger): number;
 export declare function flushAllEndpointNumberPersistence(targetServer: ServerNode, rounds?: number, pause?: number): Promise<void>;
 export declare function assertAllEndpointNumbersPersisted(targetServer: ServerNode): Promise<number>;
 export declare function closeServerNodeStores(targetServer?: ServerNode): Promise<void>;
-export declare function startServerNode(name: string, port: number, deviceType?: DeviceTypeId, createOnly?: boolean): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
-export declare function stopServerNode(server: ServerNode<ServerNode.RootEndpoint>, createOnly?: boolean): Promise<void>;
+export declare function createServerNode(name: string, port: number, deviceType?: DeviceTypeId, ticks?: number, microTurns?: number, pause?: number): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
+export declare function startServerNode(name: string, port: number, deviceType?: DeviceTypeId, createOnly?: boolean, ticks?: number, microTurns?: number, pause?: number): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
+export declare function stopServerNode(server: ServerNode<ServerNode.RootEndpoint>, createOnly?: boolean, ticks?: number, microTurns?: number, pause?: number): Promise<void>;
 export declare function addDevice(owner: ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>, device: Endpoint, pause?: number): Promise<boolean>;
 export declare function deleteDevice(owner: ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>, device: Endpoint, pause?: number): Promise<boolean>;
 export declare function getMoveToLevelRequest(level: number, transitionTime: number, executeIfOff: boolean): LevelControl.MoveToLevelRequest;

package/dist/jestutils/jestHelpers.js

@@ -7,15 +7,11 @@ import { AggregatorEndpoint } from '@matter/node/endpoints';
 import { MdnsService } from '@matter/protocol';
 import { ColorControl } from '@matter/types/clusters/color-control';
 import { DeviceTypeId, VendorId } from '@matter/types/datatype';
-import { BroadcastServer } from '@matterbridge/thread/server';
 import { MATTER_STORAGE_DIR, NODE_STORAGE_DIR } from '@matterbridge/types';
 import { AnsiLogger, er, rs, UNDERLINE, UNDERLINEOFF } from 'node-ansi-logger';
 import { NodeStorageManager } from 'node-persist-manager';
-import { Frontend } from '../frontend.js';
 import { Matterbridge } from '../matterbridge.js';
 import { bridge } from '../matterbridgeDeviceTypes.js';
-import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-import { PluginManager } from '../pluginManager.js';
 export const originalProcessArgv = Object.freeze([...process.argv]);
 export const originalProcessEnv = Object.freeze({ ...process.env });
 export let loggerLogSpy;
@@ -30,37 +26,6 @@ export let consoleDebugSpy;
 export let consoleInfoSpy;
 export let consoleWarnSpy;
 export let consoleErrorSpy;
-export let addBridgedEndpointSpy;
-export let removeBridgedEndpointSpy;
-export let removeAllBridgedEndpointsSpy;
-export let addVirtualEndpointSpy;
-export let setAttributeSpy;
-export let updateAttributeSpy;
-export let triggerEventSpy;
-export let triggerSwitchEventSpy;
-export let installPluginSpy;
-export let uninstallPluginSpy;
-export let addPluginSpy;
-export let loadPluginSpy;
-export let startPluginSpy;
-export let configurePluginSpy;
-export let shutdownPluginSpy;
-export let removePluginSpy;
-export let enablePluginSpy;
-export let disablePluginSpy;
-export let wssSendSnackbarMessageSpy;
-export let wssSendCloseSnackbarMessageSpy;
-export let wssSendUpdateRequiredSpy;
-export let wssSendRefreshRequiredSpy;
-export let wssSendRestartRequiredSpy;
-export let wssSendRestartNotRequiredSpy;
-export let broadcastServerIsWorkerRequestSpy;
-export let broadcastServerIsWorkerResponseSpy;
-export let broadcastServerBroadcastSpy;
-export let broadcastServerRequestSpy;
-export let broadcastServerRespondSpy;
-export let broadcastServerFetchSpy;
-export let broadcastMessageHandlerSpy;
 export let NAME;
 export let HOMEDIR;
 export let matterbridge;
@@ -101,37 +66,6 @@ export async function setupTest(name, debug = false) {
         consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
         consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
     }
-    addBridgedEndpointSpy = jest.spyOn(Matterbridge.prototype, 'addBridgedEndpoint');
-    removeBridgedEndpointSpy = jest.spyOn(Matterbridge.prototype, 'removeBridgedEndpoint');
-    removeAllBridgedEndpointsSpy = jest.spyOn(Matterbridge.prototype, 'removeAllBridgedEndpoints');
-    addVirtualEndpointSpy = jest.spyOn(Matterbridge.prototype, 'addVirtualEndpoint');
-    setAttributeSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'setAttribute');
-    updateAttributeSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'updateAttribute');
-    triggerEventSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'triggerEvent');
-    triggerSwitchEventSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'triggerSwitchEvent');
-    installPluginSpy = jest.spyOn(PluginManager.prototype, 'install');
-    uninstallPluginSpy = jest.spyOn(PluginManager.prototype, 'uninstall');
-    addPluginSpy = jest.spyOn(PluginManager.prototype, 'add');
-    loadPluginSpy = jest.spyOn(PluginManager.prototype, 'load');
-    startPluginSpy = jest.spyOn(PluginManager.prototype, 'start');
-    configurePluginSpy = jest.spyOn(PluginManager.prototype, 'configure');
-    shutdownPluginSpy = jest.spyOn(PluginManager.prototype, 'shutdown');
-    removePluginSpy = jest.spyOn(PluginManager.prototype, 'remove');
-    enablePluginSpy = jest.spyOn(PluginManager.prototype, 'enable');
-    disablePluginSpy = jest.spyOn(PluginManager.prototype, 'disable');
-    wssSendSnackbarMessageSpy = jest.spyOn(Frontend.prototype, 'wssSendSnackbarMessage');
-    wssSendCloseSnackbarMessageSpy = jest.spyOn(Frontend.prototype, 'wssSendCloseSnackbarMessage');
-    wssSendUpdateRequiredSpy = jest.spyOn(Frontend.prototype, 'wssSendUpdateRequired');
-    wssSendRefreshRequiredSpy = jest.spyOn(Frontend.prototype, 'wssSendRefreshRequired');
-    wssSendRestartRequiredSpy = jest.spyOn(Frontend.prototype, 'wssSendRestartRequired');
-    wssSendRestartNotRequiredSpy = jest.spyOn(Frontend.prototype, 'wssSendRestartNotRequired');
-    broadcastServerIsWorkerRequestSpy = jest.spyOn(BroadcastServer.prototype, 'isWorkerRequest');
-    broadcastServerIsWorkerResponseSpy = jest.spyOn(BroadcastServer.prototype, 'isWorkerResponse');
-    broadcastServerBroadcastSpy = jest.spyOn(BroadcastServer.prototype, 'broadcast');
-    broadcastServerRequestSpy = jest.spyOn(BroadcastServer.prototype, 'request');
-    broadcastServerRespondSpy = jest.spyOn(BroadcastServer.prototype, 'respond');
-    broadcastServerFetchSpy = jest.spyOn(BroadcastServer.prototype, 'fetch');
-    broadcastMessageHandlerSpy = jest.spyOn(BroadcastServer.prototype, 'broadcastMessageHandler');
 }
 export async function setDebug(debug) {
     const { jest } = await import('@jest/globals');
@@ -489,7 +423,7 @@ export async function closeServerNodeStores(targetServer) {
         targetServer = server;
     await targetServer?.env.get(ServerNodeStore)?.endpointStores.close();
 }
-export async function startServerNode(name, port, deviceType = bridge.code, createOnly = false) {
+export async function createServerNode(name, port, deviceType = bridge.code, ticks = 3, microTurns = 10, pause = 100) {
     const { randomBytes } = await import('node:crypto');
     const random = randomBytes(8).toString('hex');
     server = await ServerNode.create({
@@ -533,8 +467,14 @@ export async function startServerNode(name, port, deviceType = bridge.code, crea
     expect(server.parts.has(aggregator)).toBeTruthy();
     expect(aggregator.lifecycle.isReady).toBeTruthy();
     expect(server.lifecycle.isOnline).toBeFalsy();
+    await flushAsync(ticks, microTurns, pause);
+    return [server, aggregator];
+}
+export async function startServerNode(name, port, deviceType = bridge.code, createOnly = false, ticks = 3, microTurns = 10, pause = 100) {
+    if (!server || !aggregator) {
+        await createServerNode(name, port, deviceType);
+    }
     if (createOnly) {
-        await flushAsync(3, 3, 100);
         return [server, aggregator];
     }
     await new Promise((resolve) => {
@@ -554,10 +494,10 @@ export async function startServerNode(name, port, deviceType = bridge.code, crea
     expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
     expect(aggregator.lifecycle.hasId).toBeTruthy();
     expect(aggregator.lifecycle.hasNumber).toBeTruthy();
-    await flushAsync(3, 3, 100);
+    await flushAsync(ticks, microTurns, pause);
     return [server, aggregator];
 }
-export async function stopServerNode(server, createOnly = false) {
+export async function stopServerNode(server, createOnly = false, ticks = 3, microTurns = 10, pause = 100) {
     await flushAllEndpointNumberPersistence(server);
     await assertAllEndpointNumbersPersisted(server);
     expect(server).toBeDefined();
@@ -568,7 +508,7 @@ export async function stopServerNode(server, createOnly = false) {
     await server.close();
     expect(server.lifecycle.isReady).toBeFalsy();
     expect(server.lifecycle.isOnline).toBeFalsy();
-    await flushAsync(3, 3, 100);
+    await flushAsync(ticks, microTurns, pause);
 }
 export async function addDevice(owner, device, pause = 10) {
     expect(owner).toBeDefined();

package/dist/jestutils/jestMatterbridgeEndpointSpy.d.ts

@@ -0,0 +1,6 @@
+import { jest } from '@jest/globals';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare let setAttributeMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.setAttribute>;
+export declare let updateAttributeMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.updateAttribute>;
+export declare let triggerEventMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.triggerEvent>;
+export declare let triggerSwitchEventMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.triggerSwitchEvent>;

package/dist/jestutils/jestMatterbridgeEndpointSpy.js

@@ -0,0 +1,4 @@
+export let setAttributeMatterbridgeEndpointSpy;
+export let updateAttributeMatterbridgeEndpointSpy;
+export let triggerEventMatterbridgeEndpointSpy;
+export let triggerSwitchEventMatterbridgeEndpointSpy;

package/dist/jestutils/jestMatterbridgePlatformSpy.d.ts

@@ -0,0 +1,60 @@
+export declare const destroyMatterbridgePlatformSpy: import("jest-mock").SpiedSetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage> | import("jest-mock").SpiedGetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage>;
+export declare const onStartMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(reason?: string) => Promise<void>>;
+export declare const onConfigureMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => Promise<void>>;
+export declare const onShutdownMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(reason?: string) => Promise<void>>;
+export declare const onChangeLoggerLevelMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(logLevel: import("node-ansi-logger").LogLevel) => Promise<void>>;
+export declare const onActionMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(action: string, value?: string, id?: string, formData?: import("../matterbridgePlatform.js").PlatformConfig) => Promise<void>>;
+export declare const onConfigChangedMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(config: import("../matterbridgePlatform.js").PlatformConfig) => Promise<void>>;
+export declare const saveConfigMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(config: import("../matterbridgePlatform.js").PlatformConfig) => void>;
+export declare const getSchemaMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => Promise<import("../matterbridgePlatform.js").PlatformSchema | undefined>>;
+export declare const setSchemaMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(schema: import("../matterbridgePlatform.js").PlatformSchema) => void>;
+export declare const wssSendRestartRequiredMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(snackbar?: boolean, fixed?: boolean) => void>;
+export declare const wssSendSnackbarMessageMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(message: string, timeout?: number, severity?: "error" | "success" | "info" | "warning") => void>;
+export declare const sizeMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => number>;
+export declare const getDevicesMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint[]>;
+export declare const getDeviceByNameMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(deviceName: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
+export declare const getDeviceByUniqueIdMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(uniqueId: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
+export declare const getDeviceBySerialNumberMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serialNumber: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
+export declare const getDeviceByIdMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(id: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
+export declare const getDeviceByOriginalIdMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(originalId: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
+export declare const getDeviceByNumberMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(number: import("@matter/types").EndpointNumber | number) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
+export declare const hasDeviceNameMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(deviceName: string) => boolean>;
+export declare const hasDeviceUniqueIdMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(deviceUniqueId: string) => boolean>;
+export declare const registerVirtualDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(name: string, type: "light" | "outlet" | "switch" | "mounted_switch", callback: () => Promise<void>) => Promise<boolean>>;
+export declare const registerDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>>;
+export declare const unregisterDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>>;
+export declare const unregisterAllDevicesMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(delay?: number) => Promise<void>>;
+export declare const saveSelectsMatterbridgePlatformSpy: import("jest-mock").SpiedSetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage> | import("jest-mock").SpiedGetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage>;
+export declare const clearSelectMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => Promise<void>>;
+export declare const clearDeviceSelectMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serial: string) => Promise<void>>;
+export declare const clearEntitySelectMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(name: string) => Promise<void>>;
+export declare const setSelectDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serial: string, name: string, configUrl?: string, icon?: string, entities?: {
+    name: string;
+    description: string;
+    icon?: string;
+}[]) => void>;
+export declare const getSelectDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serial: string) => {
+    serial: string;
+    name: string;
+    configUrl?: string;
+    icon?: string;
+    entities?: {
+        name: string;
+        description: string;
+        icon?: string;
+    }[];
+} | undefined>;
+export declare const setSelectDeviceEntityMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serial: string, entityName: string, entityDescription: string, entityIcon?: string) => void>;
+export declare const getSelectDevicesMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => import("@matterbridge/types").ApiSelectDevice[]>;
+export declare const setSelectEntityMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(name: string, description: string, icon?: string) => void>;
+export declare const getSelectEntityMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(name: string) => {
+    name: string;
+    description: string;
+    icon?: string | undefined;
+} | undefined>;
+export declare const getSelectEntitiesMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => import("@matterbridge/types").ApiSelectEntity[]>;
+export declare const verifyMatterbridgeVersionMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(requiredVersion: string, destroy?: boolean) => boolean>;
+export declare const validateDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(device: string | string[], log?: boolean) => boolean>;
+export declare const validateEntityMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(device: string, entity: string, log?: boolean) => boolean>;
+export declare const clearEndpointNumbersMatterbridgePlatformSpy: import("jest-mock").SpiedSetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage> | import("jest-mock").SpiedGetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage>;
+export declare const checkEndpointNumbersMatterbridgePlatformSpy: import("jest-mock").SpiedSetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage> | import("jest-mock").SpiedGetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage>;

package/dist/jestutils/jestMatterbridgePlatformSpy.js

@@ -0,0 +1,44 @@
+import { jest } from '@jest/globals';
+import { MatterbridgePlatform } from '../matterbridgePlatform.js';
+export const destroyMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'destroy');
+export const onStartMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onStart');
+export const onConfigureMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onConfigure');
+export const onShutdownMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onShutdown');
+export const onChangeLoggerLevelMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onChangeLoggerLevel');
+export const onActionMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onAction');
+export const onConfigChangedMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onConfigChanged');
+export const saveConfigMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'saveConfig');
+export const getSchemaMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getSchema');
+export const setSchemaMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'setSchema');
+export const wssSendRestartRequiredMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'wssSendRestartRequired');
+export const wssSendSnackbarMessageMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'wssSendSnackbarMessage');
+export const sizeMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'size');
+export const getDevicesMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDevices');
+export const getDeviceByNameMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDeviceByName');
+export const getDeviceByUniqueIdMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDeviceByUniqueId');
+export const getDeviceBySerialNumberMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDeviceBySerialNumber');
+export const getDeviceByIdMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDeviceById');
+export const getDeviceByOriginalIdMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDeviceByOriginalId');
+export const getDeviceByNumberMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDeviceByNumber');
+export const hasDeviceNameMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'hasDeviceName');
+export const hasDeviceUniqueIdMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'hasDeviceUniqueId');
+export const registerVirtualDeviceMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'registerVirtualDevice');
+export const registerDeviceMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'registerDevice');
+export const unregisterDeviceMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'unregisterDevice');
+export const unregisterAllDevicesMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'unregisterAllDevices');
+export const saveSelectsMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'saveSelects');
+export const clearSelectMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'clearSelect');
+export const clearDeviceSelectMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'clearDeviceSelect');
+export const clearEntitySelectMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'clearEntitySelect');
+export const setSelectDeviceMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'setSelectDevice');
+export const getSelectDeviceMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getSelectDevice');
+export const setSelectDeviceEntityMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'setSelectDeviceEntity');
+export const getSelectDevicesMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getSelectDevices');
+export const setSelectEntityMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'setSelectEntity');
+export const getSelectEntityMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getSelectEntity');
+export const getSelectEntitiesMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getSelectEntities');
+export const verifyMatterbridgeVersionMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'verifyMatterbridgeVersion');
+export const validateDeviceMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'validateDevice');
+export const validateEntityMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'validateEntity');
+export const clearEndpointNumbersMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'clearEndpointNumbers');
+export const checkEndpointNumbersMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'checkEndpointNumbers');

package/dist/jestutils/jestMatterbridgeSpy.d.ts

@@ -0,0 +1,4 @@
+export declare const addBridgedEndpointMatterbridgeSpy: import("jest-mock").SpiedFunction<(pluginName: string, device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>>;
+export declare const removeBridgedEndpointMatterbridgeSpy: import("jest-mock").SpiedFunction<(pluginName: string, device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>>;
+export declare const removeAllBridgedEndpointsMatterbridgeSpy: import("jest-mock").SpiedFunction<(pluginName: string, delay?: number) => Promise<void>>;
+export declare const addVirtualEndpointMatterbridgeSpy: import("jest-mock").SpiedFunction<(pluginName: string, name: string, type: "light" | "outlet" | "switch" | "mounted_switch", callback: () => Promise<void>) => Promise<boolean>>;

package/dist/jestutils/jestMatterbridgeSpy.js

@@ -0,0 +1,6 @@
+import { jest } from '@jest/globals';
+import { Matterbridge } from '../matterbridge.js';
+export const addBridgedEndpointMatterbridgeSpy = jest.spyOn(Matterbridge.prototype, 'addBridgedEndpoint');
+export const removeBridgedEndpointMatterbridgeSpy = jest.spyOn(Matterbridge.prototype, 'removeBridgedEndpoint');
+export const removeAllBridgedEndpointsMatterbridgeSpy = jest.spyOn(Matterbridge.prototype, 'removeAllBridgedEndpoints');
+export const addVirtualEndpointMatterbridgeSpy = jest.spyOn(Matterbridge.prototype, 'addVirtualEndpoint');

package/dist/jestutils/jestPluginManagerSpy.d.ts

@@ -0,0 +1,47 @@
+export declare const destroyPluginSpy: import("jest-mock").SpiedFunction<() => void>;
+export declare const checkDependenciesPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, unknown> & {
+    name?: string;
+    dependencies?: string[] | Record<string, string>;
+    devDependencies?: string[] | Record<string, string>;
+    peerDependencies?: string[] | Record<string, string>;
+    optionalDependencies?: string[] | Record<string, string>;
+    bundledDependencies?: string[] | Record<string, string>;
+    bundleDependencies?: string[] | Record<string, string>;
+}) => boolean>;
+export declare const lengthPluginSpy: import("jest-mock").SpiedGetter<number>;
+export declare const sizePluginSpy: import("jest-mock").SpiedGetter<number>;
+export declare const hasPluginSpy: import("jest-mock").SpiedFunction<(name: string) => boolean>;
+export declare const getPluginSpy: import("jest-mock").SpiedFunction<(name: string) => import("../pluginManager.js").Plugin | undefined>;
+export declare const setPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin) => import("../pluginManager.js").Plugin>;
+export declare const clearPluginSpy: import("jest-mock").SpiedFunction<() => void>;
+export declare const arrayPluginSpy: import("jest-mock").SpiedFunction<() => import("../pluginManager.js").Plugin[]>;
+export declare const storagePluginArraySpy: import("jest-mock").SpiedFunction<() => import("@matterbridge/types").StoragePlugin[]>;
+export declare const apiPluginArraySpy: import("jest-mock").SpiedFunction<() => import("@matterbridge/types").ApiPlugin[]>;
+export declare const iteratorPluginSpy: import("jest-mock").SpiedFunction<() => MapIterator<import("../pluginManager.js").Plugin>>;
+export declare const forEachPluginSpy: import("jest-mock").SpiedFunction<(callback: (plugin: import("../pluginManager.js").Plugin) => Promise<void>) => Promise<void>>;
+export declare const logLevelPluginSpy: import("jest-mock").SpiedSetter<import("node-ansi-logger").LogLevel>;
+export declare const loadFromStoragePluginSpy: import("jest-mock").SpiedFunction<() => Promise<import("@matterbridge/types").StoragePlugin[]>>;
+export declare const saveToStoragePluginSpy: import("jest-mock").SpiedFunction<() => Promise<number>>;
+export declare const resolvePluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<string | null>>;
+export declare const installPluginSpy: import("jest-mock").SpiedFunction<(packageName: string) => void>;
+export declare const uninstallPluginSpy: import("jest-mock").SpiedFunction<(packageName: string) => void>;
+export declare const getAuthorPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string>;
+export declare const getDescriptionPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string>;
+export declare const getHomepagePluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string | undefined>;
+export declare const getHelpPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string | undefined>;
+export declare const getChangelogPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string | undefined>;
+export declare const getFundingPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, any>) => string | undefined>;
+export declare const parsePluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName) => Promise<Record<string, string | number | object> | null>>;
+export declare const addPluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<import("../pluginManager.js").Plugin | null>>;
+export declare const enablePluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<import("../pluginManager.js").Plugin | null>>;
+export declare const disablePluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<import("../pluginManager.js").Plugin | null>>;
+export declare const removePluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<import("../pluginManager.js").Plugin | null>>;
+export declare const loadPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName, start?: boolean, message?: string, configure?: boolean) => Promise<import("../matterbridgePlatform.js").MatterbridgePlatform | undefined>>;
+export declare const startPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName, message?: string, configure?: boolean) => Promise<import("../pluginManager.js").Plugin | undefined>>;
+export declare const configurePluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName) => Promise<import("../pluginManager.js").Plugin | undefined>>;
+export declare const shutdownPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName, reason?: string, removeAllDevices?: boolean, force?: boolean) => Promise<import("../pluginManager.js").Plugin | undefined>>;
+export declare const loadConfigPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin) => Promise<import("@matterbridge/types").PlatformConfig>>;
+export declare const saveConfigFromPluginPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin, restartRequired?: boolean) => Promise<void>>;
+export declare const saveConfigFromJsonPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin, config: import("@matterbridge/types").PlatformConfig, restartRequired?: boolean) => Promise<void>>;
+export declare const loadSchemaPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin) => Promise<import("@matterbridge/types").PlatformSchema>>;
+export declare const getDefaultSchemaPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin) => import("@matterbridge/types").PlatformSchema>;

package/dist/jestutils/jestPluginManagerSpy.js

@@ -0,0 +1,41 @@
+import { jest } from '@jest/globals';
+import { PluginManager } from '../pluginManager.js';
+export const destroyPluginSpy = jest.spyOn(PluginManager.prototype, 'destroy');
+export const checkDependenciesPluginSpy = jest.spyOn(PluginManager.prototype, 'checkDependencies');
+export const lengthPluginSpy = jest.spyOn(PluginManager.prototype, 'length', 'get');
+export const sizePluginSpy = jest.spyOn(PluginManager.prototype, 'size', 'get');
+export const hasPluginSpy = jest.spyOn(PluginManager.prototype, 'has');
+export const getPluginSpy = jest.spyOn(PluginManager.prototype, 'get');
+export const setPluginSpy = jest.spyOn(PluginManager.prototype, 'set');
+export const clearPluginSpy = jest.spyOn(PluginManager.prototype, 'clear');
+export const arrayPluginSpy = jest.spyOn(PluginManager.prototype, 'array');
+export const storagePluginArraySpy = jest.spyOn(PluginManager.prototype, 'storagePluginArray');
+export const apiPluginArraySpy = jest.spyOn(PluginManager.prototype, 'apiPluginArray');
+export const iteratorPluginSpy = jest.spyOn(PluginManager.prototype, Symbol.iterator);
+export const forEachPluginSpy = jest.spyOn(PluginManager.prototype, 'forEach');
+export const logLevelPluginSpy = jest.spyOn(PluginManager.prototype, 'logLevel', 'set');
+export const loadFromStoragePluginSpy = jest.spyOn(PluginManager.prototype, 'loadFromStorage');
+export const saveToStoragePluginSpy = jest.spyOn(PluginManager.prototype, 'saveToStorage');
+export const resolvePluginSpy = jest.spyOn(PluginManager.prototype, 'resolve');
+export const installPluginSpy = jest.spyOn(PluginManager.prototype, 'install');
+export const uninstallPluginSpy = jest.spyOn(PluginManager.prototype, 'uninstall');
+export const getAuthorPluginSpy = jest.spyOn(PluginManager.prototype, 'getAuthor');
+export const getDescriptionPluginSpy = jest.spyOn(PluginManager.prototype, 'getDescription');
+export const getHomepagePluginSpy = jest.spyOn(PluginManager.prototype, 'getHomepage');
+export const getHelpPluginSpy = jest.spyOn(PluginManager.prototype, 'getHelp');
+export const getChangelogPluginSpy = jest.spyOn(PluginManager.prototype, 'getChangelog');
+export const getFundingPluginSpy = jest.spyOn(PluginManager.prototype, 'getFunding');
+export const parsePluginSpy = jest.spyOn(PluginManager.prototype, 'parse');
+export const addPluginSpy = jest.spyOn(PluginManager.prototype, 'add');
+export const enablePluginSpy = jest.spyOn(PluginManager.prototype, 'enable');
+export const disablePluginSpy = jest.spyOn(PluginManager.prototype, 'disable');
+export const removePluginSpy = jest.spyOn(PluginManager.prototype, 'remove');
+export const loadPluginSpy = jest.spyOn(PluginManager.prototype, 'load');
+export const startPluginSpy = jest.spyOn(PluginManager.prototype, 'start');
+export const configurePluginSpy = jest.spyOn(PluginManager.prototype, 'configure');
+export const shutdownPluginSpy = jest.spyOn(PluginManager.prototype, 'shutdown');
+export const loadConfigPluginSpy = jest.spyOn(PluginManager.prototype, 'loadConfig');
+export const saveConfigFromPluginPluginSpy = jest.spyOn(PluginManager.prototype, 'saveConfigFromPlugin');
+export const saveConfigFromJsonPluginSpy = jest.spyOn(PluginManager.prototype, 'saveConfigFromJson');
+export const loadSchemaPluginSpy = jest.spyOn(PluginManager.prototype, 'loadSchema');
+export const getDefaultSchemaPluginSpy = jest.spyOn(PluginManager.prototype, 'getDefaultSchema');

package/dist/matterbridge.js

@@ -13,6 +13,7 @@ import { BasicInformationClient, BasicInformationServer } from '@matter/node/beh
 import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
 import { PaseClient, Read, Subscribe } from '@matter/protocol';
 import { DeviceTypeId, VendorId } from '@matter/types/datatype';
+import { ManualPairingCodeCodec } from '@matter/types/schema';
 import { BroadcastServer } from '@matterbridge/thread/server';
 import { dev, MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, typ } from '@matterbridge/types';
 import { wait } from '@matterbridge/utils';
@@ -27,7 +28,6 @@ import { NodeStorageManager } from 'node-persist-manager';
 import { DeviceManager } from './deviceManager.js';
 import { Frontend } from './frontend.js';
 import { addVirtualDevice, addVirtualDevices } from './helpers.js';
-import { ManualPairingCodeCodec } from './matter/types.js';
 import { bridge } from './matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { PluginManager } from './pluginManager.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.7.4-dev-20260414-33cae46",
+  "version": "3.7.4-dev-20260416-fabcd3f",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -130,10 +130,10 @@
   ],
   "dependencies": {
     "@matter/main": "0.16.11",
-    "@matterbridge/dgram": "3.7.4-dev-20260414-33cae46",
-    "@matterbridge/thread": "3.7.4-dev-20260414-33cae46",
-    "@matterbridge/types": "3.7.4-dev-20260414-33cae46",
-    "@matterbridge/utils": "3.7.4-dev-20260414-33cae46",
+    "@matterbridge/dgram": "3.7.4-dev-20260416-fabcd3f",
+    "@matterbridge/thread": "3.7.4-dev-20260416-fabcd3f",
+    "@matterbridge/types": "3.7.4-dev-20260416-fabcd3f",
+    "@matterbridge/utils": "3.7.4-dev-20260416-fabcd3f",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.3.2",