@matterbridge/core 3.9.0 → 3.9.1-dev-20260614-89d7aeb

package/dist/devices/oven.d.ts

@@ -1,7 +1,7 @@
-import { MaybePromise } from '@matter/general';
+import { type MaybePromise } from '@matter/general';
 import { OvenCavityOperationalStateServer } from '@matter/node/behaviors/oven-cavity-operational-state';
 import { OvenModeServer } from '@matter/node/behaviors/oven-mode';
-import { Semtag } from '@matter/types';
+import { type Semtag } from '@matter/types';
 import { ModeBase } from '@matter/types/clusters/mode-base';
 import { OperationalState } from '@matter/types/clusters/operational-state';
 import { OvenMode } from '@matter/types/clusters/oven-mode';

package/dist/devices/refrigerator.d.ts

@@ -1,6 +1,6 @@
-import { MaybePromise } from '@matter/general';
+import { type MaybePromise } from '@matter/general';
 import { RefrigeratorAndTemperatureControlledCabinetModeServer } from '@matter/node/behaviors/refrigerator-and-temperature-controlled-cabinet-mode';
-import { Semtag } from '@matter/types';
+import { type Semtag } from '@matter/types';
 import { ModeBase } from '@matter/types/clusters/mode-base';
 import { RefrigeratorAndTemperatureControlledCabinetMode } from '@matter/types/clusters/refrigerator-and-temperature-controlled-cabinet-mode';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';

package/dist/devices/roboticVacuumCleaner.d.ts

@@ -9,7 +9,7 @@ import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
 import { ServiceArea } from '@matter/types/clusters/service-area';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class RoboticVacuumCleaner extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string, mode?: 'server' | 'matter' | undefined, currentRunMode?: number, supportedRunModes?: RvcRunMode.ModeOption[], currentCleanMode?: number, supportedCleanModes?: RvcCleanMode.ModeOption[], currentPhase?: number | null, phaseList?: string[] | null, operationalState?: RvcOperationalState.OperationalState, operationalStateList?: RvcOperationalState.OperationalStateStruct[], supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number | null, supportedMaps?: ServiceArea.Map[]);
+    constructor(name: string, serial: string, mode?: 'server' | 'matter', currentRunMode?: number, supportedRunModes?: RvcRunMode.ModeOption[], currentCleanMode?: number, supportedCleanModes?: RvcCleanMode.ModeOption[], currentPhase?: number | null, phaseList?: string[] | null, operationalState?: RvcOperationalState.OperationalState, operationalStateList?: RvcOperationalState.OperationalStateStruct[], supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number | null, supportedMaps?: ServiceArea.Map[]);
     createDefaultRvcRunModeClusterServer(currentMode?: number, supportedModes?: RvcRunMode.ModeOption[]): this;
     createDefaultRvcCleanModeClusterServer(currentMode?: number, supportedModes?: RvcCleanMode.ModeOption[]): this;
     createDefaultServiceAreaClusterServer(supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number | null, supportedMaps?: ServiceArea.Map[]): this;

package/dist/devices/roboticVacuumCleaner.js

@@ -14,7 +14,7 @@ import { MatterbridgeServiceAreaServer } from '../behaviors/serviceAreaServer.js
 import { powerSource, roboticVacuumCleaner } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
-    constructor(name, serial, mode = undefined, currentRunMode, supportedRunModes, currentCleanMode, supportedCleanModes, currentPhase = null, phaseList = null, operationalState, operationalStateList, supportedAreas, selectedAreas, currentArea, supportedMaps) {
+    constructor(name, serial, mode, currentRunMode, supportedRunModes, currentCleanMode, supportedCleanModes, currentPhase = null, phaseList = null, operationalState, operationalStateList, supportedAreas, selectedAreas, currentArea, supportedMaps) {
         super([roboticVacuumCleaner, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, mode });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Robot Vacuum Cleaner')

package/dist/devices/soilSensor.d.ts

@@ -1,4 +1,4 @@
-import { type MeasurementAccuracy } from '@matter/types/globals';
+import type { MeasurementAccuracy } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export interface SoilSensorOptions {
     soilMoistureMeasurementLimits?: MeasurementAccuracy;

package/dist/devices/solarPower.d.ts

@@ -1,4 +1,4 @@
-import { Semtag } from '@matter/types/globals';
+import { type Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class SolarPower extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energyExported?: number | bigint, absMinPower?: number, absMaxPower?: number);

package/dist/devices/temperatureControl.d.ts

@@ -1,11 +1,11 @@
 import { TemperatureControlServer } from '@matter/node/behaviors/temperature-control';
 import { TemperatureControl } from '@matter/types/clusters/temperature-control';
-import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { type MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare function createLevelTemperatureControlClusterServer(endpoint: MatterbridgeEndpoint, selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[]): MatterbridgeEndpoint;
 export declare function createNumberTemperatureControlClusterServer(endpoint: MatterbridgeEndpoint, temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number): MatterbridgeEndpoint;
 declare const MatterbridgeLevelTemperatureControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof TemperatureControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<TemperatureControl, {
-    temperatureNumber: false;
     temperatureLevel: true;
+    temperatureNumber: false;
     temperatureStep: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "temperatureControl">;
 export declare class MatterbridgeLevelTemperatureControlServer extends MatterbridgeLevelTemperatureControlServer_base {
@@ -13,8 +13,8 @@ export declare class MatterbridgeLevelTemperatureControlServer extends Matterbri
     setTemperature(request: TemperatureControl.SetTemperatureRequest): Promise<void>;
 }
 declare const MatterbridgeNumberTemperatureControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof TemperatureControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<TemperatureControl, {
-    temperatureNumber: true;
     temperatureLevel: false;
+    temperatureNumber: true;
     temperatureStep: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "temperatureControl">;
 export declare class MatterbridgeNumberTemperatureControlServer extends MatterbridgeNumberTemperatureControlServer_base {

package/dist/frontend.d.ts

@@ -1,5 +1,5 @@
 import EventEmitter from 'node:events';
-import { EndpointNumber } from '@matter/types/datatype';
+import { type EndpointNumber } from '@matter/types/datatype';
 import type { ApiClusters, ApiDevice, ApiMatter, ApiPlugin, ApiSettings, RefreshRequiredChanged, WsMessageBroadcast } from '@matterbridge/types';
 import { LogLevel } from 'node-ansi-logger';
 import type { Matterbridge } from './matterbridge.js';

package/dist/frontend.js

@@ -124,7 +124,7 @@ export class Frontend extends EventEmitter {
                 this.log.debug(`Received broadcast response ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
             switch (msg.type) {
                 case 'manager_spawn_response':
-                    if (msg.result && msg.result.packageCommand === 'install') {
+                    if (msg.result?.packageCommand === 'install') {
                         this.wssSendCloseSnackbarMessage(`Installing package ${msg.result.packageName}...`);
                         if (msg.result.success) {
                             this.restartRequired = true;
@@ -137,7 +137,7 @@ export class Frontend extends EventEmitter {
                             this.wssSendSnackbarMessage(`Package ${msg.result.packageName} not installed`, 10, 'error');
                         }
                     }
-                    if (msg.result && msg.result.packageCommand === 'uninstall') {
+                    if (msg.result?.packageCommand === 'uninstall') {
                         this.wssSendCloseSnackbarMessage(`Uninstalling package ${msg.result.packageName}...`);
                         if (msg.result.success) {
                             this.restartRequired = true;
@@ -152,8 +152,7 @@ export class Frontend extends EventEmitter {
                     }
                     break;
                 case 'manager_archive_response':
-                    if (msg.result &&
-                        msg.result.success &&
+                    if (msg.result?.success &&
                         isValidString(msg.result.command) &&
                         isValidString(msg.result.archivePath) &&
                         isValidArray(msg.result.sourcePaths) &&
@@ -706,7 +705,7 @@ export class Frontend extends EventEmitter {
             res.download(path.join(os.tmpdir(), `matterbridge.${NODE_STORAGE_DIR}.zip`), `matterbridge.${NODE_STORAGE_DIR}.zip`, (error) => {
                 this.wssSendCloseSnackbarMessage('Creating matterbridge storage backup...');
                 if (error) {
-                    this.log.error(`Error downloading file ${`matterbridge.${NODE_STORAGE_DIR}.zip`}: ${error instanceof Error ? error.message : error}`);
+                    this.log.error(`Error downloading file matterbridge.${NODE_STORAGE_DIR}.zip: ${error instanceof Error ? error.message : error}`);
                     res.status(500).send('Error downloading the matterbridge storage file');
                 }
                 else {
@@ -962,7 +961,7 @@ export class Frontend extends EventEmitter {
             return false;
         if (device.hasClusterServer(BridgedDeviceBasicInformation.id))
             return device.getAttribute(BridgedDeviceBasicInformation.id, 'reachable');
-        if (device.mode === 'server' && device.serverNode && device.serverNode.state.basicInformation.reachable !== undefined)
+        if (device.mode === 'server' && device.serverNode?.state.basicInformation.reachable !== undefined)
             return device.serverNode.state.basicInformation.reachable;
         if (this.matterbridge.bridgeMode === 'childbridge')
             return true;
@@ -1003,7 +1002,7 @@ export class Frontend extends EventEmitter {
                 const batChargeLevel = device.getAttribute(PowerSource.id, 'batPercentRemaining');
                 return isValidNumber(batChargeLevel) ? batChargeLevel / 2 : undefined;
             }
-            return undefined;
+            return;
         };
         if (endpoint.hasClusterServer(PowerSource.id))
             return batteryLevel(endpoint);
@@ -1054,11 +1053,11 @@ export class Frontend extends EventEmitter {
                 attributes += `Heat to: ${attributeValue / 100}°C `;
             if (clusterName === 'thermostat' && attributeName === 'occupiedCoolingSetpoint' && isValidNumber(attributeValue))
                 attributes += `Cool to: ${attributeValue / 100}°C `;
-            const modeClusters = ['modeSelect', 'rvcRunMode', 'rvcCleanMode', 'laundryWasherMode', 'ovenMode', 'microwaveOvenMode'];
-            if (modeClusters.includes(clusterName) && attributeName === 'supportedModes') {
+            const modeClusters = new Set(['modeSelect', 'rvcRunMode', 'rvcCleanMode', 'laundryWasherMode', 'ovenMode', 'microwaveOvenMode']);
+            if (modeClusters.has(clusterName) && attributeName === 'supportedModes') {
                 supportedModes = attributeValue;
             }
-            if (modeClusters.includes(clusterName) && attributeName === 'currentMode') {
+            if (modeClusters.has(clusterName) && attributeName === 'currentMode') {
                 const supportedMode = supportedModes.find((mode) => mode.mode === attributeValue);
                 if (supportedMode)
                     attributes += `Mode: ${supportedMode.label} `;
@@ -1199,7 +1198,7 @@ export class Frontend extends EventEmitter {
         const endpoint = this.matterbridge.devices
             .array()
             .find((d) => d.plugin === pluginName && d.maybeNumber === endpointNumber && (!serialNumber || d.serialNumber === serialNumber) && (!uniqueId || d.uniqueId === uniqueId));
-        if (!endpoint || !endpoint.plugin || !endpoint.maybeNumber || !endpoint.maybeId || !endpoint.deviceName || !endpoint.serialNumber) {
+        if (!endpoint?.plugin || !endpoint.maybeNumber || !endpoint.maybeId || !endpoint.deviceName || !endpoint.serialNumber) {
             this.log.error(`getClusters: no device found for plugin ${pluginName} and endpoint number ${endpointNumber} (serial: ${serialNumber ?? 'N/A'}, uniqueId: ${uniqueId ?? 'N/A'})`);
             return;
         }
@@ -1871,7 +1870,7 @@ export class Frontend extends EventEmitter {
                         }
                         break;
                     case 'setmatterport':
-                        const port = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
+                        const port = isValidString(data.params.value) ? Number.parseInt(data.params.value) : 0;
                         if (isValidNumber(port, 5540, 5600)) {
                             this.log.debug(`Set matter commissioning port to ${CYAN}${port}${db}`);
                             this.matterbridge.port = this.matterbridge.initialPort = port;
@@ -1890,7 +1889,7 @@ export class Frontend extends EventEmitter {
                         }
                         break;
                     case 'setmatterdiscriminator':
-                        const discriminator = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
+                        const discriminator = isValidString(data.params.value) ? Number.parseInt(data.params.value) : 0;
                         if (isValidNumber(discriminator, 0, 4095)) {
                             this.log.debug(`Set matter commissioning discriminator to ${CYAN}${discriminator}${db}`);
                             this.matterbridge.discriminator = this.matterbridge.initialDiscriminator = discriminator;
@@ -1915,8 +1914,8 @@ export class Frontend extends EventEmitter {
                         }
                         break;
                     case 'setmatterpasscode':
-                        const passcode = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
-                        if (isValidNumber(passcode, 1, 99999998) && CommissioningOptions.FORBIDDEN_PASSCODES.includes(passcode) === false) {
+                        const passcode = isValidString(data.params.value) ? Number.parseInt(data.params.value) : 0;
+                        if (isValidNumber(passcode, 1, 99999998) && !CommissioningOptions.FORBIDDEN_PASSCODES.includes(passcode)) {
                             this.matterbridge.passcode = this.matterbridge.initialPasscode = passcode;
                             this.log.debug(`Set matter commissioning passcode to ${CYAN}${passcode}${db}`);
                             await this.matterbridge.nodeContext?.set('matterpasscode', passcode);
@@ -2101,7 +2100,7 @@ export class Frontend extends EventEmitter {
         this.log.debug('Sending a restart required message to all connected clients');
         this.restartRequired = true;
         this.fixedRestartRequired = fixed;
-        if (snackbar === true)
+        if (snackbar)
             this.wssSendSnackbarMessage(`Restart required`, 0);
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', success: true, response: { fixed } });
     }
@@ -2110,7 +2109,7 @@ export class Frontend extends EventEmitter {
             return;
         this.log.debug('Sending a restart not required message to all connected clients');
         this.restartRequired = false;
-        if (snackbar === true)
+        if (snackbar)
             this.wssSendCloseSnackbarMessage(`Restart required`);
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
     }

package/dist/helpers.d.ts

@@ -1,5 +1,5 @@
 import { Endpoint } from '@matter/node';
-import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
+import { type AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
 import type { Matterbridge } from './matterbridge.js';
 export declare function addVirtualDevice(aggregatorEndpoint: Endpoint<AggregatorEndpoint>, name: string, type: 'light' | 'outlet' | 'switch' | 'mounted_switch', callback: () => Promise<void>): Promise<Endpoint>;
 export declare function addVirtualDevices(matterbridge: Matterbridge, aggregatorEndpoint: Endpoint<AggregatorEndpoint>): Promise<void>;

package/dist/jestutils/jestBroadcastServerSpy.d.ts

@@ -1,12 +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 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 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 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").SpiedGetter<import("@matterbridge/types").WorkerSrcType> | import("jest-mock").SpiedSetter<import("@matterbridge/types").WorkerSrcType>;
 export declare const broadcastMessageErrorHandlerBroadcastServerSpy: import("jest-mock").SpiedGetter<import("@matterbridge/types").WorkerSrcType> | import("jest-mock").SpiedSetter<import("@matterbridge/types").WorkerSrcType>;

package/dist/jestutils/jestFrontendSpy.d.ts

@@ -1,4 +1,4 @@
-export declare const wssSendSnackbarMessageFrontendSpy: import("jest-mock").SpiedFunction<(message: string, timeout?: number, severity?: "info" | "warning" | "error" | "success") => void>;
+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?: {

package/dist/jestutils/jestMatterTest.d.ts

@@ -5,7 +5,7 @@ import { AggregatorEndpoint } from '@matter/node/endpoints';
 import { DeviceTypeId } from '@matter/types/datatype';
 import { type PlatformMatterbridge } from '@matterbridge/types';
 export declare let environment: Environment;
-export declare let server: ServerNode<ServerNode.RootEndpoint>;
+export declare let server: ServerNode;
 export declare let aggregator: Endpoint<AggregatorEndpoint>;
 export declare function createTestEnvironment(): Promise<Environment>;
 export declare function destroyTestEnvironment(): Promise<void>;
@@ -13,9 +13,9 @@ export declare function getPlatformMatterbridge(): PlatformMatterbridge;
 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 createServerNode(port: number, deviceType?: DeviceTypeId, ticks?: number, microTurns?: number, pause?: number): Promise<[ServerNode, Endpoint<AggregatorEndpoint>]>;
+export declare function startServerNode(ticks?: number, microTurns?: number, pause?: number): Promise<[ServerNode, 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>;
+export declare function addDevice(owner: ServerNode | Endpoint<AggregatorEndpoint>, device: Endpoint, rounds?: number, pause?: number): Promise<boolean>;
+export declare function deleteDevice(owner: ServerNode | Endpoint<AggregatorEndpoint>, device: Endpoint, rounds?: number, pause?: number): Promise<boolean>;

package/dist/jestutils/jestMatterTest.js

@@ -56,10 +56,10 @@ export function getPlatformMatterbridge() {
         matterbridgePluginDirectory: path.join(HOMEDIR, 'Matterbridge'),
         matterbridgeCertDirectory: path.join(HOMEDIR, '.mattercert'),
         globalModulesDirectory: path.join(HOMEDIR, 'node_modules'),
-        matterbridgeVersion: '3.9.0',
-        matterbridgeLatestVersion: '3.9.0',
-        matterbridgeDevVersion: '3.9.0',
-        frontendVersion: '3.9.0',
+        matterbridgeVersion: '3.9.1',
+        matterbridgeLatestVersion: '3.9.1',
+        matterbridgeDevVersion: '3.9.1',
+        frontendVersion: '3.9.1',
         bridgeMode: '',
         restartMode: '',
         virtualMode: 'mounted_switch',

package/dist/jestutils/jestMatterbridgeEndpointSpy.d.ts

@@ -25,7 +25,7 @@ export declare const updateAttributeMatterbridgeEndpointSpy: import("jest-mock")
     (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): MatterbridgeEndpoint;
+    <T extends import("@matter/node").Behavior.Type, A extends keyof import("@matter/node").Behavior.StateOf<T>>(cluster: T, attribute: A, listener: (newValue: InstanceType<T["State"]>[A], oldValue: InstanceType<T["State"]>[A], context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): MatterbridgeEndpoint;
     <T extends import("@matter/types").ClusterType, A extends keyof (T["Typing"] extends {
         Attributes: infer Attributes;
     } ? Attributes : {})>(cluster: T, attribute: A, listener: (newValue: (T["Typing"] extends {
@@ -52,4 +52,4 @@ export declare const triggerEventMatterbridgeEndpointSpy: import("jest-mock").Sp
     } ? Events : Record<string, never>)[E] : never, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
     (cluster: import("@matter/types").ClusterId | string, event: string, payload: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
 }>;
-export declare const triggerSwitchEventMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<(event: "Single" | "Double" | "Long" | "Press" | "Release", log?: import("node-ansi-logger").AnsiLogger) => Promise<boolean>>;
+export declare const triggerSwitchEventMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<(event: 'Single' | 'Double' | 'Long' | 'Press' | 'Release', log?: import("node-ansi-logger").AnsiLogger) => Promise<boolean>>;

package/dist/jestutils/jestMatterbridgePlatformSpy.d.ts

@@ -1,4 +1,4 @@
-export declare const destroyMatterbridgePlatformSpy: 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> | 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>;
+export declare const destroyMatterbridgePlatformSpy: import("jest-mock").SpiedGetter<string | boolean | import("node-ansi-logger").AnsiLogger | import("node-persist-manager").NodeStorage | import("../matterbridgePlatform.js").PlatformMatterbridge | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig> | import("jest-mock").SpiedSetter<string | boolean | import("node-ansi-logger").AnsiLogger | import("node-persist-manager").NodeStorage | import("../matterbridgePlatform.js").PlatformMatterbridge | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig>;
 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>>;
@@ -9,7 +9,7 @@ export declare const saveConfigMatterbridgePlatformSpy: import("jest-mock").Spie
 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 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>;
@@ -20,11 +20,11 @@ export declare const getDeviceByOriginalIdMatterbridgePlatformSpy: import("jest-
 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 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").SpiedGetter<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").SpiedSetter<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 saveSelectsMatterbridgePlatformSpy: import("jest-mock").SpiedGetter<string | boolean | import("node-ansi-logger").AnsiLogger | import("node-persist-manager").NodeStorage | import("../matterbridgePlatform.js").PlatformMatterbridge | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig> | import("jest-mock").SpiedSetter<string | boolean | import("node-ansi-logger").AnsiLogger | import("node-persist-manager").NodeStorage | import("../matterbridgePlatform.js").PlatformMatterbridge | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig>;
 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>>;
@@ -56,5 +56,5 @@ export declare const getSelectEntitiesMatterbridgePlatformSpy: import("jest-mock
 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").SpiedGetter<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").SpiedSetter<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").SpiedGetter<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").SpiedSetter<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 clearEndpointNumbersMatterbridgePlatformSpy: import("jest-mock").SpiedGetter<string | boolean | import("node-ansi-logger").AnsiLogger | import("node-persist-manager").NodeStorage | import("../matterbridgePlatform.js").PlatformMatterbridge | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig> | import("jest-mock").SpiedSetter<string | boolean | import("node-ansi-logger").AnsiLogger | import("node-persist-manager").NodeStorage | import("../matterbridgePlatform.js").PlatformMatterbridge | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig>;
+export declare const checkEndpointNumbersMatterbridgePlatformSpy: import("jest-mock").SpiedGetter<string | boolean | import("node-ansi-logger").AnsiLogger | import("node-persist-manager").NodeStorage | import("../matterbridgePlatform.js").PlatformMatterbridge | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig> | import("jest-mock").SpiedSetter<string | boolean | import("node-ansi-logger").AnsiLogger | import("node-persist-manager").NodeStorage | import("../matterbridgePlatform.js").PlatformMatterbridge | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig>;

package/dist/jestutils/jestMatterbridgeSpy.d.ts

@@ -1,4 +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>>;
+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/jestMatterbridgeTest.d.ts

@@ -1,5 +1,5 @@
-import { Endpoint, ServerNode } from '@matter/node';
-import { AggregatorEndpoint } from '@matter/node/endpoints';
+import { type Endpoint, type ServerNode } from '@matter/node';
+import { type AggregatorEndpoint } from '@matter/node/endpoints';
 import type { DeviceManager } from '../deviceManager.js';
 import type { Frontend } from '../frontend.js';
 import { Matterbridge } from '../matterbridge.js';
@@ -12,7 +12,7 @@ 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 startMatterbridgeEnvironment(port?: number, createOnly?: boolean): Promise<[ServerNode, 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>;

package/dist/jestutils/jestMatterbridgeTest.js

@@ -109,7 +109,7 @@ export async function createMatterbridgeEnvironment() {
     matterbridge = await Matterbridge.loadInstance(false);
     expect(matterbridge).toBeDefined();
     expect(matterbridge).toBeInstanceOf(Matterbridge);
-    matterbridge.matterbridgeVersion = '3.9.0';
+    matterbridge.matterbridgeVersion = '3.9.1';
     matterbridge.bridgeMode = 'bridge';
     matterbridge.rootDirectory = path.join(HOMEDIR);
     matterbridge.homeDirectory = path.join(HOMEDIR);

package/dist/jestutils/logKeepAlives.d.ts

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

package/dist/jestutils/matterRequest.d.ts

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

package/dist/matterbridge.d.ts

@@ -1,13 +1,13 @@
 import '@matter/nodejs';
 import EventEmitter from 'node:events';
-import { StorageContext, StorageManager, StorageService } from '@matter/general';
+import { type StorageContext, type StorageManager, StorageService } from '@matter/general';
 import { Endpoint, ServerNode } from '@matter/node';
 import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
-import { DeviceCertification } from '@matter/protocol';
+import { type DeviceCertification } from '@matter/protocol';
 import { DeviceTypeId, VendorId } from '@matter/types/datatype';
 import type { ApiMatter, MaybePromise, PlatformMatterbridge, SharedMatterbridge, SystemInformation } from '@matterbridge/types';
 import { AnsiLogger, LogLevel } from 'node-ansi-logger';
-import { NodeStorage, NodeStorageManager } from 'node-persist-manager';
+import { type NodeStorage, NodeStorageManager } from 'node-persist-manager';
 import { DeviceManager } from './deviceManager.js';
 import { Frontend } from './frontend.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
@@ -96,7 +96,7 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
     discriminator: number | undefined;
     initialDiscriminator: number | undefined;
     certification: DeviceCertification.Configuration | undefined;
-    serverNode: ServerNode<ServerNode.RootEndpoint> | undefined;
+    serverNode: ServerNode | undefined;
     aggregatorNode: Endpoint<AggregatorEndpoint> | undefined;
     aggregatorVendorId: VendorId;
     aggregatorVendorName: string;
@@ -105,7 +105,7 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
     aggregatorDeviceType: DeviceTypeId;
     aggregatorSerialNumber: string | undefined;
     aggregatorUniqueId: string | undefined;
-    controllerNode: ServerNode<ServerNode.RootEndpoint> | undefined;
+    controllerNode: ServerNode | undefined;
     controllerVendorId: VendorId;
     controllerVendorName: string;
     controllerProductId: number;
@@ -142,7 +142,7 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
     private stopMatterStorage;
     private createServerNodeContext;
     private createServerNode;
-    getServerNodeData(serverNode: ServerNode<ServerNode.RootEndpoint>): ApiMatter;
+    getServerNodeData(serverNode: ServerNode): ApiMatter;
     private startServerNode;
     private stopServerNode;
     private createAggregatorNode;