@matterbridge/core 3.9.1-dev-20260614-89d7aeb → 3.9.1-dev-20260614-18d1a2e

package/dist/behaviors/activatedCarbonFilterMonitoringServer.d.ts

@@ -1,9 +1,9 @@
 import { ActivatedCarbonFilterMonitoringServer } from '@matter/node/behaviors/activated-carbon-filter-monitoring';
 import { type ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
 declare const MatterbridgeActivatedCarbonFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<typeof ActivatedCarbonFilterMonitoringServer, import("@matter/types").ClusterType.WithSupportedFeatures<ActivatedCarbonFilterMonitoring, {
+    warning: false;
     condition: true;
     replacementProductList: false;
-    warning: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "activatedCarbonFilterMonitoring">;
 export declare class MatterbridgeActivatedCarbonFilterMonitoringServer extends MatterbridgeActivatedCarbonFilterMonitoringServer_base {
     resetCondition(): Promise<void>;

package/dist/behaviors/booleanStateConfigurationServer.d.ts

@@ -1,10 +1,10 @@
 import { BooleanStateConfigurationServer } from '@matter/node/behaviors/boolean-state-configuration';
 import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
 declare const MatterbridgeBooleanStateConfigurationServer_base: import("@matter/node").ClusterBehavior.Type<typeof BooleanStateConfigurationServer, import("@matter/types").ClusterType.WithSupportedFeatures<BooleanStateConfiguration, {
-    alarmSuppress: false;
+    visual: true;
     audible: true;
+    alarmSuppress: false;
     sensitivityLevel: true;
-    visual: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "booleanStateConfiguration">;
 export declare class MatterbridgeBooleanStateConfigurationServer extends MatterbridgeBooleanStateConfigurationServer_base {
     enableDisableAlarm(request: BooleanStateConfiguration.EnableDisableAlarmRequest): Promise<void>;

package/dist/behaviors/colorControlServer.d.ts

@@ -1,11 +1,11 @@
 import { ColorControlServer } from '@matter/node/behaviors/color-control';
 import { ColorControl } from '@matter/types/clusters/color-control';
 declare const MatterbridgeColorControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof ColorControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<ColorControl, {
-    colorLoop: false;
-    colorTemperature: true;
-    enhancedHue: true;
     hueSaturation: true;
+    enhancedHue: true;
+    colorLoop: false;
     xy: true;
+    colorTemperature: true;
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/color-control").ColorControlBaseServer.Internal, "colorControl">;
 export declare class MatterbridgeColorControlServer extends MatterbridgeColorControlServer_base {
     moveToHue(request: ColorControl.MoveToHueRequest): Promise<void>;
@@ -17,17 +17,17 @@ export declare class MatterbridgeColorControlServer extends MatterbridgeColorCon
     moveToColorTemperature(request: ColorControl.MoveToColorTemperatureRequest): Promise<void>;
 }
 declare const MatterbridgeEnhancedColorControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof MatterbridgeColorControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<ColorControl, {
-    colorLoop: false;
-    colorTemperature: true;
-    enhancedHue: true;
     hueSaturation: true;
-    xy: true;
-}>, {
+    enhancedHue: true;
     colorLoop: false;
+    xy: true;
     colorTemperature: true;
-    enhancedHue: true;
+}>, {
     hueSaturation: true;
+    enhancedHue: true;
+    colorLoop: false;
     xy: true;
+    colorTemperature: true;
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/color-control").ColorControlBaseServer.Internal, "colorControl">;
 export declare class MatterbridgeEnhancedColorControlServer extends MatterbridgeEnhancedColorControlServer_base {
 }

package/dist/behaviors/deviceEnergyManagementServer.d.ts

@@ -1,13 +1,13 @@
 import { DeviceEnergyManagementServer } from '@matter/node/behaviors/device-energy-management';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
 declare const MatterbridgeDeviceEnergyManagementServer_base: import("@matter/node").ClusterBehavior.Type<typeof DeviceEnergyManagementServer, import("@matter/types").ClusterType.WithSupportedFeatures<DeviceEnergyManagement, {
-    constraintBasedAdjustment: false;
-    forecastAdjustment: false;
-    pausable: false;
     powerAdjustment: true;
     powerForecastReporting: true;
-    startTimeAdjustment: false;
     stateForecastReporting: false;
+    startTimeAdjustment: false;
+    pausable: false;
+    forecastAdjustment: false;
+    constraintBasedAdjustment: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "deviceEnergyManagement">;
 export declare class MatterbridgeDeviceEnergyManagementServer extends MatterbridgeDeviceEnergyManagementServer_base {
     powerAdjustRequest(request: DeviceEnergyManagement.PowerAdjustRequest): Promise<void>;

package/dist/behaviors/doorLockServer.d.ts

@@ -1,33 +1,33 @@
 import { DoorLockServer } from '@matter/node/behaviors/door-lock';
 import { DoorLock } from '@matter/types/clusters/door-lock';
 declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/node").ClusterBehavior.Type<typeof DoorLockServer, import("@matter/types").ClusterType.WithSupportedFeatures<DoorLock, {
-    aliroBleuwb: false;
-    aliroProvisioning: false;
-    credentialOverTheAirAccess: false;
-    doorPositionSensor: false;
-    faceCredentials: false;
-    fingerCredentials: false;
-    holidaySchedules: false;
     pinCredential: true;
     rfidCredential: false;
-    unbolting: false;
-    user: true;
+    fingerCredentials: false;
     weekDayAccessSchedules: false;
-    yearDayAccessSchedules: false;
-}>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/door-lock").DoorLockBaseServer.Internal, "doorLock">, import("@matter/types").ClusterType.WithEnabledAttributes<import("@matter/types").ClusterType.WithEnabledEvents<import("@matter/types").ClusterType.WithSupportedFeatures<DoorLock, {
-    aliroBleuwb: false;
-    aliroProvisioning: false;
-    credentialOverTheAirAccess: false;
     doorPositionSensor: false;
     faceCredentials: false;
-    fingerCredentials: false;
+    credentialOverTheAirAccess: false;
+    user: true;
+    yearDayAccessSchedules: false;
     holidaySchedules: false;
+    unbolting: false;
+    aliroProvisioning: false;
+    aliroBleuwb: false;
+}>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/door-lock").DoorLockBaseServer.Internal, "doorLock">, import("@matter/types").ClusterType.WithEnabledAttributes<import("@matter/types").ClusterType.WithEnabledEvents<import("@matter/types").ClusterType.WithSupportedFeatures<DoorLock, {
     pinCredential: true;
     rfidCredential: false;
-    unbolting: false;
-    user: true;
+    fingerCredentials: false;
     weekDayAccessSchedules: false;
+    doorPositionSensor: false;
+    faceCredentials: false;
+    credentialOverTheAirAccess: false;
+    user: true;
     yearDayAccessSchedules: false;
+    holidaySchedules: false;
+    unbolting: false;
+    aliroProvisioning: false;
+    aliroBleuwb: false;
 }>, "doorLockAlarm" | "lockOperation" | "lockOperationError">, never>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/door-lock").DoorLockBaseServer.Internal, "doorLock">;
 export declare class MatterbridgeDoorLockServer extends MatterbridgeDoorLockServer_base {
     initialize(): Promise<void>;

package/dist/behaviors/fanControlServer.d.ts

@@ -1,11 +1,11 @@
 import { FanControlServer } from '@matter/node/behaviors/fan-control';
 import { FanControl } from '@matter/types/clusters/fan-control';
 declare const MatterbridgeFanControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof FanControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<FanControl, {
+    step: true;
     airflowDirection: false;
-    auto: true;
     multiSpeed: false;
+    auto: true;
     rocking: false;
-    step: true;
     wind: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "fanControl">;
 export declare class MatterbridgeFanControlServer extends MatterbridgeFanControlServer_base {

package/dist/behaviors/hepaFilterMonitoringServer.d.ts

@@ -1,9 +1,9 @@
 import { HepaFilterMonitoringServer } from '@matter/node/behaviors/hepa-filter-monitoring';
 import { type HepaFilterMonitoring } from '@matter/types/clusters/hepa-filter-monitoring';
 declare const MatterbridgeHepaFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<typeof HepaFilterMonitoringServer, import("@matter/types").ClusterType.WithSupportedFeatures<HepaFilterMonitoring, {
+    warning: false;
     condition: true;
     replacementProductList: false;
-    warning: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "hepaFilterMonitoring">;
 export declare class MatterbridgeHepaFilterMonitoringServer extends MatterbridgeHepaFilterMonitoringServer_base {
     resetCondition(): Promise<void>;

package/dist/behaviors/smokeCoAlarmServer.d.ts

@@ -1,8 +1,8 @@
 import { SmokeCoAlarmServer } from '@matter/node/behaviors/smoke-co-alarm';
 import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
 declare const MatterbridgeSmokeCoAlarmServer_base: import("@matter/node").ClusterBehavior.Type<typeof SmokeCoAlarmServer, import("@matter/types").ClusterType.WithSupportedFeatures<SmokeCoAlarm, {
-    coAlarm: true;
     smokeAlarm: true;
+    coAlarm: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "smokeCoAlarm">;
 export declare class MatterbridgeSmokeCoAlarmServer extends MatterbridgeSmokeCoAlarmServer_base {
     selfTestRequest(): Promise<void>;

package/dist/behaviors/thermostatServer.d.ts

@@ -1,14 +1,14 @@
 import { ThermostatServer } from '@matter/node/behaviors/thermostat';
 import { Thermostat } from '@matter/types/clusters/thermostat';
 declare const MatterbridgeThermostatServer_base: import("@matter/node").ClusterBehavior.Type<typeof ThermostatServer, import("@matter/types").ClusterType.WithSupportedFeatures<Thermostat, {
-    autoMode: true;
-    cooling: true;
-    heating: true;
-    localTemperatureNotExposed: false;
-    matterScheduleConfiguration: false;
     occupancy: false;
     presets: true;
+    heating: true;
+    cooling: true;
     setback: false;
+    autoMode: true;
+    localTemperatureNotExposed: false;
+    matterScheduleConfiguration: false;
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/thermostat").ThermostatBaseServer.Internal, "thermostat">;
 export declare class MatterbridgeThermostatServer extends MatterbridgeThermostatServer_base {
     initialize(): Promise<void>;
@@ -16,14 +16,14 @@ export declare class MatterbridgeThermostatServer extends MatterbridgeThermostat
     setActivePresetRequest(request: Thermostat.SetActivePresetRequest): Promise<void>;
 }
 declare const MatterbridgePresetThermostatServer_base: import("@matter/node").ClusterBehavior.Type<typeof ThermostatServer, import("@matter/types").ClusterType.WithSupportedFeatures<Thermostat, {
-    autoMode: true;
-    cooling: true;
-    heating: true;
-    localTemperatureNotExposed: false;
-    matterScheduleConfiguration: false;
     occupancy: false;
     presets: true;
+    heating: true;
+    cooling: true;
     setback: false;
+    autoMode: true;
+    localTemperatureNotExposed: false;
+    matterScheduleConfiguration: false;
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/thermostat").ThermostatBaseServer.Internal, "thermostat">;
 export declare class MatterbridgePresetThermostatServer extends MatterbridgePresetThermostatServer_base {
 }

package/dist/behaviors/valveConfigurationAndControlServer.d.ts

@@ -1,8 +1,8 @@
 import { ValveConfigurationAndControlServer } from '@matter/node/behaviors/valve-configuration-and-control';
 import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
 declare const MatterbridgeValveConfigurationAndControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof ValveConfigurationAndControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<ValveConfigurationAndControl, {
-    level: true;
     timeSync: false;
+    level: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "valveConfigurationAndControl">;
 export declare class MatterbridgeValveConfigurationAndControlServer extends MatterbridgeValveConfigurationAndControlServer_base {
     open(request: ValveConfigurationAndControl.OpenRequest): Promise<void>;

package/dist/behaviors/windowCoveringServer.d.ts

@@ -2,9 +2,9 @@ import { type WindowCoveringBaseServer, WindowCoveringServer } from '@matter/nod
 import { WindowCovering } from '@matter/types/clusters/window-covering';
 declare const MatterbridgeWindowCoveringServer_base: import("@matter/node").ClusterBehavior.Type<typeof WindowCoveringServer, import("@matter/types").ClusterType.WithSupportedFeatures<WindowCovering, {
     lift: true;
+    tilt: true;
     positionAwareLift: true;
     positionAwareTilt: true;
-    tilt: true;
 }>, import("@matter/types").ClusterType.Concrete, typeof WindowCoveringBaseServer.Internal, "windowCovering">;
 export declare class MatterbridgeWindowCoveringServer extends MatterbridgeWindowCoveringServer_base {
     protected internal: WindowCoveringBaseServer.Internal;
@@ -20,27 +20,27 @@ export declare class MatterbridgeWindowCoveringServer extends MatterbridgeWindow
 }
 declare const MatterbridgeLiftWindowCoveringServer_base: import("@matter/node").ClusterBehavior.Type<typeof MatterbridgeWindowCoveringServer, import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<WindowCovering, {
     lift: true;
+    tilt: true;
     positionAwareLift: true;
     positionAwareTilt: true;
-    tilt: true;
 }>, {
     lift: true;
+    tilt: false;
     positionAwareLift: true;
     positionAwareTilt: false;
-    tilt: false;
 }>, import("@matter/types").ClusterType.Concrete, typeof WindowCoveringBaseServer.Internal, "windowCovering">;
 export declare class MatterbridgeLiftWindowCoveringServer extends MatterbridgeLiftWindowCoveringServer_base {
 }
 declare const MatterbridgeLiftTiltWindowCoveringServer_base: import("@matter/node").ClusterBehavior.Type<typeof MatterbridgeWindowCoveringServer, import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<WindowCovering, {
     lift: true;
+    tilt: true;
     positionAwareLift: true;
     positionAwareTilt: true;
-    tilt: true;
 }>, {
     lift: true;
+    tilt: true;
     positionAwareLift: true;
     positionAwareTilt: true;
-    tilt: true;
 }>, import("@matter/types").ClusterType.Concrete, typeof WindowCoveringBaseServer.Internal, "windowCovering">;
 export declare class MatterbridgeLiftTiltWindowCoveringServer extends MatterbridgeLiftTiltWindowCoveringServer_base {
 }

package/dist/clusters/closure-control.d.ts

@@ -130,7 +130,7 @@ export declare namespace ClosureControl {
 }
 export declare const ClosureControl: ClusterType.Concrete & {
     readonly id: ClusterId & 260;
-    readonly name: 'ClosureControl';
+    readonly name: "ClosureControl";
     readonly revision: 1;
     readonly schema: ClusterModel;
     readonly attributes: ClusterType.AttributeObjects<ClosureControl.Attributes>;

package/dist/clusters/closure-dimension.d.ts

@@ -148,7 +148,7 @@ export declare namespace ClosureDimension {
 }
 export declare const ClosureDimension: ClusterType.Concrete & {
     readonly id: ClusterId & 261;
-    readonly name: 'ClosureDimension';
+    readonly name: "ClosureDimension";
     readonly revision: 1;
     readonly schema: ClusterModel;
     readonly attributes: ClusterType.AttributeObjects<ClosureDimension.Attributes>;

package/dist/clusters/soil-measurement.d.ts

@@ -24,7 +24,7 @@ export declare namespace SoilMeasurement {
 }
 export declare const SoilMeasurement: ClusterType.Concrete & {
     readonly id: ClusterId & 1072;
-    readonly name: 'SoilMeasurement';
+    readonly name: "SoilMeasurement";
     readonly revision: 1;
     readonly schema: ClusterModel;
     readonly attributes: ClusterType.AttributeObjects<SoilMeasurement.Attributes>;

package/dist/devices/closure.d.ts

@@ -2,15 +2,15 @@ import { ClosureControlServer } from '@matter/node/behaviors/closure-control';
 import { ClosureControl } from '@matter/types/clusters/closure-control';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 declare const MatterbridgeClosureControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof ClosureControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<ClosureControl, {
-    calibration: false;
-    instantaneous: false;
-    manuallyOperable: false;
+    speed: true;
+    positioning: true;
     motionLatching: true;
+    instantaneous: false;
+    ventilation: false;
     pedestrian: false;
-    positioning: true;
+    calibration: false;
     protection: false;
-    speed: true;
-    ventilation: false;
+    manuallyOperable: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "closureControl">;
 export declare class MatterbridgeClosureControlServer extends MatterbridgeClosureControlServer_base {
     moveTo: (request: ClosureControl.MoveToRequest) => Promise<void>;

package/dist/devices/closurePanel.d.ts

@@ -2,14 +2,14 @@ import { ClosureDimensionServer } from '@matter/node/behaviors/closure-dimension
 import { ClosureDimension } from '@matter/types/clusters/closure-dimension';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 declare const MatterbridgeClosureDimensionServer_base: import("@matter/node").ClusterBehavior.Type<typeof ClosureDimensionServer, import("@matter/types").ClusterType.WithSupportedFeatures<ClosureDimension, {
-    limitation: false;
-    modulation: false;
-    motionLatching: true;
-    positioning: true;
-    rotation: false;
+    unit: false;
     speed: true;
+    positioning: true;
+    motionLatching: true;
+    limitation: false;
     translation: false;
-    unit: false;
+    rotation: false;
+    modulation: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "closureDimension">;
 export declare class MatterbridgeClosureDimensionServer extends MatterbridgeClosureDimensionServer_base {
     setTarget: (request: ClosureDimension.SetTargetRequest) => Promise<void>;

package/dist/devices/evse.d.ts

@@ -11,10 +11,10 @@ export declare class Evse extends MatterbridgeEndpoint {
     createDefaultEnergyEvseModeClusterServer(currentMode?: number, supportedModes?: EnergyEvseMode.ModeOption[]): this;
 }
 declare const MatterbridgeEnergyEvseServer_base: import("@matter/node").ClusterBehavior.Type<typeof EnergyEvseServer, import("@matter/types").ClusterType.WithSupportedFeatures<EnergyEvse, {
-    chargingPreferences: true;
-    plugAndCharge: false;
     rfid: false;
+    chargingPreferences: true;
     soCReporting: false;
+    plugAndCharge: false;
     v2X: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "energyEvse">;
 export declare class MatterbridgeEnergyEvseServer extends MatterbridgeEnergyEvseServer_base {

package/dist/devices/temperatureControl.d.ts

@@ -4,8 +4,8 @@ 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, {
-    temperatureLevel: true;
     temperatureNumber: false;
+    temperatureLevel: true;
     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, {
-    temperatureLevel: false;
     temperatureNumber: true;
+    temperatureLevel: false;
     temperatureStep: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "temperatureControl">;
 export declare class MatterbridgeNumberTemperatureControlServer extends MatterbridgeNumberTemperatureControlServer_base {

package/dist/helpers.js

@@ -10,9 +10,6 @@ import { OnOffLightDevice } from '@matter/node/devices/on-off-light';
 import { OnOffLightSwitchDevice } from '@matter/node/devices/on-off-light-switch';
 import { OnOffPlugInUnitDevice } from '@matter/node/devices/on-off-plug-in-unit';
 import { VendorId } from '@matter/types/datatype';
-import { hasParameter } from '@matterbridge/utils/cli';
-import { doorLock } from './matterbridgeDeviceTypes.js';
-import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 export async function addVirtualDevice(aggregatorEndpoint, name, type, callback) {
     let deviceType;
     switch (type) {
@@ -59,13 +56,6 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
     return device;
 }
 export async function addVirtualDevices(matterbridge, aggregatorEndpoint) {
-    if (hasParameter('experimental') && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
-        const lockUserPin = new MatterbridgeEndpoint(doorLock, { id: 'door_lock_user_pin' });
-        lockUserPin.createDefaultBridgedDeviceBasicInformationClusterServer('Matterbridge User Pin Lock', 'sn_system_lock', 0xfff1, 'Matterbridge', 'Matterbridge Virtual Device', 20000, '2.0.0');
-        lockUserPin.createUserPinDoorLockClusterServer();
-        lockUserPin.addRequiredClusterServers();
-        await aggregatorEndpoint.add(lockUserPin);
-    }
     if (matterbridge.virtualMode !== 'disabled' && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
         matterbridge.log.notice(`Creating virtual devices for Matterbridge server node...`);
         await addVirtualDevice(aggregatorEndpoint, 'Restart Matterbridge', matterbridge.virtualMode, async () => {

package/dist/jestutils/jestBroadcastServerSpy.d.ts

@@ -1,12 +1,13 @@
-export declare const closeBroadcastServerSpy: import("jest-mock").SpiedFunction<() => void>;
-export declare const getUniqueIdBroadcastServerSpy: import("jest-mock").SpiedFunction<() => number>;
-export declare const isWorkerRequestBroadcastServerSpy: import("jest-mock").SpiedFunction<(value: unknown) => value is import("@matterbridge/types").WorkerMessageRequest>;
-export declare const isWorkerRequestOfTypeBroadcastServerSpy: import("jest-mock").SpiedFunction<<K extends keyof import("@matterbridge/types").WorkerMessageTypes>(value: unknown, type: K) => value is import("@matterbridge/types").WorkerMessageRequest<K>>;
-export declare const isWorkerResponseBroadcastServerSpy: import("jest-mock").SpiedFunction<(value: unknown) => value is import("@matterbridge/types").WorkerMessageResponse>;
-export declare const isWorkerResponseOfTypeBroadcastServerSpy: import("jest-mock").SpiedFunction<<K extends keyof import("@matterbridge/types").WorkerMessageTypes>(value: unknown, type: K) => value is import("@matterbridge/types").WorkerMessageResponse<K>>;
-export declare const broadcastBroadcastServerSpy: import("jest-mock").SpiedFunction<(message: import("@matterbridge/types").WorkerMessage) => void>;
-export declare const requestBroadcastServerSpy: import("jest-mock").SpiedFunction<<K extends keyof import("@matterbridge/types").WorkerMessageTypes>(message: import("@matterbridge/types").WorkerMessageRequest<K>) => void>;
-export declare const respondBroadcastServerSpy: import("jest-mock").SpiedFunction<<K extends keyof import("@matterbridge/types").WorkerMessageTypes>(message: import("@matterbridge/types").WorkerMessageResponse<K>) => void>;
-export declare const fetchBroadcastServerSpy: import("jest-mock").SpiedFunction<<T extends import("@matterbridge/types").WorkerMessageRequestAny, K extends Extract<keyof import("@matterbridge/types").WorkerMessageTypes, T['type']>>(message: T, timeout?: number) => Promise<import("@matterbridge/types").WorkerMessageResponseSuccess<K>>>;
-export declare const broadcastMessageHandlerBroadcastServerSpy: import("jest-mock").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>;
+import { BroadcastServer } from '@matterbridge/thread/server';
+export declare const closeBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.close>;
+export declare const getUniqueIdBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.getUniqueId>;
+export declare const isWorkerRequestBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.isWorkerRequest>;
+export declare const isWorkerRequestOfTypeBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.isWorkerRequestOfType>;
+export declare const isWorkerResponseBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.isWorkerResponse>;
+export declare const isWorkerResponseOfTypeBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.isWorkerResponseOfType>;
+export declare const broadcastBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.broadcast>;
+export declare const requestBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.request>;
+export declare const respondBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.respond>;
+export declare const fetchBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.fetch>;
+export declare const broadcastMessageHandlerBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.broadcastMessageHandler>;
+export declare const broadcastMessageErrorHandlerBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.broadcastMessageErrorHandler>;

package/dist/jestutils/jestBroadcastServerSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { BroadcastServer } from '@matterbridge/thread/server';
+const { jest } = await import('@jest/globals');
 export const closeBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'close');
 export const getUniqueIdBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'getUniqueId');
 export const isWorkerRequestBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'isWorkerRequest');

package/dist/jestutils/jestDeviceManagerSpy.d.ts

@@ -1,13 +1,14 @@
-export declare const destroyDeviceManagerSpy: import("jest-mock").SpiedFunction<() => void>;
-export declare const lengthDeviceManagerSpy: import("jest-mock").SpiedGetter<number>;
-export declare const sizeDeviceManagerSpy: import("jest-mock").SpiedGetter<number>;
-export declare const hasDeviceManagerSpy: import("jest-mock").SpiedFunction<(uniqueId: string) => boolean>;
-export declare const getDeviceManagerSpy: import("jest-mock").SpiedFunction<(uniqueId: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const setDeviceManagerSpy: import("jest-mock").SpiedFunction<(device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint>;
-export declare const removeDeviceManagerSpy: import("jest-mock").SpiedFunction<(device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => boolean>;
-export declare const clearDeviceManagerSpy: import("jest-mock").SpiedFunction<() => void>;
-export declare const arrayDeviceManagerSpy: import("jest-mock").SpiedFunction<() => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint[]>;
-export declare const baseArrayDeviceManagerSpy: import("jest-mock").SpiedFunction<(pluginName?: string) => import("@matterbridge/types").BaseDevice[]>;
-export declare const iteratorDeviceManagerSpy: import("jest-mock").SpiedFunction<() => MapIterator<import("../matterbridgeEndpoint.js").MatterbridgeEndpoint>>;
-export declare const forEachDeviceManagerSpy: import("jest-mock").SpiedFunction<(callback: (device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>) => Promise<void>>;
-export declare const logLevelDeviceManagerSpy: import("jest-mock").SpiedSetter<import("node-ansi-logger").LogLevel>;
+import { DeviceManager } from '../deviceManager.js';
+export declare const destroyDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.destroy>;
+export declare const lengthDeviceManagerSpy: jest.SpiedGetter<typeof DeviceManager.prototype.length>;
+export declare const sizeDeviceManagerSpy: jest.SpiedGetter<typeof DeviceManager.prototype.size>;
+export declare const hasDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.has>;
+export declare const getDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.get>;
+export declare const setDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.set>;
+export declare const removeDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.remove>;
+export declare const clearDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.clear>;
+export declare const arrayDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.array>;
+export declare const baseArrayDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.baseArray>;
+export declare const iteratorDeviceManagerSpy: jest.SpiedFunction<(typeof DeviceManager.prototype)[typeof Symbol.iterator]>;
+export declare const forEachDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.forEach>;
+export declare const logLevelDeviceManagerSpy: jest.SpiedSetter<typeof DeviceManager.prototype.logLevel>;

package/dist/jestutils/jestDeviceManagerSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { DeviceManager } from '../deviceManager.js';
+const { jest } = await import('@jest/globals');
 export const destroyDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'destroy');
 export const lengthDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'length', 'get');
 export const sizeDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'size', 'get');

package/dist/jestutils/jestFrontendSpy.d.ts

@@ -1,9 +1,7 @@
-export declare const wssSendSnackbarMessageFrontendSpy: import("jest-mock").SpiedFunction<(message: string, timeout?: number, severity?: 'info' | 'warning' | 'error' | 'success') => void>;
-export declare const wssSendCloseSnackbarMessageFrontendSpy: import("jest-mock").SpiedFunction<(message: string) => void>;
-export declare const wssSendUpdateRequiredFrontendSpy: import("jest-mock").SpiedFunction<(devVersion?: boolean) => void>;
-export declare const wssSendRefreshRequiredFrontendSpy: import("jest-mock").SpiedFunction<(changed: import("@matterbridge/types").RefreshRequiredChanged, params?: {
-    matter?: import("@matterbridge/types").ApiMatter;
-    lock?: string;
-}) => void>;
-export declare const wssSendRestartRequiredFrontendSpy: import("jest-mock").SpiedFunction<(snackbar?: boolean, fixed?: boolean) => void>;
-export declare const wssSendRestartNotRequiredFrontendSpy: import("jest-mock").SpiedFunction<(snackbar?: boolean) => void>;
+import { Frontend } from '../frontend.js';
+export declare const wssSendSnackbarMessageFrontendSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendSnackbarMessage>;
+export declare const wssSendCloseSnackbarMessageFrontendSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendCloseSnackbarMessage>;
+export declare const wssSendUpdateRequiredFrontendSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendUpdateRequired>;
+export declare const wssSendRefreshRequiredFrontendSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendRefreshRequired>;
+export declare const wssSendRestartRequiredFrontendSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendRestartRequired>;
+export declare const wssSendRestartNotRequiredFrontendSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendRestartNotRequired>;

package/dist/jestutils/jestFrontendSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { Frontend } from '../frontend.js';
+const { jest } = await import('@jest/globals');
 export const wssSendSnackbarMessageFrontendSpy = jest.spyOn(Frontend.prototype, 'wssSendSnackbarMessage');
 export const wssSendCloseSnackbarMessageFrontendSpy = jest.spyOn(Frontend.prototype, 'wssSendCloseSnackbarMessage');
 export const wssSendUpdateRequiredFrontendSpy = jest.spyOn(Frontend.prototype, 'wssSendUpdateRequired');

package/dist/jestutils/jestMatterbridgeEndpointSpy.d.ts

@@ -1,55 +1,7 @@
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-export declare const setClusterMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
-    <T extends import("@matter/node").Behavior.Type>(cluster: T, value: import("@matter/node").Behavior.StateOf<T>, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    <T extends import("@matter/types").ClusterType>(cluster: T, value: Partial<T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {}>, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    (cluster: import("@matter/types").ClusterId | string, value: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-}>;
-export declare const setAttributeMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
-    <T extends import("@matter/node").Behavior.Type, A extends keyof import("@matter/node").Behavior.StateOf<T>>(clusterId: T, attribute: A, value: import("@matter/node").Behavior.StateOf<T>[A], log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    <T extends import("@matter/types").ClusterType, A extends keyof (T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {})>(clusterId: T, attribute: A, value: (T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {})[A], log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    (clusterId: 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 updateAttributeMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
-    <T extends import("@matter/node").Behavior.Type, A extends keyof import("@matter/node").Behavior.StateOf<T>>(cluster: T, attribute: A, value: import("@matter/node").Behavior.StateOf<T>[A], log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    <T extends import("@matter/types").ClusterType, A extends keyof (T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {})>(cluster: T, attribute: A, value: (T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {})[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: 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 {
-        Attributes: infer Attributes;
-    } ? Attributes : {})[A], oldValue: (T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {})[A], context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): MatterbridgeEndpoint;
-    (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): MatterbridgeEndpoint;
-}>;
-export declare const triggerEventMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
-    <T extends import("@matter/node").Behavior.Type, E extends keyof ((T extends {
-        Interface: infer N extends import("@matter/types").ClusterTyping;
-    } ? N : import("@matter/types").ClusterTyping)["Events"] & {}) & string>(cluster: T, event: E, payload: E extends keyof ((T extends {
-        Interface: infer N extends import("@matter/types").ClusterTyping;
-    } ? N : import("@matter/types").ClusterTyping)["Events"] & {}) & string ? ((T extends {
-        Interface: infer N extends import("@matter/types").ClusterTyping;
-    } ? N : import("@matter/types").ClusterTyping)["Events"] & {})[E] : never, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    <T extends import("@matter/types").ClusterType, E extends keyof (T["Typing"] extends {
-        Events: infer Events;
-    } ? Events : Record<string, never>) & string>(cluster: T, event: E, payload: E extends keyof (T["Typing"] extends {
-        Events: infer Events;
-    } ? Events : Record<string, never>) ? (T["Typing"] extends {
-        Events: infer Events;
-    } ? 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 setClusterMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.setCluster>;
+export declare const setAttributeMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.setAttribute>;
+export declare const updateAttributeMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.updateAttribute>;
+export declare const subscribeAttributeMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.subscribeAttribute>;
+export declare const triggerEventMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.triggerEvent>;
+export declare const triggerSwitchEventMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.triggerSwitchEvent>;

package/dist/jestutils/jestMatterbridgeEndpointSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+const { jest } = await import('@jest/globals');
 export const setClusterMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'setCluster');
 export const setAttributeMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'setAttribute');
 export const updateAttributeMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'updateAttribute');

package/dist/jestutils/jestMatterbridgePlatformSpy.d.ts

@@ -1,60 +1,43 @@
-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>>;
-export declare const onChangeLoggerLevelMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(logLevel: import("node-ansi-logger").LogLevel) => Promise<void>>;
-export declare const onActionMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(action: string, value?: string, id?: string, formData?: import("../matterbridgePlatform.js").PlatformConfig) => Promise<void>>;
-export declare const onConfigChangedMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(config: import("../matterbridgePlatform.js").PlatformConfig) => Promise<void>>;
-export declare const saveConfigMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(config: import("../matterbridgePlatform.js").PlatformConfig) => void>;
-export declare const getSchemaMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => Promise<import("../matterbridgePlatform.js").PlatformSchema | undefined>>;
-export declare const setSchemaMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(schema: import("../matterbridgePlatform.js").PlatformSchema) => void>;
-export declare const wssSendRestartRequiredMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(snackbar?: boolean, fixed?: boolean) => void>;
-export declare const wssSendSnackbarMessageMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(message: string, timeout?: number, severity?: 'error' | 'success' | 'info' | 'warning') => void>;
-export declare const sizeMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => number>;
-export declare const getDevicesMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint[]>;
-export declare const getDeviceByNameMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(deviceName: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const getDeviceByUniqueIdMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(uniqueId: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const getDeviceBySerialNumberMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serialNumber: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const getDeviceByIdMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(id: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const getDeviceByOriginalIdMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(originalId: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const getDeviceByNumberMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(number: import("@matter/types").EndpointNumber | number) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const hasDeviceNameMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(deviceName: string) => boolean>;
-export declare const hasDeviceUniqueIdMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(deviceUniqueId: string) => boolean>;
-export declare const registerVirtualDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(name: string, type: 'light' | 'outlet' | 'switch' | 'mounted_switch', callback: () => Promise<void>) => Promise<boolean>>;
-export declare const registerDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>>;
-export declare const unregisterDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>>;
-export declare const unregisterAllDevicesMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(delay?: number) => Promise<void>>;
-export declare const saveSelectsMatterbridgePlatformSpy: import("jest-mock").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>>;
-export declare const setSelectDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serial: string, name: string, configUrl?: string, icon?: string, entities?: {
-    name: string;
-    description: string;
-    icon?: string;
-}[]) => void>;
-export declare const getSelectDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serial: string) => {
-    serial: string;
-    name: string;
-    configUrl?: string;
-    icon?: string;
-    entities?: {
-        name: string;
-        description: string;
-        icon?: string;
-    }[];
-} | undefined>;
-export declare const setSelectDeviceEntityMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serial: string, entityName: string, entityDescription: string, entityIcon?: string) => void>;
-export declare const getSelectDevicesMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => import("@matterbridge/types").ApiSelectDevice[]>;
-export declare const setSelectEntityMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(name: string, description: string, icon?: string) => void>;
-export declare const getSelectEntityMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(name: string) => {
-    name: string;
-    description: string;
-    icon?: string | undefined;
-} | undefined>;
-export declare const getSelectEntitiesMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => import("@matterbridge/types").ApiSelectEntity[]>;
-export declare const verifyMatterbridgeVersionMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(requiredVersion: string, destroy?: boolean) => boolean>;
-export declare const validateDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(device: string | string[], log?: boolean) => boolean>;
-export declare const validateEntityMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(device: string, entity: string, log?: boolean) => boolean>;
-export declare const clearEndpointNumbersMatterbridgePlatformSpy: import("jest-mock").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>;
+import { MatterbridgePlatform } from '../matterbridgePlatform.js';
+export declare const destroyMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.destroy>;
+export declare const onStartMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onStart>;
+export declare const onConfigureMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onConfigure>;
+export declare const onShutdownMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onShutdown>;
+export declare const onChangeLoggerLevelMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onChangeLoggerLevel>;
+export declare const onActionMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onAction>;
+export declare const onConfigChangedMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onConfigChanged>;
+export declare const saveConfigMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.saveConfig>;
+export declare const getSchemaMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSchema>;
+export declare const setSchemaMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.setSchema>;
+export declare const wssSendRestartRequiredMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.wssSendRestartRequired>;
+export declare const wssSendSnackbarMessageMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.wssSendSnackbarMessage>;
+export declare const sizeMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.size>;
+export declare const getDevicesMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDevices>;
+export declare const getDeviceByNameMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceByName>;
+export declare const getDeviceByUniqueIdMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceByUniqueId>;
+export declare const getDeviceBySerialNumberMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceBySerialNumber>;
+export declare const getDeviceByIdMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceById>;
+export declare const getDeviceByOriginalIdMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceByOriginalId>;
+export declare const getDeviceByNumberMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceByNumber>;
+export declare const hasDeviceNameMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.hasDeviceName>;
+export declare const hasDeviceUniqueIdMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.hasDeviceUniqueId>;
+export declare const registerVirtualDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.registerVirtualDevice>;
+export declare const registerDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.registerDevice>;
+export declare const unregisterDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.unregisterDevice>;
+export declare const unregisterAllDevicesMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.unregisterAllDevices>;
+export declare const saveSelectsMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.saveSelects>;
+export declare const clearSelectMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.clearSelect>;
+export declare const clearDeviceSelectMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.clearDeviceSelect>;
+export declare const clearEntitySelectMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.clearEntitySelect>;
+export declare const setSelectDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.setSelectDevice>;
+export declare const getSelectDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSelectDevice>;
+export declare const setSelectDeviceEntityMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.setSelectDeviceEntity>;
+export declare const getSelectDevicesMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSelectDevices>;
+export declare const setSelectEntityMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.setSelectEntity>;
+export declare const getSelectEntityMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSelectEntity>;
+export declare const getSelectEntitiesMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSelectEntities>;
+export declare const verifyMatterbridgeVersionMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.verifyMatterbridgeVersion>;
+export declare const validateDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.validateDevice>;
+export declare const validateEntityMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.validateEntity>;
+export declare const clearEndpointNumbersMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.clearEndpointNumbers>;
+export declare const checkEndpointNumbersMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.checkEndpointNumbers>;

package/dist/jestutils/jestMatterbridgePlatformSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { MatterbridgePlatform } from '../matterbridgePlatform.js';
+const { jest } = await import('@jest/globals');
 export const destroyMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'destroy');
 export const onStartMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onStart');
 export const onConfigureMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onConfigure');

package/dist/jestutils/jestMatterbridgeSpy.d.ts

@@ -1,4 +1,5 @@
-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>>;
+import { Matterbridge } from '../matterbridge.js';
+export declare const addBridgedEndpointMatterbridgeSpy: jest.SpiedFunction<typeof Matterbridge.prototype.addBridgedEndpoint>;
+export declare const removeBridgedEndpointMatterbridgeSpy: jest.SpiedFunction<typeof Matterbridge.prototype.removeBridgedEndpoint>;
+export declare const removeAllBridgedEndpointsMatterbridgeSpy: jest.SpiedFunction<typeof Matterbridge.prototype.removeAllBridgedEndpoints>;
+export declare const addVirtualEndpointMatterbridgeSpy: jest.SpiedFunction<typeof Matterbridge.prototype.addVirtualEndpoint>;

package/dist/jestutils/jestMatterbridgeSpy.js

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

package/dist/jestutils/jestPluginManagerSpy.d.ts

@@ -1,47 +1,40 @@
-export declare const destroyPluginSpy: import("jest-mock").SpiedFunction<() => void>;
-export declare const checkDependenciesPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, unknown> & {
-    name?: string;
-    dependencies?: string[] | Record<string, string>;
-    devDependencies?: string[] | Record<string, string>;
-    peerDependencies?: string[] | Record<string, string>;
-    optionalDependencies?: string[] | Record<string, string>;
-    bundledDependencies?: string[] | Record<string, string>;
-    bundleDependencies?: string[] | Record<string, string>;
-}) => boolean>;
-export declare const lengthPluginSpy: import("jest-mock").SpiedGetter<number>;
-export declare const sizePluginSpy: import("jest-mock").SpiedGetter<number>;
-export declare const hasPluginSpy: import("jest-mock").SpiedFunction<(name: string) => boolean>;
-export declare const getPluginSpy: import("jest-mock").SpiedFunction<(name: string) => import("../pluginManager.js").Plugin | undefined>;
-export declare const setPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin) => import("../pluginManager.js").Plugin>;
-export declare const clearPluginSpy: import("jest-mock").SpiedFunction<() => void>;
-export declare const arrayPluginSpy: import("jest-mock").SpiedFunction<() => import("../pluginManager.js").Plugin[]>;
-export declare const storagePluginArraySpy: import("jest-mock").SpiedFunction<() => import("@matterbridge/types").StoragePlugin[]>;
-export declare const apiPluginArraySpy: import("jest-mock").SpiedFunction<() => import("@matterbridge/types").ApiPlugin[]>;
-export declare const iteratorPluginSpy: import("jest-mock").SpiedFunction<() => MapIterator<import("../pluginManager.js").Plugin>>;
-export declare const forEachPluginSpy: import("jest-mock").SpiedFunction<(callback: (plugin: import("../pluginManager.js").Plugin) => Promise<void>) => Promise<void>>;
-export declare const logLevelPluginSpy: import("jest-mock").SpiedSetter<import("node-ansi-logger").LogLevel>;
-export declare const loadFromStoragePluginSpy: import("jest-mock").SpiedFunction<() => Promise<import("@matterbridge/types").StoragePlugin[]>>;
-export declare const saveToStoragePluginSpy: import("jest-mock").SpiedFunction<() => Promise<number>>;
-export declare const resolvePluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<string | null>>;
-export declare const installPluginSpy: import("jest-mock").SpiedFunction<(packageName: string) => void>;
-export declare const uninstallPluginSpy: import("jest-mock").SpiedFunction<(packageName: string) => void>;
-export declare const getAuthorPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string>;
-export declare const getDescriptionPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string>;
-export declare const getHomepagePluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string | undefined>;
-export declare const getHelpPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string | undefined>;
-export declare const getChangelogPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string | undefined>;
-export declare const getFundingPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, any>) => string | undefined>;
-export declare const parsePluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName) => Promise<Record<string, string | number | object> | null>>;
-export declare const addPluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<import("../pluginManager.js").Plugin | null>>;
-export declare const enablePluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<import("../pluginManager.js").Plugin | null>>;
-export declare const disablePluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<import("../pluginManager.js").Plugin | null>>;
-export declare const removePluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<import("../pluginManager.js").Plugin | null>>;
-export declare const loadPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName, start?: boolean, message?: string, configure?: boolean) => Promise<import("../matterbridgePlatform.js").MatterbridgePlatform | undefined>>;
-export declare const startPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName, message?: string, configure?: boolean) => Promise<import("../pluginManager.js").Plugin | undefined>>;
-export declare const configurePluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName) => Promise<import("../pluginManager.js").Plugin | undefined>>;
-export declare const shutdownPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName, reason?: string, removeAllDevices?: boolean, force?: boolean) => Promise<import("../pluginManager.js").Plugin | undefined>>;
-export declare const loadConfigPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin) => Promise<import("@matterbridge/types").PlatformConfig>>;
-export declare const saveConfigFromPluginPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin, restartRequired?: boolean) => Promise<void>>;
-export declare const saveConfigFromJsonPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin, config: import("@matterbridge/types").PlatformConfig, restartRequired?: boolean) => Promise<void>>;
-export declare const loadSchemaPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin) => Promise<import("@matterbridge/types").PlatformSchema>>;
-export declare const getDefaultSchemaPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin) => import("@matterbridge/types").PlatformSchema>;
+import { PluginManager } from '../pluginManager.js';
+export declare const destroyPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.destroy>;
+export declare const checkDependenciesPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.checkDependencies>;
+export declare const lengthPluginSpy: jest.SpiedGetter<typeof PluginManager.prototype.length>;
+export declare const sizePluginSpy: jest.SpiedGetter<typeof PluginManager.prototype.size>;
+export declare const hasPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.has>;
+export declare const getPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.get>;
+export declare const setPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.set>;
+export declare const clearPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.clear>;
+export declare const arrayPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.array>;
+export declare const storagePluginArraySpy: jest.SpiedFunction<typeof PluginManager.prototype.storagePluginArray>;
+export declare const apiPluginArraySpy: jest.SpiedFunction<typeof PluginManager.prototype.apiPluginArray>;
+export declare const iteratorPluginSpy: jest.SpiedFunction<(typeof PluginManager.prototype)[typeof Symbol.iterator]>;
+export declare const forEachPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.forEach>;
+export declare const logLevelPluginSpy: jest.SpiedSetter<typeof PluginManager.prototype.logLevel>;
+export declare const loadFromStoragePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.loadFromStorage>;
+export declare const saveToStoragePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.saveToStorage>;
+export declare const resolvePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.resolve>;
+export declare const installPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.install>;
+export declare const uninstallPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.uninstall>;
+export declare const getAuthorPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getAuthor>;
+export declare const getDescriptionPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getDescription>;
+export declare const getHomepagePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getHomepage>;
+export declare const getHelpPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getHelp>;
+export declare const getChangelogPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getChangelog>;
+export declare const getFundingPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getFunding>;
+export declare const parsePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.parse>;
+export declare const addPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.add>;
+export declare const enablePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.enable>;
+export declare const disablePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.disable>;
+export declare const removePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.remove>;
+export declare const loadPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.load>;
+export declare const startPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.start>;
+export declare const configurePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.configure>;
+export declare const shutdownPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.shutdown>;
+export declare const loadConfigPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.loadConfig>;
+export declare const saveConfigFromPluginPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.saveConfigFromPlugin>;
+export declare const saveConfigFromJsonPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.saveConfigFromJson>;
+export declare const loadSchemaPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.loadSchema>;
+export declare const getDefaultSchemaPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getDefaultSchema>;

package/dist/jestutils/jestPluginManagerSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { PluginManager } from '../pluginManager.js';
+const { jest } = await import('@jest/globals');
 export const destroyPluginSpy = jest.spyOn(PluginManager.prototype, 'destroy');
 export const checkDependenciesPluginSpy = jest.spyOn(PluginManager.prototype, 'checkDependencies');
 export const lengthPluginSpy = jest.spyOn(PluginManager.prototype, 'length', 'get');

package/dist/jestutils/jestSetupTest.d.ts

@@ -1,4 +1,3 @@
-import type { jest } from '@jest/globals';
 import { AnsiLogger } from 'node-ansi-logger';
 export declare const originalProcessArgv: readonly string[];
 export declare const originalProcessEnv: Readonly<Record<string, string | undefined>>;

package/dist/matterbridgeEndpointHelpers.d.ts

@@ -62,67 +62,67 @@ export declare function setCluster(endpoint: MatterbridgeEndpoint, cluster: Beha
 export declare function getCluster(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, log?: AnsiLogger): Record<string, boolean | number | bigint | string | object | undefined | null> | undefined;
 export declare function triggerEvent(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, event: string, payload: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: AnsiLogger): Promise<boolean>;
 export declare function getDefaultPowerSourceWiredClusterServer(wiredCurrentType?: PowerSource.WiredCurrentType): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<PowerSource, {
+    wired: true;
     battery: false;
     rechargeable: false;
     replaceable: false;
-    wired: true;
 }>, typeof MatterbridgePowerSourceServer>>;
 export declare function getDefaultPowerSourceBatteryClusterServer(batPercentRemaining?: null | number, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: null | number, batReplaceability?: PowerSource.BatReplaceability): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<PowerSource, {
+    wired: false;
     battery: true;
     rechargeable: false;
     replaceable: false;
-    wired: false;
 }>, typeof MatterbridgePowerSourceServer>>;
 export declare function getDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining?: number | null, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number | null, batReplacementDescription?: string, batQuantity?: number, batReplaceability?: PowerSource.BatReplaceability): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<PowerSource, {
+    wired: false;
     battery: true;
     rechargeable: false;
     replaceable: true;
-    wired: false;
 }>, typeof MatterbridgePowerSourceServer>>;
 export declare function getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining?: number | null, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number | null, batReplaceability?: PowerSource.BatReplaceability): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<PowerSource, {
+    wired: false;
     battery: true;
     rechargeable: true;
     replaceable: false;
-    wired: false;
 }>, typeof MatterbridgePowerSourceServer>>;
 export declare function getDefaultElectricalEnergyMeasurementClusterServer(energyImported?: number | bigint | null, energyExported?: number | bigint | null): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<ElectricalEnergyMeasurement, {
-    apparentEnergy: false;
-    cumulativeEnergy: true;
-    exportedEnergy: true;
     importedEnergy: true;
+    exportedEnergy: true;
+    cumulativeEnergy: true;
     periodicEnergy: false;
+    apparentEnergy: false;
     reactiveEnergy: false;
 }>, typeof ElectricalEnergyMeasurementServer>>;
 export declare function getDefaultElectricalPowerMeasurementClusterServer(voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, frequency?: number | bigint | null): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<ElectricalPowerMeasurement, {
-    alternatingCurrent: true;
     directCurrent: false;
-    harmonics: false;
+    alternatingCurrent: true;
     polyphasePower: false;
+    harmonics: false;
     powerQuality: false;
 }>, typeof ElectricalPowerMeasurementServer>>;
 export declare function getApparentElectricalPowerMeasurementClusterServer(voltage?: number | bigint | null, apparentCurrent?: number | bigint | null, apparentPower?: number | bigint | null, frequency?: number | bigint | null): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<ElectricalPowerMeasurement, {
-    alternatingCurrent: true;
     directCurrent: false;
-    harmonics: false;
+    alternatingCurrent: true;
     polyphasePower: false;
+    harmonics: false;
     powerQuality: false;
 }>, typeof ElectricalPowerMeasurementServer>>;
 export declare function getDefaultDeviceEnergyManagementClusterServer(esaType?: DeviceEnergyManagement.EsaType, esaCanGenerate?: boolean, esaState?: DeviceEnergyManagement.EsaState, absMinPower?: number, absMaxPower?: number): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<ClusterType.WithSupportedFeatures<DeviceEnergyManagement, {
-    constraintBasedAdjustment: false;
-    forecastAdjustment: false;
-    pausable: false;
     powerAdjustment: true;
     powerForecastReporting: true;
-    startTimeAdjustment: false;
     stateForecastReporting: false;
-}>, {
-    constraintBasedAdjustment: false;
-    forecastAdjustment: false;
+    startTimeAdjustment: false;
     pausable: false;
+    forecastAdjustment: false;
+    constraintBasedAdjustment: false;
+}>, {
     powerAdjustment: true;
     powerForecastReporting: true;
-    startTimeAdjustment: false;
     stateForecastReporting: false;
+    startTimeAdjustment: false;
+    pausable: false;
+    forecastAdjustment: false;
+    constraintBasedAdjustment: false;
 }>, typeof MatterbridgeDeviceEnergyManagementServer>>;
 export declare function getDefaultDeviceEnergyManagementModeClusterServer(currentMode?: number, supportedModes?: DeviceEnergyManagementMode.ModeOption[]): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<DeviceEnergyManagementMode, {
     onOff: false;
@@ -134,13 +134,13 @@ export declare function getDefaultPressureMeasurementClusterServer(measuredValue
 export declare function getDefaultIlluminanceMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<import("@matter/node").ClusterState.Type<IlluminanceMeasurement, typeof ClusterBehavior>>;
 export declare function getDefaultFlowMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<import("@matter/node").ClusterState.Type<FlowMeasurement, typeof ClusterBehavior>>;
 export declare function getDefaultOccupancySensingClusterServer(occupied?: boolean, holdTime?: number, holdTimeMin?: number, holdTimeMax?: number): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<OccupancySensing, {
-    activeInfrared: false;
     other: false;
     passiveInfrared: true;
+    ultrasonic: false;
     physicalContact: false;
+    activeInfrared: false;
     radar: false;
     rfSensing: false;
-    ultrasonic: false;
     vision: false;
 }>, typeof OccupancySensingServer>>;
 export declare function getDefaultSoilMeasurementClusterServer(soilMoistureMeasuredValue?: number | null, soilMoistureMeasurementLimits?: MeasurementAccuracy): Partial<import("@matter/node").ClusterState.Type<SoilMeasurement, typeof ClusterBehavior>>;

package/dist/matterbridgeEndpointHelpers.js

@@ -203,9 +203,8 @@ export async function internalFor(endpoint, cluster) {
         return undefined;
     }
     const supportedBehavior = endpoint.behaviors.supported[lowercaseFirstLetter(behaviorId)];
-    if (!supportedBehavior) {
+    if (!supportedBehavior)
         return undefined;
-    }
     return endpoint.act(() => endpoint.behaviors.internalsOf(supportedBehavior));
 }
 export function optionsFor(type, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.9.1-dev-20260614-89d7aeb",
+  "version": "3.9.1-dev-20260614-18d1a2e",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -130,10 +130,10 @@
   ],
   "dependencies": {
     "@matter/main": "0.17.2",
-    "@matterbridge/dgram": "3.9.1-dev-20260614-89d7aeb",
-    "@matterbridge/thread": "3.9.1-dev-20260614-89d7aeb",
-    "@matterbridge/types": "3.9.1-dev-20260614-89d7aeb",
-    "@matterbridge/utils": "3.9.1-dev-20260614-89d7aeb",
+    "@matterbridge/dgram": "3.9.1-dev-20260614-18d1a2e",
+    "@matterbridge/thread": "3.9.1-dev-20260614-18d1a2e",
+    "@matterbridge/types": "3.9.1-dev-20260614-18d1a2e",
+    "@matterbridge/utils": "3.9.1-dev-20260614-18d1a2e",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.5.2",