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

package/dist/jestutils/export.d.ts

@@ -1,8 +1,13 @@
 export * from './jestBroadcastServerSpy.js';
 export * from './jestDeviceManagerSpy.js';
+export * from './jestFlushAsync.js';
 export * from './jestFrontendSpy.js';
-export * from './jestHelpers.js';
+export * from './jestLogAlive.js';
 export * from './jestMatterbridgeEndpointSpy.js';
 export * from './jestMatterbridgePlatformSpy.js';
 export * from './jestMatterbridgeSpy.js';
+export * from './jestMatterbridgeTest.js';
+export * from './jestMatterRequest.js';
+export * from './jestMatterTest.js';
 export * from './jestPluginManagerSpy.js';
+export * from './jestSetupTest.js';

package/dist/jestutils/export.js

@@ -1,8 +1,13 @@
 export * from './jestBroadcastServerSpy.js';
 export * from './jestDeviceManagerSpy.js';
+export * from './jestFlushAsync.js';
 export * from './jestFrontendSpy.js';
-export * from './jestHelpers.js';
+export * from './jestLogAlive.js';
 export * from './jestMatterbridgeEndpointSpy.js';
 export * from './jestMatterbridgePlatformSpy.js';
 export * from './jestMatterbridgeSpy.js';
+export * from './jestMatterbridgeTest.js';
+export * from './jestMatterRequest.js';
+export * from './jestMatterTest.js';
 export * from './jestPluginManagerSpy.js';
+export * from './jestSetupTest.js';

package/dist/jestutils/jestFlushAsync.d.ts

@@ -0,0 +1 @@
+export declare function flushAsync(ticks?: number, microTurns?: number, pause?: number): Promise<void>;

package/dist/jestutils/jestFlushAsync.js

@@ -0,0 +1,8 @@
+export async function flushAsync(ticks = 3, microTurns = 10, pause = 250) {
+    for (let i = 0; i < ticks; i++)
+        await new Promise((resolve) => setImmediate(resolve));
+    for (let i = 0; i < microTurns; i++)
+        await Promise.resolve();
+    if (pause)
+        await new Promise((resolve) => setTimeout(resolve, pause));
+}

package/dist/jestutils/jestLogAlive.d.ts

@@ -0,0 +1,2 @@
+import { AnsiLogger } from 'node-ansi-logger';
+export declare function logKeepAlives(log?: AnsiLogger): number;

package/dist/jestutils/jestLogAlive.js

@@ -0,0 +1,31 @@
+import { inspect } from 'node:util';
+import { rs } from 'node-ansi-logger';
+export function logKeepAlives(log) {
+    const handles = process._getActiveHandles?.() ?? [];
+    const requests = process._getActiveRequests?.() ?? [];
+    const fmtHandle = (h, i) => {
+        const ctor = h?.constructor?.name ?? 'Unknown';
+        const hasRef = typeof h?.hasRef === 'function' ? h.hasRef() : undefined;
+        const isPort = h?.constructor?.name?.includes('MessagePort');
+        const fd = h?.fd ?? h?._handle?.fd;
+        return { i, type: ctor, hasRef, isPort, fd };
+    };
+    const fmtReq = (r, i) => {
+        const ctor = r?.constructor?.name ?? 'Unknown';
+        return { i, type: ctor };
+    };
+    const summary = {
+        handles: handles.map(fmtHandle),
+        requests: requests.map(fmtReq),
+    };
+    if (summary.handles.length === 0 && summary.requests.length === 0) {
+        log?.debug('KeepAlive: no active handles or requests.');
+    }
+    else {
+        log?.debug(`KeepAlive:${rs}\n${inspect(summary, { depth: 5, colors: true })}`);
+        if (!log) {
+            process.stdout.write(`KeepAlive:\n${inspect(summary, { depth: 5, colors: true })}\n`);
+        }
+    }
+    return summary.handles.length + summary.requests.length;
+}

package/dist/jestutils/jestMatterRequest.d.ts

@@ -0,0 +1,10 @@
+import { ColorControl } from '@matter/main/clusters/color-control';
+import { LevelControl } from '@matter/main/clusters/level-control';
+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;

package/dist/jestutils/jestMatterRequest.js

@@ -0,0 +1,78 @@
+import { ColorControl } from '@matter/main/clusters/color-control';
+export function getMoveToLevelRequest(level, transitionTime, executeIfOff) {
+    const request = {
+        level,
+        transitionTime,
+        optionsMask: { executeIfOff, coupleColorTempToLevel: false },
+        optionsOverride: { executeIfOff, coupleColorTempToLevel: false },
+    };
+    return request;
+}
+export function getMoveToColorTemperatureRequest(colorTemperatureMireds, transitionTime, executeIfOff) {
+    const request = {
+        colorTemperatureMireds,
+        transitionTime,
+        optionsMask: { executeIfOff },
+        optionsOverride: { executeIfOff },
+    };
+    return request;
+}
+export function getMoveToHueRequest(hue, transitionTime, executeIfOff) {
+    const request = {
+        hue,
+        transitionTime,
+        direction: ColorControl.Direction.Shortest,
+        optionsMask: { executeIfOff },
+        optionsOverride: { executeIfOff },
+    };
+    return request;
+}
+export function getEnhancedMoveToHueRequest(enhancedHue, transitionTime, executeIfOff) {
+    const request = {
+        enhancedHue,
+        transitionTime,
+        direction: ColorControl.Direction.Shortest,
+        optionsMask: { executeIfOff },
+        optionsOverride: { executeIfOff },
+    };
+    return request;
+}
+export function getMoveToSaturationRequest(saturation, transitionTime, executeIfOff) {
+    const request = {
+        saturation,
+        transitionTime,
+        optionsMask: { executeIfOff },
+        optionsOverride: { executeIfOff },
+    };
+    return request;
+}
+export function getMoveToHueAndSaturationRequest(hue, saturation, transitionTime, executeIfOff) {
+    const request = {
+        hue,
+        saturation,
+        transitionTime,
+        optionsMask: { executeIfOff },
+        optionsOverride: { executeIfOff },
+    };
+    return request;
+}
+export function getEnhancedMoveToHueAndSaturationRequest(enhancedHue, saturation, transitionTime, executeIfOff) {
+    const request = {
+        enhancedHue,
+        saturation,
+        transitionTime,
+        optionsMask: { executeIfOff },
+        optionsOverride: { executeIfOff },
+    };
+    return request;
+}
+export function getMoveToColorRequest(colorX, colorY, transitionTime, executeIfOff) {
+    const request = {
+        colorX,
+        colorY,
+        transitionTime,
+        optionsMask: { executeIfOff },
+        optionsOverride: { executeIfOff },
+    };
+    return request;
+}

package/dist/jestutils/jestMatterTest.d.ts

@@ -0,0 +1,19 @@
+import '@matter/nodejs';
+import { Environment } from '@matter/general';
+import { Endpoint, ServerNode } from '@matter/node';
+import { AggregatorEndpoint } from '@matter/node/endpoints';
+import { DeviceTypeId } from '@matter/types/datatype';
+export declare let environment: Environment;
+export declare let server: ServerNode<ServerNode.RootEndpoint>;
+export declare let aggregator: Endpoint<AggregatorEndpoint>;
+export declare function createTestEnvironment(): Promise<Environment>;
+export declare function destroyTestEnvironment(): Promise<void>;
+export declare function flushAllEndpointNumberPersistence(targetServer: ServerNode, rounds?: number, ticks?: number, microTurns?: 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(port: number, deviceType?: DeviceTypeId, ticks?: number, microTurns?: number, pause?: number): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
+export declare function startServerNode(ticks?: number, microTurns?: number, pause?: number): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
+export declare function stopServerNode(ticks?: number, microTurns?: number, pause?: number): Promise<void>;
+export declare function flushServerNode(ticks?: number, microTurns?: number, pause?: number): Promise<void>;
+export declare function addDevice(owner: ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>, device: Endpoint, rounds?: number, pause?: number): Promise<boolean>;
+export declare function deleteDevice(owner: ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>, device: Endpoint, rounds?: number, pause?: number): Promise<boolean>;

package/dist/jestutils/jestMatterTest.js

@@ -0,0 +1,218 @@
+import '@matter/nodejs';
+import path from 'node:path';
+import { inspect } from 'node:util';
+import { Environment, Lifecycle, LogFormat as MatterLogFormat, LogLevel as MatterLogLevel } from '@matter/general';
+import { Endpoint, ServerNode, ServerNodeStore } from '@matter/node';
+import { AggregatorEndpoint } from '@matter/node/endpoints';
+import { DeviceTypeId, VendorId } from '@matter/types/datatype';
+import { MATTER_STORAGE_DIR } from '@matterbridge/types';
+import { er, rs } from 'node-ansi-logger';
+import { bridge } from '../matterbridgeDeviceTypes.js';
+import { flushAsync } from './jestFlushAsync.js';
+import { HOMEDIR, NAME } from './jestSetupTest.js';
+export let environment;
+export let server;
+export let aggregator;
+export async function createTestEnvironment() {
+    expect(NAME).toBeDefined();
+    expect(typeof NAME).toBe('string');
+    expect(NAME.length).toBeGreaterThanOrEqual(4);
+    environment = Environment.default;
+    environment.vars.set('log.level', MatterLogLevel.DEBUG);
+    environment.vars.set('log.format', MatterLogFormat.ANSI);
+    environment.vars.set('path.root', path.join(HOMEDIR, '.matterbridge', MATTER_STORAGE_DIR));
+    environment.vars.set('runtime.signals', false);
+    environment.vars.set('runtime.exitcode', false);
+    return environment;
+}
+export async function destroyTestEnvironment() {
+}
+export async function flushAllEndpointNumberPersistence(targetServer, rounds = 3, ticks = 1, microTurns = 1, pause = 10) {
+    const nodeStore = targetServer.env.get(ServerNodeStore);
+    for (let i = 0; i < rounds; i++) {
+        await flushAsync(ticks, microTurns, pause);
+        await nodeStore.endpointStores.close();
+    }
+}
+function getRootServerNode(endpoint) {
+    let current = endpoint;
+    while (current.owner) {
+        current = current.owner;
+    }
+    return current;
+}
+function collectAllEndpoints(root) {
+    const list = [];
+    const walk = (ep) => {
+        list.push(ep);
+        if (ep.parts) {
+            for (const child of ep.parts) {
+                walk(child);
+            }
+        }
+    };
+    walk(root);
+    return list;
+}
+export async function assertAllEndpointNumbersPersisted(targetServer) {
+    const nodeStore = targetServer.env.get(ServerNodeStore);
+    await nodeStore.endpointStores.close();
+    const all = collectAllEndpoints(targetServer);
+    for (const ep of all) {
+        const store = nodeStore.storeForEndpoint(ep);
+        if (ep.maybeNumber === 0) {
+            expect(store.number ?? 0).toBe(0);
+        }
+        else {
+            expect(store.number).toBeGreaterThan(0);
+        }
+    }
+    return all.length;
+}
+export async function closeServerNodeStores(targetServer) {
+    if (!targetServer)
+        targetServer = server;
+    await targetServer?.env.get(ServerNodeStore)?.endpointStores.close();
+}
+export async function createServerNode(port, deviceType = bridge.code, ticks = 1, microTurns = 1, pause = 10) {
+    const { randomBytes } = await import('node:crypto');
+    const random = randomBytes(8).toString('hex');
+    server = await ServerNode.create({
+        id: NAME + 'ServerNode',
+        environment,
+        productDescription: {
+            name: NAME + 'ServerNode',
+            deviceType: DeviceTypeId(deviceType),
+            vendorId: VendorId(0xfff1),
+            productId: 0x8000,
+        },
+        basicInformation: {
+            vendorId: VendorId(0xfff1),
+            vendorName: 'Matterbridge',
+            productId: 0x8000,
+            productName: 'Matterbridge ' + NAME,
+            nodeLabel: NAME + 'ServerNode',
+            hardwareVersion: 1,
+            softwareVersion: 1,
+            reachable: true,
+            serialNumber: 'SN' + random,
+            uniqueId: 'UI' + random,
+        },
+        network: {
+            listeningAddressIpv4: undefined,
+            listeningAddressIpv6: undefined,
+            port,
+        },
+        operationalCredentials: {
+            certification: undefined,
+        },
+    });
+    expect(server).toBeDefined();
+    expect(server.lifecycle.isReady).toBeTruthy();
+    aggregator = new Endpoint(AggregatorEndpoint, {
+        id: NAME + 'AggregatorNode',
+    });
+    expect(aggregator).toBeDefined();
+    await server.add(aggregator);
+    expect(server.parts.has(aggregator.id)).toBeTruthy();
+    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(ticks = 1, microTurns = 1, pause = 10) {
+    if (!server || !aggregator) {
+        throw new Error('Server node and aggregator must be created before starting the server. Call createServerNode() first.');
+    }
+    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(ticks, microTurns, pause);
+    return [server, aggregator];
+}
+export async function stopServerNode(ticks = 1, microTurns = 1, pause = 10) {
+    await flushAllEndpointNumberPersistence(server);
+    await assertAllEndpointNumbersPersisted(server);
+    expect(server).toBeDefined();
+    expect(server.lifecycle.isReady).toBeTruthy();
+    expect(server.lifecycle.isOnline).toBeTruthy();
+    await server.close();
+    expect(server.lifecycle.isReady).toBeFalsy();
+    expect(server.lifecycle.isOnline).toBeFalsy();
+    await flushAsync(ticks, microTurns, pause);
+}
+export async function flushServerNode(ticks = 1, microTurns = 1, pause = 10) {
+    await flushAllEndpointNumberPersistence(server);
+    await assertAllEndpointNumbersPersisted(server);
+    await flushAsync(ticks, microTurns, pause);
+}
+export async function addDevice(owner, device, rounds = 3, pause = 10) {
+    expect(owner).toBeDefined();
+    expect(device).toBeDefined();
+    expect(owner.lifecycle.isReady).toBeTruthy();
+    expect(owner.construction.status).toBe(Lifecycle.Status.Active);
+    expect(owner.lifecycle.isPartsReady).toBeTruthy();
+    const rootServerNode = getRootServerNode(owner);
+    await flushAllEndpointNumberPersistence(rootServerNode, rounds, pause);
+    try {
+        await owner.add(device);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : error;
+        const errorInspect = inspect(error, { depth: 10 });
+        process.stderr.write(`${er}Error adding device ${device.maybeId}.${device.maybeNumber}: ${errorMessage}${rs}\nStack: ${errorInspect}\n`);
+        return false;
+    }
+    await device.construction.ready;
+    expect(owner.parts.has(device)).toBeTruthy();
+    expect(owner.lifecycle.isPartsReady).toBeTruthy();
+    expect(device.lifecycle.isReady).toBeTruthy();
+    expect(device.lifecycle.isInstalled).toBeTruthy();
+    expect(device.lifecycle.hasId).toBeTruthy();
+    expect(device.lifecycle.hasNumber).toBeTruthy();
+    expect(device.construction.status).toBe(Lifecycle.Status.Active);
+    await flushAllEndpointNumberPersistence(rootServerNode, rounds, pause);
+    return true;
+}
+export async function deleteDevice(owner, device, rounds = 3, pause = 10) {
+    expect(owner).toBeDefined();
+    expect(device).toBeDefined();
+    expect(owner.lifecycle.isReady).toBeTruthy();
+    expect(owner.construction.status).toBe(Lifecycle.Status.Active);
+    expect(owner.lifecycle.isPartsReady).toBeTruthy();
+    const rootServerNode = getRootServerNode(owner);
+    await flushAllEndpointNumberPersistence(rootServerNode, rounds, pause);
+    try {
+        await device.delete();
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : error;
+        const errorInspect = inspect(error, { depth: 10 });
+        process.stderr.write(`${er}Error deleting device ${device.maybeId}.${device.maybeNumber}: ${errorMessage}${rs}\nStack: ${errorInspect}\n`);
+        return false;
+    }
+    expect(owner.parts.has(device)).toBeFalsy();
+    expect(owner.lifecycle.isPartsReady).toBeTruthy();
+    expect(device.lifecycle.isReady).toBeFalsy();
+    expect(device.lifecycle.isInstalled).toBeFalsy();
+    expect(device.lifecycle.hasId).toBeTruthy();
+    expect(device.lifecycle.hasNumber).toBeTruthy();
+    expect(device.construction.status).toBe(Lifecycle.Status.Destroyed);
+    await flushAllEndpointNumberPersistence(rootServerNode, rounds, pause);
+    return true;
+}

package/dist/jestutils/jestMatterbridgeEndpointSpy.d.ts

@@ -13,6 +13,11 @@ export declare const updateAttributeMatterbridgeEndpointSpy: import("jest-mock")
     <T extends import("@matter/types").ClusterType, A extends keyof import("@matter/types").ClusterType.AttributeValues<T>>(cluster: T, attribute: A, value: import("@matter/types").ClusterType.AttributeValues<T>[A], log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
     (cluster: import("@matter/types").ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
 }>;
+export declare const subscribeAttributeMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
+    <T extends import("@matter/node").Behavior.Type, A extends keyof import("@matter/node").Behavior.StateOf<T>>(cluster: T, attribute: A, listener: (newValue: import("@matter/node").Behavior.StateOf<T>[A], oldValue: import("@matter/node").Behavior.StateOf<T>[A], context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
+    <T extends import("@matter/types").ClusterType, A extends keyof import("@matter/types").ClusterType.AttributeValues<T>>(cluster: T, attribute: A, listener: (newValue: import("@matter/types").ClusterType.AttributeValues<T>[A], oldValue: import("@matter/types").ClusterType.AttributeValues<T>[A], context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
+    (cluster: import("@matter/types").ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
+}>;
 export declare const triggerEventMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
     <T extends import("@matter/node").Behavior.Type, E extends keyof import("@matter/types").ClusterType.EventsOf<T extends {
         cluster: infer C extends import("@matter/types").ClusterType;

package/dist/jestutils/jestMatterbridgeEndpointSpy.js

@@ -3,5 +3,6 @@ import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export const setClusterMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'setCluster');
 export const setAttributeMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'setAttribute');
 export const updateAttributeMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'updateAttribute');
+export const subscribeAttributeMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'subscribeAttribute');
 export const triggerEventMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'triggerEvent');
 export const triggerSwitchEventMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'triggerSwitchEvent');

package/dist/jestutils/jestMatterbridgeTest.d.ts

@@ -0,0 +1,21 @@
+import { Endpoint, ServerNode } from '@matter/node';
+import { AggregatorEndpoint } from '@matter/node/endpoints';
+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 let matterbridge: Matterbridge;
+export declare let frontend: Frontend;
+export declare let plugins: PluginManager;
+export declare let devices: DeviceManager;
+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, closeRuntime?: boolean): Promise<void>;
+export declare function createMatterbridgeEnvironment(): 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, closeRuntime?: 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 closeRuntimeInstance(matterbridge: Matterbridge): Promise<void>;