@matterbridge/core 3.7.5-dev-20260419-96eefd1 → 3.7.5-dev-20260421-b7fd269

package/dist/jestutils/jestMatterbridgeTest.js

@@ -0,0 +1,252 @@
+import path from 'node:path';
+import { Environment, RuntimeService } from '@matter/general';
+import { MdnsService } from '@matter/protocol';
+import { MATTER_STORAGE_DIR, NODE_STORAGE_DIR } from '@matterbridge/types';
+import { rs, UNDERLINE, UNDERLINEOFF } from 'node-ansi-logger';
+import { NodeStorageManager } from 'node-persist-manager';
+import { Matterbridge } from '../matterbridge.js';
+import { flushAsync } from './jestFlushAsync.js';
+import { assertAllEndpointNumbersPersisted, createTestEnvironment, flushAllEndpointNumberPersistence } from './jestMatterTest.js';
+import { HOMEDIR, loggerLogSpy, originalProcessArgv } from './jestSetupTest.js';
+let server;
+let aggregator;
+export let matterbridge;
+export let frontend;
+export let plugins;
+export let devices;
+export async function startMatterbridge(bridgeMode = 'bridge', frontendPort = 8283, matterPort = 5540, passcode = 20252026, discriminator = 3840, pluginSize = 0, devicesSize = 0) {
+    process.env['MATTERBRIDGE_START_MATTER_INTERVAL_MS'] = '100';
+    process.env['MATTERBRIDGE_PAUSE_MATTER_INTERVAL_MS'] = '100';
+    process.argv.length = 0;
+    process.argv.push(...originalProcessArgv, '--novirtual', '--debug', '--verbose', '--logger', 'debug', '--matterlogger', 'debug', bridgeMode === '' ? '--test' : '--' + bridgeMode, '--homedir', HOMEDIR, '--frontend', frontendPort.toString(), '--port', matterPort.toString(), '--passcode', passcode.toString(), '--discriminator', discriminator.toString());
+    expect(Matterbridge.instance).toBeUndefined();
+    matterbridge = await Matterbridge.loadInstance(true);
+    expect(matterbridge.environment).toBeDefined();
+    expect(matterbridge.systemCheckTimeout).toBeDefined();
+    expect(matterbridge.checkUpdateTimeout).toBeDefined();
+    expect(matterbridge.checkUpdateInterval).toBeDefined();
+    clearTimeout(matterbridge.systemCheckTimeout);
+    clearTimeout(matterbridge.checkUpdateTimeout);
+    clearInterval(matterbridge.checkUpdateInterval);
+    new MdnsService(matterbridge.environment);
+    expect(matterbridge).toBeDefined();
+    expect(matterbridge.profile).toBeUndefined();
+    expect(matterbridge.bridgeMode).toBe(bridgeMode);
+    frontend = matterbridge.frontend;
+    plugins = matterbridge.plugins;
+    devices = matterbridge.devices;
+    expect(matterbridge.initialized).toBeTruthy();
+    expect(matterbridge.log).toBeDefined();
+    expect(matterbridge.rootDirectory).toBe(path.resolve('./'));
+    expect(matterbridge.homeDirectory).toBe(path.join(HOMEDIR));
+    expect(matterbridge.matterbridgeDirectory).toBe(path.join(HOMEDIR, '.matterbridge'));
+    expect(matterbridge.matterbridgePluginDirectory).toBe(path.join(HOMEDIR, 'Matterbridge'));
+    expect(matterbridge.matterbridgeCertDirectory).toBe(path.join(HOMEDIR, '.mattercert'));
+    expect(plugins).toBeDefined();
+    expect(plugins.size).toBe(pluginSize);
+    expect(devices).toBeDefined();
+    expect(devices.size).toBe(devicesSize);
+    expect(frontend).toBeDefined();
+    expect(frontend.listening).toBeTruthy();
+    expect(frontend.httpServer).toBeDefined();
+    expect(frontend.httpsServer).toBeUndefined();
+    expect(frontend.expressApp).toBeDefined();
+    expect(frontend.webSocketServer).toBeDefined();
+    expect(matterbridge.nodeStorage).toBeDefined();
+    expect(matterbridge.nodeContext).toBeDefined();
+    expect(Environment.default.vars.get('path.root')).toBe(path.join(matterbridge.matterbridgeDirectory, MATTER_STORAGE_DIR));
+    expect(matterbridge.matterStorageService).toBeDefined();
+    expect(matterbridge.matterStorageManager).toBeDefined();
+    expect(matterbridge.matterbridgeContext).toBeDefined();
+    expect(matterbridge.controllerContext).toBeUndefined();
+    if (bridgeMode === 'bridge') {
+        expect(matterbridge.serverNode).toBeDefined();
+        expect(matterbridge.aggregatorNode).toBeDefined();
+    }
+    expect(matterbridge.mdnsInterface).toBe(undefined);
+    expect(matterbridge.port).toBe(matterPort + (bridgeMode === 'bridge' ? 1 : 0));
+    expect(matterbridge.passcode).toBe(passcode + (bridgeMode === 'bridge' ? 1 : 0));
+    expect(matterbridge.discriminator).toBe(discriminator + (bridgeMode === 'bridge' ? 1 : 0));
+    if (bridgeMode === 'bridge') {
+        const started = new Promise((resolve) => {
+            matterbridge.once('bridge_started', () => {
+                resolve();
+            });
+        });
+        const online = new Promise((resolve) => {
+            matterbridge.once('online', (name) => {
+                if (name === 'Matterbridge')
+                    resolve();
+            });
+        });
+        await Promise.all([started, online]);
+    }
+    else if (bridgeMode === 'childbridge') {
+        await new Promise((resolve) => {
+            matterbridge.once('childbridge_started', () => {
+                resolve();
+            });
+        });
+    }
+    expect(loggerLogSpy).toHaveBeenCalledWith("info", `The frontend http server is listening on ${UNDERLINE}http://${matterbridge.systemInformation.ipv4Address}:${frontendPort}${UNDERLINEOFF}${rs}`);
+    if (bridgeMode === 'bridge') {
+        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Starting Matterbridge server node`);
+        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Server node for Matterbridge is online`);
+        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Starting start matter interval in bridge mode...`);
+        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Cleared startMatterInterval interval in bridge mode`);
+        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Matterbridge bridge started successfully`);
+    }
+    else if (bridgeMode === 'childbridge') {
+        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Starting start matter interval in childbridge mode...`);
+        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Cleared startMatterInterval interval in childbridge mode`);
+        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Matterbridge childbridge started successfully`);
+    }
+    return matterbridge;
+}
+export async function stopMatterbridge(cleanupPause = 10, destroyPause = 250, closeMdns = false, closeRuntime = false) {
+    await destroyMatterbridgeEnvironment(cleanupPause, destroyPause, closeMdns, closeRuntime);
+}
+export async function createMatterbridgeEnvironment() {
+    matterbridge = await Matterbridge.loadInstance(false);
+    expect(matterbridge).toBeDefined();
+    expect(matterbridge).toBeInstanceOf(Matterbridge);
+    matterbridge.matterbridgeVersion = '3.7.5';
+    matterbridge.bridgeMode = 'bridge';
+    matterbridge.rootDirectory = path.join(HOMEDIR);
+    matterbridge.homeDirectory = path.join(HOMEDIR);
+    matterbridge.matterbridgeDirectory = path.join(HOMEDIR, '.matterbridge');
+    matterbridge.matterbridgePluginDirectory = path.join(HOMEDIR, 'Matterbridge');
+    matterbridge.matterbridgeCertDirectory = path.join(HOMEDIR, '.mattercert');
+    matterbridge.log.logLevel = "debug";
+    frontend = matterbridge.frontend;
+    plugins = matterbridge.plugins;
+    devices = matterbridge.devices;
+    const environment = await createTestEnvironment();
+    expect(environment).toBeDefined();
+    expect(environment).toBeInstanceOf(Environment);
+    matterbridge.environment = environment;
+    return matterbridge;
+}
+export async function startMatterbridgeEnvironment(port = 5540, createOnly = false) {
+    matterbridge.nodeStorage = new NodeStorageManager({
+        dir: path.join(matterbridge.matterbridgeDirectory, NODE_STORAGE_DIR),
+        writeQueue: false,
+        expiredInterval: undefined,
+        logging: false,
+    });
+    matterbridge.nodeContext = await matterbridge.nodeStorage.createStorage('matterbridge');
+    await matterbridge.startMatterStorage();
+    expect(matterbridge.matterStorageService).toBeDefined();
+    expect(matterbridge.matterStorageManager).toBeDefined();
+    expect(matterbridge.matterbridgeContext).toBeDefined();
+    server = await matterbridge.createServerNode(matterbridge.matterbridgeContext, port);
+    expect(server).toBeDefined();
+    expect(server).toBeDefined();
+    expect(server.lifecycle.isReady).toBeTruthy();
+    matterbridge.serverNode = server;
+    aggregator = await matterbridge.createAggregatorNode(matterbridge.matterbridgeContext);
+    expect(aggregator).toBeDefined();
+    matterbridge.aggregatorNode = aggregator;
+    expect(await server.add(aggregator)).toBeDefined();
+    expect(server.parts.has(aggregator.id)).toBeTruthy();
+    expect(server.parts.has(aggregator)).toBeTruthy();
+    expect(aggregator.lifecycle.isReady).toBeTruthy();
+    if (createOnly) {
+        await flushAsync();
+        return [server, aggregator];
+    }
+    expect(server.lifecycle.isOnline).toBeFalsy();
+    await new Promise((resolve) => {
+        server.lifecycle.online.on(async () => {
+            resolve();
+        });
+        server.start();
+    });
+    expect(server.lifecycle.isReady).toBeTruthy();
+    expect(server.lifecycle.isOnline).toBeTruthy();
+    expect(server.lifecycle.isCommissioned).toBeFalsy();
+    expect(server.lifecycle.isPartsReady).toBeTruthy();
+    expect(server.lifecycle.hasId).toBeTruthy();
+    expect(server.lifecycle.hasNumber).toBeTruthy();
+    expect(aggregator.lifecycle.isReady).toBeTruthy();
+    expect(aggregator.lifecycle.isInstalled).toBeTruthy();
+    expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
+    expect(aggregator.lifecycle.hasId).toBeTruthy();
+    expect(aggregator.lifecycle.hasNumber).toBeTruthy();
+    await flushAsync();
+    return [server, aggregator];
+}
+export function addMatterbridgePlatform(platform, name) {
+    expect(platform).toBeDefined();
+    platform.setMatterNode?.(matterbridge.addBridgedEndpoint.bind(matterbridge), matterbridge.removeBridgedEndpoint.bind(matterbridge), matterbridge.removeAllBridgedEndpoints.bind(matterbridge), matterbridge.addVirtualEndpoint.bind(matterbridge));
+    if (name)
+        platform.config.name = name;
+    expect(platform.config.name).toBeDefined();
+    expect(platform.config.type).toBeDefined();
+    expect(platform.type).toBeDefined();
+    expect(platform.config.version).toBeDefined();
+    expect(platform.version).toBeDefined();
+    expect(platform.config.debug).toBeDefined();
+    expect(platform.config.unregisterOnShutdown).toBeDefined();
+    matterbridge.plugins._plugins.set(platform.config.name, {
+        name: platform.config.name,
+        path: './',
+        type: platform.type,
+        version: platform.version,
+        description: 'Plugin ' + platform.config.name,
+        author: 'Unknown',
+        enabled: true,
+    });
+    platform['name'] = platform.config.name;
+}
+export async function stopMatterbridgeEnvironment(createOnly = false) {
+    expect(matterbridge).toBeDefined();
+    expect(server).toBeDefined();
+    expect(aggregator).toBeDefined();
+    await flushAllEndpointNumberPersistence(server);
+    await assertAllEndpointNumbersPersisted(server);
+    expect(server.lifecycle.isReady).toBeTruthy();
+    if (!createOnly) {
+        expect(server.lifecycle.isOnline).toBeTruthy();
+    }
+    await server.close();
+    expect(server.lifecycle.isReady).toBeFalsy();
+    expect(server.lifecycle.isOnline).toBeFalsy();
+    await matterbridge.stopMatterStorage();
+    expect(matterbridge.matterStorageService).not.toBeDefined();
+    expect(matterbridge.matterStorageManager).not.toBeDefined();
+    expect(matterbridge.matterbridgeContext).not.toBeDefined();
+    await matterbridge.nodeContext?.close();
+    matterbridge.nodeContext = undefined;
+    await matterbridge.nodeStorage?.close();
+    matterbridge.nodeStorage = undefined;
+    await flushAsync();
+}
+export async function destroyMatterbridgeEnvironment(cleanupPause = 10, destroyPause = 100, closeMdns = false, closeRuntime = false) {
+    await destroyInstance(matterbridge, cleanupPause, destroyPause);
+    if (closeMdns) {
+        await closeMdnsInstance(matterbridge);
+    }
+    if (closeRuntime) {
+        await closeRuntimeInstance(matterbridge);
+    }
+    Matterbridge.instance = undefined;
+}
+export async function destroyInstance(matterbridge, cleanupPause = 10, destroyPause = 250) {
+    await matterbridge.cleanup('destroying instance...', false, cleanupPause);
+    if (destroyPause > 0)
+        await flushAsync(undefined, undefined, destroyPause);
+}
+export async function closeMdnsInstance(matterbridge) {
+    const environment = matterbridge.environment;
+    const mdns = environment.maybeGet(MdnsService);
+    if (!mdns)
+        return;
+    await mdns.close();
+    environment.delete(MdnsService, mdns);
+}
+export async function closeRuntimeInstance(matterbridge) {
+    const environment = matterbridge.environment;
+    const runtime = environment.maybeGet(RuntimeService);
+    await runtime?.close();
+}

package/dist/jestutils/jestSetupTest.d.ts

@@ -0,0 +1,21 @@
+import type { jest } from '@jest/globals';
+import { AnsiLogger } from 'node-ansi-logger';
+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>;
+export declare let loggerDebugSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.debug>;
+export declare let loggerInfoSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.info>;
+export declare let loggerNoticeSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.notice>;
+export declare let loggerWarnSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.warn>;
+export declare let loggerErrorSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.error>;
+export declare let loggerFatalSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.fatal>;
+export declare let consoleLogSpy: jest.SpiedFunction<typeof console.log>;
+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 NAME: string;
+export declare let HOMEDIR: string;
+export declare let log: AnsiLogger;
+export declare function setupTest(name: string, debug?: boolean): Promise<void>;
+export declare function setDebug(debug: boolean): Promise<void>;

package/dist/jestutils/jestSetupTest.js

@@ -0,0 +1,78 @@
+import { mkdirSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { AnsiLogger } from 'node-ansi-logger';
+export const originalProcessArgv = Object.freeze([...process.argv]);
+export const originalProcessEnv = Object.freeze({ ...process.env });
+export let loggerLogSpy;
+export let loggerDebugSpy;
+export let loggerInfoSpy;
+export let loggerNoticeSpy;
+export let loggerWarnSpy;
+export let loggerErrorSpy;
+export let loggerFatalSpy;
+export let consoleLogSpy;
+export let consoleDebugSpy;
+export let consoleInfoSpy;
+export let consoleWarnSpy;
+export let consoleErrorSpy;
+export let NAME;
+export let HOMEDIR;
+export let log;
+export async function setupTest(name, debug = false) {
+    expect(name).toBeDefined();
+    expect(typeof name).toBe('string');
+    expect(name.length).toBeGreaterThanOrEqual(4);
+    NAME = name;
+    HOMEDIR = path.join('.cache', 'jest', name);
+    log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: "debug" });
+    rmSync(HOMEDIR, { recursive: true, force: true });
+    mkdirSync(HOMEDIR, { recursive: true });
+    const { jest } = await import('@jest/globals');
+    loggerDebugSpy = jest.spyOn(AnsiLogger.prototype, 'debug');
+    loggerInfoSpy = jest.spyOn(AnsiLogger.prototype, 'info');
+    loggerNoticeSpy = jest.spyOn(AnsiLogger.prototype, 'notice');
+    loggerWarnSpy = jest.spyOn(AnsiLogger.prototype, 'warn');
+    loggerErrorSpy = jest.spyOn(AnsiLogger.prototype, 'error');
+    loggerFatalSpy = jest.spyOn(AnsiLogger.prototype, 'fatal');
+    if (debug) {
+        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
+        consoleLogSpy = jest.spyOn(console, 'log');
+        consoleDebugSpy = jest.spyOn(console, 'debug');
+        consoleInfoSpy = jest.spyOn(console, 'info');
+        consoleWarnSpy = jest.spyOn(console, 'warn');
+        consoleErrorSpy = jest.spyOn(console, 'error');
+    }
+    else {
+        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log').mockImplementation(() => { });
+        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
+        consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
+        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+    }
+}
+export async function setDebug(debug) {
+    const { jest } = await import('@jest/globals');
+    if (debug) {
+        loggerLogSpy.mockRestore();
+        consoleLogSpy.mockRestore();
+        consoleDebugSpy.mockRestore();
+        consoleInfoSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
+        consoleLogSpy = jest.spyOn(console, 'log');
+        consoleDebugSpy = jest.spyOn(console, 'debug');
+        consoleInfoSpy = jest.spyOn(console, 'info');
+        consoleWarnSpy = jest.spyOn(console, 'warn');
+        consoleErrorSpy = jest.spyOn(console, 'error');
+    }
+    else {
+        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log').mockImplementation(() => { });
+        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
+        consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
+        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.7.5-dev-20260419-96eefd1",
+  "version": "3.7.5-dev-20260421-b7fd269",
   "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.5-dev-20260419-96eefd1",
-    "@matterbridge/thread": "3.7.5-dev-20260419-96eefd1",
-    "@matterbridge/types": "3.7.5-dev-20260419-96eefd1",
-    "@matterbridge/utils": "3.7.5-dev-20260419-96eefd1",
+    "@matterbridge/dgram": "3.7.5-dev-20260421-b7fd269",
+    "@matterbridge/thread": "3.7.5-dev-20260421-b7fd269",
+    "@matterbridge/types": "3.7.5-dev-20260421-b7fd269",
+    "@matterbridge/utils": "3.7.5-dev-20260421-b7fd269",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.3.2",

package/dist/jestutils/jestHelpers.d.ts

@@ -1,68 +0,0 @@
-import type { jest } from '@jest/globals';
-import { Environment } from '@matter/general';
-import { Endpoint, ServerNode } from '@matter/node';
-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 { AnsiLogger } from 'node-ansi-logger';
-import type { DeviceManager } from '../deviceManager.js';
-import type { Frontend } from '../frontend.js';
-import { Matterbridge } from '../matterbridge.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>;
-export declare let loggerDebugSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.debug>;
-export declare let loggerInfoSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.info>;
-export declare let loggerNoticeSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.notice>;
-export declare let loggerWarnSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.warn>;
-export declare let loggerErrorSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.error>;
-export declare let loggerFatalSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.fatal>;
-export declare let consoleLogSpy: jest.SpiedFunction<typeof console.log>;
-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 NAME: string;
-export declare let HOMEDIR: string;
-export declare let matterbridge: Matterbridge;
-export declare let frontend: Frontend;
-export declare let plugins: PluginManager;
-export declare let devices: DeviceManager;
-export declare let environment: Environment;
-export declare let server: ServerNode<ServerNode.RootEndpoint>;
-export declare let aggregator: Endpoint<AggregatorEndpoint>;
-export declare let log: AnsiLogger;
-export declare function setupTest(name: string, debug?: boolean): Promise<void>;
-export declare function setDebug(debug: boolean): Promise<void>;
-export declare function startMatterbridge(bridgeMode?: 'bridge' | 'childbridge' | 'controller' | '', frontendPort?: number, matterPort?: number, passcode?: number, discriminator?: number, pluginSize?: number, devicesSize?: number): Promise<Matterbridge>;
-export declare function stopMatterbridge(cleanupPause?: number, destroyPause?: number, closeMdns?: boolean): Promise<void>;
-export declare function createMatterbridgeEnvironment(name: string, createOnly?: boolean): Promise<Matterbridge>;
-export declare function startMatterbridgeEnvironment(port?: number, createOnly?: boolean): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
-export declare function addMatterbridgePlatform(platform: MatterbridgePlatform, name?: string): void;
-export declare function stopMatterbridgeEnvironment(createOnly?: boolean): Promise<void>;
-export declare function destroyMatterbridgeEnvironment(cleanupPause?: number, destroyPause?: number, closeMdns?: boolean): Promise<void>;
-export declare function destroyInstance(matterbridge: Matterbridge, cleanupPause?: number, destroyPause?: number): Promise<void>;
-export declare function closeMdnsInstance(matterbridge: Matterbridge): Promise<void>;
-export declare function createTestEnvironment(name: string, createOnly?: boolean): Environment;
-export declare function destroyTestEnvironment(createOnly?: boolean): Promise<void>;
-export declare function flushAsync(ticks?: number, microTurns?: number, pause?: number): Promise<void>;
-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 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;
-export declare function getMoveToColorTemperatureRequest(colorTemperatureMireds: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToColorTemperatureRequest;
-export declare function getMoveToHueRequest(hue: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToHueRequest;
-export declare function getEnhancedMoveToHueRequest(enhancedHue: number, transitionTime: number, executeIfOff: boolean): ColorControl.EnhancedMoveToHueRequest;
-export declare function getMoveToSaturationRequest(saturation: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToSaturationRequest;
-export declare function getMoveToHueAndSaturationRequest(hue: number, saturation: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToHueAndSaturationRequest;
-export declare function getEnhancedMoveToHueAndSaturationRequest(enhancedHue: number, saturation: number, transitionTime: number, executeIfOff: boolean): ColorControl.EnhancedMoveToHueAndSaturationRequest;
-export declare function getMoveToColorRequest(colorX: number, colorY: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToColorRequest;