matterbridge 3.3.0 → 3.3.1-dev-20251007-4e5eaac

package/CHANGELOG.md

@@ -23,7 +23,35 @@ Advantages:
 - isolation between threads;
 - individual plugin isolation in childbridge mode;
 
-## [3.3.0] - Not released
+## [3.3.1] - Not released
+
+### Breaking Changes
+
+- [frontend]: When a plugin is first installed, it will not be anymore started to allow to configure it before restarting.
+- [index]: Removed old plugin api compatibility since it was changed one year ago.
+
+### Added
+
+- [network]: Added getInterfaceDetails() function.
+- [network]: Added getInterfaceName() function.
+- [network]: Optimized code.
+- [matterbridge]: Added SharedMatterbridge readonly type.
+- [thread]: Add BroadcastServer to frontend plugins and devices.
+
+### Changed
+
+- [package]: Updated dependencies.
+- [matterbridge]: Removed matterbridgeInformation. It will be recreated when the frontend requires it.
+- [frontend]: Bumped `frontend` version to 3.2.1.
+- [frontend]: Refactored InstallProgressDialog.
+- [spawn]: Refactored spawnCommand for compatibility with InstallProgressDialog.
+- [matter.js]: Bumped `matter.js` to 0.15.5. Thanks matter.js!
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
+## [3.3.0] - 2025-10-03
 
 ### Development Breaking Changes Notice
 
@@ -98,8 +126,6 @@ In this phase (matterbridge `3.4.x`) all plugins will not build and will not run
 - [package]: Updated dependencies.
 - [frontend]: General improvements and small bug fixes.
 
-### Fixed
-
 <a href="https://www.buymeacoffee.com/luligugithub">
   <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
 </a>

package/README.md

@@ -78,10 +78,14 @@ After follow the guidelines for the [Docker configurations](README-DOCKER.md).
 
 I suggest using Docker for its simplicity.
 
-Since as stated in the Matter specifications "Matter aims to build a universal IPv6-based communication protocol for smart home devices", ipv6 should be enabled in the network.
+Since Matter is designed as "a universal IPv6-based communication protocol for smart home devices" (per the Matter specifications), **IPv6 must be enabled on your local network (LAN)**.
+
+**Important:** You only need IPv6 on your local network - it doesn't matter if your internet provider doesn't provide IPv6 on the internet side (WAN).
 
 Avoid using VLAN and firewall blocking the communications between the controllers and Matterbridge.
 
+To pair matterbridge, you need a matter enabled controller (Apple Home, Smart Things, Google Home, Alexa, Hose Assistant etc.).
+
 ## Installation
 
 Follow these steps to install Matterbridge:
@@ -574,3 +578,7 @@ Click on the badge below to get started:
 </a>
 
 Thank you for your support!
+
+# Licensing
+
+Matterbridge is licensed under the [Apache License 2.0](./LICENSE).

package/dist/broadcastServer.js

@@ -0,0 +1,73 @@
+import { EventEmitter } from 'node:events';
+import { BroadcastChannel } from 'node:worker_threads';
+import { debugStringify } from 'node-ansi-logger';
+export class BroadcastServer extends EventEmitter {
+    name;
+    log;
+    channel;
+    broadcastChannel;
+    constructor(name, log, channel = 'broadcast-channel') {
+        super();
+        this.name = name;
+        this.log = log;
+        this.channel = channel;
+        this.broadcastChannel = new BroadcastChannel(this.channel);
+        this.broadcastChannel.onmessage = this.broadcastMessageHandler.bind(this);
+    }
+    close() {
+        this.broadcastChannel.onmessage = null;
+        this.broadcastChannel.close();
+    }
+    getUniqueId() {
+        return Math.floor(Math.random() * (999999 - 100000 + 1)) + 100000;
+    }
+    isWorkerRequest(msg, type) {
+        return typeof msg === 'object' && msg !== null && 'id' in msg && 'type' in msg && msg.type === type && !('response' in msg) && 'src' in msg && 'dst' in msg;
+    }
+    isWorkerResponse(msg, type) {
+        return typeof msg === 'object' && msg !== null && 'id' in msg && 'type' in msg && msg.type === type && 'response' in msg && 'src' in msg && 'dst' in msg;
+    }
+    broadcastMessageHandler(event) {
+        const data = event.data;
+        this.log.debug(`*Received broadcast message: ${debugStringify(data)}`);
+        this.emit('broadcast_message', data);
+    }
+    request(message) {
+        if (message.id === undefined) {
+            message.id = this.getUniqueId();
+        }
+        if (!this.isWorkerRequest(message, message.type)) {
+            this.log.error(`Invalid request message format for broadcast: ${debugStringify(message)}`);
+            return;
+        }
+        this.log.debug(`*Broadcasting message: ${debugStringify(message)}`);
+        this.broadcastChannel.postMessage(message);
+    }
+    respond(message) {
+        if (!this.isWorkerResponse(message, message.type)) {
+            this.log.error(`Invalid response message format for broadcast: ${debugStringify(message)}`);
+            return;
+        }
+        this.log.debug(`*Broadcasting message: ${debugStringify(message)}`);
+        this.broadcastChannel.postMessage(message);
+    }
+    async fetch(message) {
+        this.log.debug(`*Fetching message: ${debugStringify(message)}`);
+        return new Promise((resolve, reject) => {
+            const responseHandler = (msg) => {
+                if (this.isWorkerResponse(msg, message.type) && msg.id === message.id) {
+                    clearTimeout(timeoutId);
+                    this.off('broadcast_message', responseHandler);
+                    this.log.debug(`*Fetch response: ${debugStringify(msg)}`);
+                    resolve(msg);
+                }
+            };
+            this.on('broadcast_message', responseHandler);
+            this.request(message);
+            const timeoutId = setTimeout(() => {
+                this.off('broadcast_message', responseHandler);
+                reject(new Error(`Fetch timeout after 100ms for message id ${message.id}`));
+            }, 100);
+        });
+    }
+}

package/dist/broadcastServerTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -1,44 +1,17 @@
-/**
- * This file contains the CLI entry point of Matterbridge.
- *
- * @file cli.ts
- * @author Luca Liguori
- * @created 2023-12-29
- * @version 2.0.1
- * @license Apache-2.0
- *
- * Copyright 2023, 2024, 2025 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import os from 'node:os';
 import { inspect } from 'node:util';
-// AnsiLogger module
 import { AnsiLogger, BRIGHT, CYAN, db, YELLOW } from 'node-ansi-logger';
-// Matterbridge
 import { getIntParameter, hasParameter } from './utils/export.js';
 import { Matterbridge } from './matterbridge.js';
 import { cliEmitter, lastCpuUsage, setLastCpuUsage } from './cliEmitter.js';
 export let instance;
-// Inspectop
 let session;
 let snapshotInterval;
-// Cpu and memory check
 let memoryCheckInterval;
 let prevCpus;
 let peakCpu = 0;
 let peakRss = 0;
-const log = new AnsiLogger({ logName: 'Cli', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: hasParameter('debug') ? "debug" /* LogLevel.DEBUG */ : "info" /* LogLevel.INFO */ });
+const log = new AnsiLogger({ logName: 'Cli', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
 const formatMemoryUsage = (bytes) => {
     if (bytes >= 1024 ** 3) {
         return `${(bytes / 1024 ** 3).toFixed(2)} GB`;
@@ -65,20 +38,14 @@ const formatOsUpTime = (seconds) => {
     }
     return `${seconds} second${seconds !== 1 ? 's' : ''}`;
 };
-/**
- * Starts the CPU and memory check interval.
- */
 async function startCpuMemoryCheck() {
-    // const os = await import('node:os');
     log.debug(`Cpu memory check started`);
     prevCpus = os.cpus();
     clearInterval(memoryCheckInterval);
     const interval = () => {
-        // Get the os uptime
         const systemUptime = formatOsUpTime(Math.floor(os.uptime()));
         const processUptime = formatOsUpTime(Math.floor(process.uptime()));
         cliEmitter.emit('uptime', systemUptime, processUptime);
-        // Get the memory usage
         const totalMememory = formatMemoryUsage(os.totalmem());
         const freeMemory = formatMemoryUsage(os.freemem());
         const memoryUsageRaw = process.memoryUsage();
@@ -90,12 +57,10 @@ async function startCpuMemoryCheck() {
         if (memoryUsageRaw.rss > peakRss)
             peakRss = memoryUsageRaw.rss;
         cliEmitter.emit('memory', totalMememory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers);
-        // Get the cpu usage
         const currCpus = os.cpus();
-        // log.debug(`Cpus: ${JSON.stringify(currCpus)}`);
         let cpuUsageLog;
         if (currCpus.length !== prevCpus.length) {
-            prevCpus = currCpus; // Reset the previous cpus
+            prevCpus = currCpus;
             log.debug(`Cpu check length failed, resetting previous cpus`);
             return;
         }
@@ -121,29 +86,20 @@ async function startCpuMemoryCheck() {
             cliEmitter.emit('cpu', lastCpuUsage);
         }
         prevCpus = currCpus;
-        // Show the cpu and memory usage
         log.debug(`***${YELLOW}${BRIGHT}Cpu usage:${db} ${CYAN}${cpuUsageLog.padStart(6, ' ')} %${db} ${YELLOW}${BRIGHT}Memory usage:${db} rss ${CYAN}${rss}${db} heapTotal ${CYAN}${heapTotal}${db} heapUsed ${CYAN}${heapUsed}${db} external ${external} arrayBuffers ${arrayBuffers}`);
     };
     interval();
     clearInterval(memoryCheckInterval);
     memoryCheckInterval = setInterval(interval, getIntParameter('memoryinterval') ?? 10 * 1000).unref();
 }
-/**
- * Stops the CPU and memory check interval.
- */
 async function stopCpuMemoryCheck() {
     log.debug(`***Cpu memory check stopped. Peak cpu: ${CYAN}${peakCpu.toFixed(2)} %${db}. Peak rss: ${CYAN}${formatMemoryUsage(peakRss)}${db}.`);
     clearInterval(memoryCheckInterval);
 }
-/**
- * Starts the inspector for heap sampling.
- * This function is called when the -inspect parameter is passed.
- */
 async function startInspector() {
     const { Session } = await import('node:inspector');
     const { mkdirSync } = await import('node:fs');
     log.debug(`***Starting heap sampling...`);
-    // Create the heap snapshots directory if it doesn't exist
     mkdirSync('heap_profile', { recursive: true });
     try {
         session = new Session();
@@ -152,7 +108,6 @@ async function startInspector() {
             session?.post('HeapProfiler.startSampling', (err) => (err ? reject(err) : resolve()));
         });
         log.debug(`***Started heap sampling`);
-        // Set an interval to take heap snapshots
         const interval = getIntParameter('snapshotinterval');
         if (interval && interval >= 30000) {
             log.debug(`***Started heap snapshot interval of ${CYAN}${interval}${db} ms`);
@@ -170,19 +125,13 @@ async function startInspector() {
         return;
     }
 }
-/**
- * Stops the heap sampling and saves the profile to a file.
- * This function is called when the inspector is stopped.
- */
 async function stopInspector() {
     const { writeFileSync } = await import('node:fs');
     const path = await import('node:path');
     log.debug(`***Stopping heap sampling...`);
     if (snapshotInterval) {
         log.debug(`***Clearing heap snapshot interval...`);
-        // Clear the snapshot interval if it exists
         clearInterval(snapshotInterval);
-        // Take a final heap snapshot before stopping
         await takeHeapSnapshot();
     }
     if (!session) {
@@ -190,7 +139,6 @@ async function stopInspector() {
         return;
     }
     try {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const result = await new Promise((resolve, reject) => {
             session?.post('HeapProfiler.stopSampling', (err, result) => (err ? reject(err) : resolve(result)));
         });
@@ -208,13 +156,6 @@ async function stopInspector() {
         log.debug(`***Stopped heap sampling`);
     }
 }
-/**
- * Takes a heap snapshot and saves it to the file name Heap-snapshot-<timestamp>.heapsnapshot.
- * This function is called periodically based on the -snapshotinterval parameter.
- * The -snapshotinterval parameter must at least 30000 ms.
- * The snapshot is saved in the heap_profile directory that is created in the current working directory.
- * The snapshot can be analyzed using vscode or Chrome DevTools or other tools that support heap snapshots.
- */
 async function takeHeapSnapshot() {
     const { writeFileSync } = await import('node:fs');
     const path = await import('node:path');
@@ -246,10 +187,6 @@ async function takeHeapSnapshot() {
         });
     });
 }
-/**
- * Triggers a manual garbage collection.
- * This function is working only if the process is started with --expose-gc.
- */
 function triggerGarbageCollection() {
     if (typeof global.gc === 'function') {
         global.gc();
@@ -259,9 +196,6 @@ function triggerGarbageCollection() {
         log.debug('Garbage collection is not exposed. Start Node.js with --expose-gc to enable manual GC.');
     }
 }
-/**
- * Registers event handlers for the Matterbridge instance.
- */
 function registerHandlers() {
     log.debug('Registering event handlers...');
     if (instance)
@@ -284,52 +218,32 @@ function registerHandlers() {
         instance.on('triggergarbagecollection', async () => triggerGarbageCollection());
     log.debug('Registered event handlers');
 }
-/**
- * Shuts down the Matterbridge instance and exits the process.
- */
 async function shutdown() {
     log.debug('Received shutdown event, exiting...');
     if (hasParameter('inspect'))
         await stopInspector();
     await stopCpuMemoryCheck();
     cliEmitter.emit('shutdown');
-    // eslint-disable-next-line n/no-process-exit
     process.exit(0);
 }
-/**
- *
- */
 async function restart() {
     log.debug('Received restart event, loading...');
     instance = await Matterbridge.loadInstance(true);
     registerHandlers();
 }
-/**
- *
- */
 async function update() {
     log.debug('Received update event, updating...');
-    // TODO: Implement update logic outside of matterbridge
     instance = await Matterbridge.loadInstance(true);
     registerHandlers();
 }
-/**
- * Starts the CPU and memory check when the -startmemorycheck parameter is passed.
- */
 async function start() {
     log.debug('Received start memory check event');
     await startCpuMemoryCheck();
 }
-/**
- * Stops the CPU and memory check when the -stopmemorycheck parameter is passed.
- */
 async function stop() {
     log.debug('Received stop memory check event');
     await stopCpuMemoryCheck();
 }
-/**
- * Main function that initializes the Matterbridge instance and starts the CLI.
- */
 async function main() {
     log.debug(`Cli main() started`);
     await startCpuMemoryCheck();
@@ -338,7 +252,6 @@ async function main() {
     log.debug(`***Matterbridge.loadInstance(true) called`);
     instance = await Matterbridge.loadInstance(true);
     log.debug(`***Matterbridge.loadInstance(true) exited`);
-    // Check if the instance needs to shut down from parseCommandLine()
     if (!instance || instance.shutdown) {
         shutdown();
     }
@@ -347,11 +260,9 @@ async function main() {
         cliEmitter.emit('ready');
     }
 }
-// Run the main function
 process.title = 'matterbridge';
 main().catch((error) => {
     const errorMessage = error instanceof Error ? error.message : error;
     const errorInspect = inspect(error, { depth: 10 });
     log.error(`Matterbridge.loadInstance() failed with error: ${errorMessage}\nstack: ${errorInspect}`);
 });
-//# sourceMappingURL=cli.js.map

package/dist/cliEmitter.js

@@ -1,36 +1,6 @@
-/**
- * This file contains the CLI emitter.
- *
- * @file cliEmitter.ts
- * @author Luca Liguori
- * @created 2025-07-04
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { EventEmitter } from 'node:events';
 export const cliEmitter = new EventEmitter();
 export let lastCpuUsage = 0;
-/**
- * Sets the last CPU usage.
- *
- * @param {number} val - The CPU usage percentage to set.
- * @returns {void}
- */
 export function setLastCpuUsage(val) {
     lastCpuUsage = val;
 }
-//# sourceMappingURL=cliEmitter.js.map

package/dist/clusters/export.js

@@ -1,3 +1 @@
 export {};
-// Nothing to export right now, but this file is here to make it easier to add exports in the future
-//# sourceMappingURL=export.js.map

package/dist/defaultConfigSchema.js

@@ -1,26 +1,3 @@
-/**
- * This file contains the default config for the plugins.
- *
- * @file defaultConfigSchema.ts
- * @author Luca Liguori
- * @created 2024-05-07
- * @version 1.0.1
- * @license Apache-2.0
- *
- * Copyright 2024, 2025, 2026 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 export const zigbee2mqtt_config = {
     name: 'matterbridge-zigbee2mqtt',
     type: 'DynamicPlatform',
@@ -82,4 +59,3 @@ export const shelly_config = {
     debugWs: false,
     unregisterOnShutdown: false,
 };
-//# sourceMappingURL=defaultConfigSchema.js.map

package/dist/deviceManager.js

@@ -1,87 +1,65 @@
-/**
- * This file contains the DeviceManager class.
- *
- * @file devices.ts
- * @author Luca Liguori
- * @created 2024-07-26
- * @version 1.0.11
- * @license Apache-2.0
- *
- * Copyright 2024, 2025, 2026 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// AnsiLogger module
-import { AnsiLogger, BLUE, er } from 'node-ansi-logger';
+import { AnsiLogger, BLUE, CYAN, db, debugStringify, er, wr } from 'node-ansi-logger';
 import { dev } from './matterbridgeTypes.js';
-/**
- * Manages Matterbridge devices.
- */
+import { BroadcastServer } from './broadcastServer.js';
 export class DeviceManager {
     _devices = new Map();
-    matterbridge;
     log;
-    /**
-     * Creates an instance of DeviceManager.
-     *
-     * @param {Matterbridge} matterbridge - The Matterbridge instance.
-     */
-    constructor(matterbridge) {
-        this.matterbridge = matterbridge;
-        this.log = new AnsiLogger({ logName: 'DeviceManager', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: matterbridge.log.logLevel });
+    server;
+    constructor() {
+        this.log = new AnsiLogger({ logName: 'DeviceManager', logTimestampFormat: 4, logLevel: "info" });
         this.log.debug('Matterbridge device manager starting...');
+        this.server = new BroadcastServer('devices', this.log);
+        this.server.on('broadcast_message', this.msgHandler.bind(this));
+        this.log.debug('Matterbridge device manager started');
+    }
+    destroy() {
+        this.server.close();
+    }
+    async msgHandler(msg) {
+        if (!this.server.isWorkerRequest(msg, msg.type))
+            return;
+        if (!msg.id || (msg.dst !== 'all' && msg.dst !== 'devices'))
+            return;
+        this.log.debug(`**Received request message ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
+        switch (msg.type) {
+            case 'devices_length':
+                this.server.respond({ ...msg, id: msg.id, response: { length: this.length } });
+                break;
+            case 'devices_size':
+                this.server.respond({ ...msg, id: msg.id, response: { size: this.size } });
+                break;
+            case 'devices_has':
+                this.server.respond({ ...msg, id: msg.id, response: { has: this.has(msg.params.uniqueId) } });
+                break;
+            case 'devices_get':
+                this.server.respond({ ...msg, id: msg.id, response: { device: this.get(msg.params.uniqueId) } });
+                break;
+            case 'devices_set':
+                this.server.respond({ ...msg, id: msg.id, response: { device: this.set(msg.params.device) } });
+                break;
+            case 'devices_remove':
+                this.server.respond({ ...msg, id: msg.id, response: { success: this.remove(msg.params.device) } });
+                break;
+            case 'devices_clear':
+                this.clear();
+                this.server.respond({ ...msg, id: msg.id, response: { success: true } });
+                break;
+            default:
+                this.log.warn(`Unknown broadcast message ${CYAN}${msg.type}${wr} from ${CYAN}${msg.src}${wr}`);
+        }
     }
-    /**
-     * Gets the number of devices.
-     *
-     * @returns {number} The number of devices.
-     */
     get length() {
         return this._devices.size;
     }
-    /**
-     * Gets the number of devices.
-     *
-     * @returns {number} The number of devices.
-     */
     get size() {
         return this._devices.size;
     }
-    /**
-     * Checks if a device with the specified unique ID exists.
-     *
-     * @param {string} uniqueId - The unique ID of the device.
-     * @returns {boolean} True if the device exists, false otherwise.
-     */
     has(uniqueId) {
         return this._devices.has(uniqueId);
     }
-    /**
-     * Gets a device by its unique ID.
-     *
-     * @param {string} uniqueId - The unique ID of the device.
-     * @returns {MatterbridgeEndpoint | undefined} The device, or undefined if not found.
-     */
     get(uniqueId) {
         return this._devices.get(uniqueId);
     }
-    /**
-     * Adds a device to the manager.
-     *
-     * @param {MatterbridgeEndpoint} device - The device to add.
-     * @returns {MatterbridgeEndpoint} The added device.
-     * @throws {Error} If the device does not have a unique ID.
-     */
     set(device) {
         if (!device.uniqueId)
             throw new Error(`The device ${dev}${device.deviceName}${er} has not been initialized: uniqueId is required`);
@@ -90,13 +68,6 @@ export class DeviceManager {
         this._devices.set(device.uniqueId, device);
         return device;
     }
-    /**
-     * Removes a device from the manager.
-     *
-     * @param {MatterbridgeEndpoint} device - The device to remove.
-     * @returns {boolean} True if the device was removed, false otherwise.
-     * @throws {Error} If the device does not have a unique ID.
-     */
     remove(device) {
         if (!device.uniqueId)
             throw new Error(`The device ${dev}${device.deviceName}${er} has not been initialized: uniqueId is required`);
@@ -104,34 +75,15 @@ export class DeviceManager {
             this.log.error(`The device ${dev}${device.deviceName}${er} with uniqueId ${BLUE}${device.uniqueId}${er} serialNumber ${BLUE}${device.serialNumber}${er} is not registered in the device manager`);
         return this._devices.delete(device.uniqueId);
     }
-    /**
-     * Clears all devices from the manager.
-     */
     clear() {
         this._devices.clear();
     }
-    /**
-     * Gets an array of all devices.
-     *
-     * @returns {MatterbridgeEndpoint[]} An array of all devices.
-     */
     array() {
         return Array.from(this._devices.values());
     }
-    /**
-     * Iterates over all devices.
-     *
-     * @returns {IterableIterator<MatterbridgeEndpoint>} An iterator for the devices.
-     */
     [Symbol.iterator]() {
         return this._devices.values();
     }
-    /**
-     * Asynchronously iterates over each device and calls the provided callback function.
-     *
-     * @param {(device: MatterbridgeEndpoint) => Promise<void>} callback - The callback function to call with each device.
-     * @returns {Promise<void>} A promise that resolves when all callbacks have been called.
-     */
     async forEach(callback) {
         if (this.size === 0)
             return;
@@ -145,13 +97,7 @@ export class DeviceManager {
         });
         await Promise.all(tasks);
     }
-    /**
-     * Sets the log level.
-     *
-     * @param {LogLevel} logLevel - The log level to set.
-     */
     set logLevel(logLevel) {
         this.log.logLevel = logLevel;
     }
 }
-//# sourceMappingURL=deviceManager.js.map