matterbridge 3.0.0-edge.2 → 3.0.0-edge.4

package/CHANGELOG.md

@@ -59,21 +59,25 @@ Modified clusters:
 - [doorLock]: Fixed supportedOperatingModes inverted bitmap (Thanks Apollon).
 - [DevicesIcon]: Fixed rendering of leak freeze and rain sensors.
 
-## [2.2.8] - 2025-04-08
+## [2.2.8] - 2025-04-10
 
 ### Added
 
-- [platform]: Added stack to errors messages.
+- [platform]: Added stack to error messages.
+- [endpoint]: Added createLevelControlClusterServer()
 - [endpoint]: Added createLevelTvocMeasurementClusterServer()
+- [frontend]: Added a restart button on the QRCode panel when the advertising for a not paired node is expired.
 
 ### Changed
 
 - [package]: Update dependencies.
 - [package]: Use node:https.
+- [endpoint]: Modified createOnOffClusterServer().
 
 ### Fixed
 
 - [homepage]: Fixed warning log for homepage property in package.json.
+- [DevicesIcon]: Fixed rendering of rain, freeze and leak sensors.
 
 <a href="https://www.buymeacoffee.com/luligugithub">
   <img src="bmc-button.svg" alt="Buy me a coffee" width="80">

package/dist/cluster/export.js

@@ -1,205 +1 @@
-import { ModeBase } from '@matter/main/clusters/mode-base';
-import { Attribute, BitFlag, ClusterRegistry, Command, Event, EventPriority, FixedAttribute, MutableCluster, OptionalAttribute, OptionalCommand, OptionalEvent, TlvArray, TlvEnum, TlvField, TlvNoArguments, TlvNullable, TlvObject, TlvOptionalField, TlvString, TlvUInt32, TlvUInt8, TlvVendorId, WritableAttribute, } from '@matter/main/types';
-import { OperationalState as OperationalStateNamespace } from '@matter/main/clusters/operational-state';
-export var RvcRunMode;
-(function (RvcRunMode) {
-    let Feature;
-    (function (Feature) {
-        Feature["OnOff"] = "OnOff";
-    })(Feature = RvcRunMode.Feature || (RvcRunMode.Feature = {}));
-    let ModeTag;
-    (function (ModeTag) {
-        ModeTag[ModeTag["Auto"] = 0] = "Auto";
-        ModeTag[ModeTag["Quick"] = 1] = "Quick";
-        ModeTag[ModeTag["Quiet"] = 2] = "Quiet";
-        ModeTag[ModeTag["LowNoise"] = 3] = "LowNoise";
-        ModeTag[ModeTag["LowEnergy"] = 4] = "LowEnergy";
-        ModeTag[ModeTag["Vacation"] = 5] = "Vacation";
-        ModeTag[ModeTag["Min"] = 6] = "Min";
-        ModeTag[ModeTag["Max"] = 7] = "Max";
-        ModeTag[ModeTag["Night"] = 8] = "Night";
-        ModeTag[ModeTag["Day"] = 9] = "Day";
-        ModeTag[ModeTag["Idle"] = 16384] = "Idle";
-        ModeTag[ModeTag["Cleaning"] = 16385] = "Cleaning";
-        ModeTag[ModeTag["Mapping"] = 16386] = "Mapping";
-    })(ModeTag = RvcRunMode.ModeTag || (RvcRunMode.ModeTag = {}));
-    RvcRunMode.TlvModeTagStruct = TlvObject({
-        mfgCode: TlvOptionalField(0, TlvVendorId),
-        value: TlvField(1, TlvEnum()),
-    });
-    RvcRunMode.TlvModeOption = TlvObject({
-        label: TlvField(0, TlvString.bound({ maxLength: 64 })),
-        mode: TlvField(1, TlvUInt8),
-        modeTags: TlvField(2, TlvArray(RvcRunMode.TlvModeTagStruct, { maxLength: 8 })),
-    });
-    let ModeChangeStatus;
-    (function (ModeChangeStatus) {
-        ModeChangeStatus[ModeChangeStatus["Stuck"] = 65] = "Stuck";
-        ModeChangeStatus[ModeChangeStatus["DustBinMissing"] = 66] = "DustBinMissing";
-        ModeChangeStatus[ModeChangeStatus["DustBinFull"] = 67] = "DustBinFull";
-        ModeChangeStatus[ModeChangeStatus["WaterTankEmpty"] = 68] = "WaterTankEmpty";
-        ModeChangeStatus[ModeChangeStatus["WaterTankMissing"] = 69] = "WaterTankMissing";
-        ModeChangeStatus[ModeChangeStatus["WaterTankLidOpen"] = 70] = "WaterTankLidOpen";
-        ModeChangeStatus[ModeChangeStatus["MopCleaningPadMissing"] = 71] = "MopCleaningPadMissing";
-        ModeChangeStatus[ModeChangeStatus["BatteryLow"] = 72] = "BatteryLow";
-    })(ModeChangeStatus = RvcRunMode.ModeChangeStatus || (RvcRunMode.ModeChangeStatus = {}));
-    RvcRunMode.OnOffComponent = MutableCluster.Component({
-        attributes: {
-            startUpMode: WritableAttribute(0x2, TlvNullable(TlvUInt8), { persistent: true }),
-            onMode: WritableAttribute(0x3, TlvNullable(TlvUInt8), { persistent: true, default: null }),
-        },
-    });
-    RvcRunMode.Base = MutableCluster.Component({
-        id: 0x54,
-        name: 'RvcRunMode',
-        revision: 3,
-        features: {
-            onOff: BitFlag(0),
-        },
-        attributes: {
-            supportedModes: FixedAttribute(0x0, TlvArray(RvcRunMode.TlvModeOption, { minLength: 2, maxLength: 255 }), { default: [] }),
-            currentMode: Attribute(0x1, TlvUInt8, { persistent: true }),
-        },
-        commands: {
-            changeToMode: Command(0x0, ModeBase.TlvChangeToModeRequest, 0x1, ModeBase.TlvChangeToModeResponse),
-        },
-        extensions: MutableCluster.Extensions({ flags: { onOff: true }, component: RvcRunMode.OnOffComponent }),
-    });
-    RvcRunMode.ClusterInstance = MutableCluster(RvcRunMode.Base);
-    RvcRunMode.Cluster = RvcRunMode.ClusterInstance;
-    RvcRunMode.Complete = RvcRunMode.Cluster;
-})(RvcRunMode || (RvcRunMode = {}));
-export const RvcRunModeCluster = RvcRunMode.Cluster;
-ClusterRegistry.register(RvcRunMode.Complete);
-export var RvcCleanMode;
-(function (RvcCleanMode) {
-    let Feature;
-    (function (Feature) {
-        Feature["OnOff"] = "OnOff";
-    })(Feature = RvcCleanMode.Feature || (RvcCleanMode.Feature = {}));
-    let ModeTag;
-    (function (ModeTag) {
-        ModeTag[ModeTag["Auto"] = 0] = "Auto";
-        ModeTag[ModeTag["Quick"] = 1] = "Quick";
-        ModeTag[ModeTag["Quiet"] = 2] = "Quiet";
-        ModeTag[ModeTag["LowNoise"] = 3] = "LowNoise";
-        ModeTag[ModeTag["LowEnergy"] = 4] = "LowEnergy";
-        ModeTag[ModeTag["Vacation"] = 5] = "Vacation";
-        ModeTag[ModeTag["Min"] = 6] = "Min";
-        ModeTag[ModeTag["Max"] = 7] = "Max";
-        ModeTag[ModeTag["Night"] = 8] = "Night";
-        ModeTag[ModeTag["Day"] = 9] = "Day";
-        ModeTag[ModeTag["DeepClean"] = 16384] = "DeepClean";
-        ModeTag[ModeTag["Vacuum"] = 16385] = "Vacuum";
-        ModeTag[ModeTag["Mop"] = 16386] = "Mop";
-    })(ModeTag = RvcCleanMode.ModeTag || (RvcCleanMode.ModeTag = {}));
-    RvcCleanMode.TlvModeTagStruct = TlvObject({
-        mfgCode: TlvOptionalField(0, TlvVendorId),
-        value: TlvField(1, TlvEnum()),
-    });
-    RvcCleanMode.TlvModeOption = TlvObject({
-        label: TlvField(0, TlvString.bound({ maxLength: 64 })),
-        mode: TlvField(1, TlvUInt8),
-        modeTags: TlvField(2, TlvArray(RvcCleanMode.TlvModeTagStruct, { maxLength: 8 })),
-    });
-    let ModeChangeStatus;
-    (function (ModeChangeStatus) {
-        ModeChangeStatus[ModeChangeStatus["CleaningInProgress"] = 64] = "CleaningInProgress";
-    })(ModeChangeStatus = RvcCleanMode.ModeChangeStatus || (RvcCleanMode.ModeChangeStatus = {}));
-    RvcCleanMode.OnOffComponent = MutableCluster.Component({
-        attributes: {
-            startUpMode: WritableAttribute(0x2, TlvNullable(TlvUInt8), { persistent: true }),
-            onMode: WritableAttribute(0x3, TlvNullable(TlvUInt8), { persistent: true, default: null }),
-        },
-    });
-    RvcCleanMode.Base = MutableCluster.Component({
-        id: 0x55,
-        name: 'RvcCleanMode',
-        revision: 3,
-        features: {
-            onOff: BitFlag(0),
-        },
-        attributes: {
-            supportedModes: FixedAttribute(0x0, TlvArray(RvcCleanMode.TlvModeOption, { minLength: 2, maxLength: 255 }), { default: [] }),
-            currentMode: Attribute(0x1, TlvUInt8, { persistent: true }),
-        },
-        commands: {
-            changeToMode: Command(0x0, ModeBase.TlvChangeToModeRequest, 0x1, ModeBase.TlvChangeToModeResponse),
-        },
-        extensions: MutableCluster.Extensions({ flags: { onOff: true }, component: RvcCleanMode.OnOffComponent }),
-    });
-    RvcCleanMode.ClusterInstance = MutableCluster(RvcCleanMode.Base);
-    RvcCleanMode.Cluster = RvcCleanMode.ClusterInstance;
-    RvcCleanMode.Complete = RvcCleanMode.Cluster;
-})(RvcCleanMode || (RvcCleanMode = {}));
-export const RvcCleanModeCluster = RvcCleanMode.Cluster;
-ClusterRegistry.register(RvcCleanMode.Complete);
-export var RvcOperationalState;
-(function (RvcOperationalState) {
-    let OperationalState;
-    (function (OperationalState) {
-        OperationalState[OperationalState["Stopped"] = 0] = "Stopped";
-        OperationalState[OperationalState["Running"] = 1] = "Running";
-        OperationalState[OperationalState["Paused"] = 2] = "Paused";
-        OperationalState[OperationalState["Error"] = 3] = "Error";
-        OperationalState[OperationalState["SeekingCharger"] = 64] = "SeekingCharger";
-        OperationalState[OperationalState["Charging"] = 65] = "Charging";
-        OperationalState[OperationalState["Docked"] = 66] = "Docked";
-    })(OperationalState = RvcOperationalState.OperationalState || (RvcOperationalState.OperationalState = {}));
-    RvcOperationalState.TlvOperationalStateStruct = TlvObject({
-        operationalStateId: TlvField(0, TlvEnum()),
-        operationalStateLabel: TlvOptionalField(1, TlvString.bound({ maxLength: 64 })),
-    });
-    let ErrorState;
-    (function (ErrorState) {
-        ErrorState[ErrorState["NoError"] = 0] = "NoError";
-        ErrorState[ErrorState["UnableToStartOrResume"] = 1] = "UnableToStartOrResume";
-        ErrorState[ErrorState["UnableToCompleteOperation"] = 2] = "UnableToCompleteOperation";
-        ErrorState[ErrorState["CommandInvalidInState"] = 3] = "CommandInvalidInState";
-        ErrorState[ErrorState["FailedToFindChargingDock"] = 64] = "FailedToFindChargingDock";
-        ErrorState[ErrorState["Stuck"] = 65] = "Stuck";
-        ErrorState[ErrorState["DustBinMissing"] = 66] = "DustBinMissing";
-        ErrorState[ErrorState["DustBinFull"] = 67] = "DustBinFull";
-        ErrorState[ErrorState["WaterTankEmpty"] = 68] = "WaterTankEmpty";
-        ErrorState[ErrorState["WaterTankMissing"] = 69] = "WaterTankMissing";
-        ErrorState[ErrorState["WaterTankLidOpen"] = 70] = "WaterTankLidOpen";
-        ErrorState[ErrorState["MopCleaningPadMissing"] = 71] = "MopCleaningPadMissing";
-    })(ErrorState = RvcOperationalState.ErrorState || (RvcOperationalState.ErrorState = {}));
-    RvcOperationalState.TlvErrorStateStruct = TlvObject({
-        errorStateId: TlvField(0, TlvEnum()),
-        errorStateLabel: TlvOptionalField(1, TlvString.bound({ maxLength: 64 })),
-        errorStateDetails: TlvOptionalField(2, TlvString.bound({ maxLength: 64 })),
-    });
-    RvcOperationalState.TlvOperationalCommandResponse = TlvObject({
-        commandResponseState: TlvField(0, RvcOperationalState.TlvErrorStateStruct),
-    });
-    RvcOperationalState.TlvOperationalErrorEvent = TlvObject({ errorState: TlvField(0, RvcOperationalState.TlvErrorStateStruct) });
-    RvcOperationalState.ClusterInstance = MutableCluster({
-        id: 0x61,
-        name: 'RvcOperationalState',
-        revision: 2,
-        attributes: {
-            phaseList: Attribute(0x0, TlvNullable(TlvArray(TlvString, { maxLength: 32 }))),
-            currentPhase: Attribute(0x1, TlvNullable(TlvUInt8)),
-            countdownTime: OptionalAttribute(0x2, TlvNullable(TlvUInt32.bound({ max: 259200 })), { default: null }),
-            operationalStateList: Attribute(0x3, TlvArray(RvcOperationalState.TlvOperationalStateStruct), { default: [] }),
-            operationalState: Attribute(0x4, TlvEnum()),
-            operationalError: Attribute(0x5, RvcOperationalState.TlvErrorStateStruct),
-        },
-        commands: {
-            pause: OptionalCommand(0x0, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
-            stop: OptionalCommand(0x1, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
-            start: OptionalCommand(0x2, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
-            resume: OptionalCommand(0x3, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
-            goHome: OptionalCommand(0x80, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
-        },
-        events: {
-            operationalError: Event(0x0, EventPriority.Critical, RvcOperationalState.TlvOperationalErrorEvent),
-            operationCompletion: OptionalEvent(0x1, EventPriority.Info, OperationalStateNamespace.TlvOperationCompletionEvent),
-        },
-    });
-    RvcOperationalState.Cluster = RvcOperationalState.ClusterInstance;
-    RvcOperationalState.Complete = RvcOperationalState.Cluster;
-})(RvcOperationalState || (RvcOperationalState = {}));
-export const RvcOperationalStateCluster = RvcOperationalState.Cluster;
-ClusterRegistry.register(RvcOperationalState.Complete);
+export {};

package/dist/matterbridge.js

@@ -1728,12 +1728,14 @@ export class Matterbridge extends EventEmitter {
         this.devices.remove(device);
     }
     async removeAllBridgedEndpoints(pluginName, delay = 0) {
-        this.log.debug(`Removing all bridged endpoints for plugin ${plg}${pluginName}${db}`);
+        this.log.debug(`Removing all bridged endpoints for plugin ${plg}${pluginName}${db}${delay > 0 ? ` with delay ${delay} ms` : ''}`);
         for (const device of this.devices.array().filter((device) => device.plugin === pluginName)) {
             await this.removeBridgedEndpoint(pluginName, device);
             if (delay > 0)
                 await new Promise((resolve) => setTimeout(resolve, delay));
         }
+        if (delay > 0)
+            await new Promise((resolve) => setTimeout(resolve, delay * 2));
     }
     async subscribeAttributeChanged(plugin, device) {
         this.log.info(`Subscribing attributes for endpoint ${dev}${device.deviceName}${nf} (${dev}${device.id}${nf}) plugin ${plg}${plugin.name}${nf}`);

package/dist/matterbridgeBehaviors.js

@@ -1,5 +1,4 @@
-import { Behavior, ClusterBehavior } from '@matter/main';
-import { Status } from '@matter/main/types';
+import { Behavior } from '@matter/main';
 import { BooleanStateConfiguration } from '@matter/main/clusters/boolean-state-configuration';
 import { ColorControl } from '@matter/main/clusters/color-control';
 import { FanControl } from '@matter/main/clusters/fan-control';
@@ -20,11 +19,7 @@ import { ValveConfigurationAndControlBehavior } from '@matter/main/behaviors/val
 import { ModeSelectServer } from '@matter/main/behaviors/mode-select';
 import { SmokeCoAlarmServer } from '@matter/main/behaviors/smoke-co-alarm';
 import { SwitchServer } from '@matter/main/behaviors/switch';
-import { RvcCleanMode } from 'matterbridge/cluster';
-import { RvcRunMode } from 'matterbridge/cluster';
-import { RvcOperationalState } from 'matterbridge/cluster';
-import { OperationalState } from '@matter/main/clusters/operational-state';
-export class MatterbridgeBehaviorDevice {
+export class MatterbridgeServerDevice {
     log;
     commandHandler;
     device;
@@ -146,107 +141,107 @@ export class MatterbridgeBehaviorDevice {
         this.commandHandler.executeHandler('enableDisableAlarm', { request: { alarmsToEnableDisable }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
     }
 }
-export class MatterbridgeBehavior extends Behavior {
+export class MatterbridgeServer extends Behavior {
     static id = 'matterbridge';
 }
-(function (MatterbridgeBehavior) {
+(function (MatterbridgeServer) {
     class State {
         deviceCommand;
     }
-    MatterbridgeBehavior.State = State;
-})(MatterbridgeBehavior || (MatterbridgeBehavior = {}));
+    MatterbridgeServer.State = State;
+})(MatterbridgeServer || (MatterbridgeServer = {}));
 export class MatterbridgeIdentifyServer extends IdentifyServer {
     initialize() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.setEndpointId(this.endpoint.maybeId);
         device.setEndpointNumber(this.endpoint.maybeNumber);
         super.initialize();
     }
     identify({ identifyTime }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.identify({ identifyTime });
         super.identify({ identifyTime });
     }
     triggerEffect({ effectIdentifier, effectVariant }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.triggerEffect({ effectIdentifier, effectVariant });
         super.triggerEffect({ effectIdentifier, effectVariant });
     }
 }
 export class MatterbridgeOnOffServer extends OnOffServer {
     async on() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.on();
         super.on();
     }
     async off() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.off();
         super.off();
     }
     async toggle() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.toggle();
         super.toggle();
     }
 }
 export class MatterbridgeLevelControlServer extends LevelControlServer {
     async moveToLevel({ level, transitionTime, optionsMask, optionsOverride }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToLevel({ level, transitionTime, optionsMask, optionsOverride });
         super.moveToLevel({ level, transitionTime, optionsMask, optionsOverride });
     }
     async moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride });
         super.moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride });
     }
 }
 export class MatterbridgeColorControlServer extends ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature) {
     async moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime });
         super.moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime });
     }
     async moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime });
         super.moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime });
     }
     async moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime });
         super.moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime });
     }
     async moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime });
         super.moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime });
     }
     async moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime });
         super.moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime });
     }
 }
 export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift) {
     async upOrOpen() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.upOrOpen();
         super.upOrOpen();
     }
     async downOrClose() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.downOrClose();
         super.downOrClose();
     }
     stopMotion() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.stopMotion();
         super.stopMotion();
     }
     goToLiftPercentage({ liftPercent100thsValue }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.goToLiftPercentage({ liftPercent100thsValue });
         super.goToLiftPercentage({ liftPercent100thsValue });
     }
@@ -255,26 +250,26 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
 }
 export class MatterbridgeDoorLockServer extends DoorLockServer {
     async lockDoor() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.lockDoor();
         super.lockDoor();
     }
     async unlockDoor() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.unlockDoor();
         super.unlockDoor();
     }
 }
 export class MatterbridgeModeSelectServer extends ModeSelectServer {
     async changeToMode({ newMode }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.changeToMode({ newMode });
         super.changeToMode({ newMode });
     }
 }
 export class MatterbridgeFanControlServer extends FanControlServer.with(FanControl.Feature.MultiSpeed, FanControl.Feature.Auto, FanControl.Feature.Step) {
     async step({ direction, wrap, lowestOff }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.step({ direction, wrap, lowestOff });
         const lookupStepDirection = ['Increase', 'Decrease'];
         device.log.debug(`Command step called with direction: ${lookupStepDirection[direction]} wrap: ${wrap} lowestOff: ${lowestOff}`);
@@ -299,7 +294,7 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
 }
 export class MatterbridgeThermostatServer extends ThermostatBehavior.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode) {
     async setpointRaiseLower({ mode, amount }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.setpointRaiseLower({ mode, amount });
         const lookupSetpointAdjustMode = ['Heat', 'Cool', 'Both'];
         device.log.debug(`Command setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[mode]} amount: ${amount / 10}`);
@@ -321,14 +316,14 @@ export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigu
     initialize() {
     }
     open({ openDuration, targetLevel }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.log.debug(`Command open called with openDuration: ${openDuration} targetLevel: ${targetLevel}`);
         device.open({ openDuration, targetLevel });
         this.state.targetLevel = targetLevel ?? 100;
         this.state.currentLevel = targetLevel ?? 100;
     }
     close() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.log.debug(`Command close called`);
         device.close();
         this.state.targetLevel = 0;
@@ -337,14 +332,14 @@ export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigu
 }
 export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(SmokeCoAlarm.Feature.SmokeAlarm, SmokeCoAlarm.Feature.CoAlarm) {
     async selfTestRequest() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.selfTestRequest();
         super.selfTestRequest();
     }
 }
 export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.SensitivityLevel) {
     async enableDisableAlarm({ alarmsToEnableDisable }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.enableDisableAlarm({ alarmsToEnableDisable });
         super.enableDisableAlarm({ alarmsToEnableDisable });
     }
@@ -353,71 +348,3 @@ export class MatterbridgeSwitchServer extends SwitchServer {
     initialize() {
     }
 }
-export const RvcRunModeBehavior = ClusterBehavior.withInterface().for(RvcRunMode.Cluster);
-export class MatterbridgeRvcRunModeServer extends RvcRunModeBehavior.with(RvcRunMode.Feature.OnOff) {
-    initialize() {
-    }
-    changeToMode({ newMode }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
-        device.changeToMode({ newMode });
-        this.state.currentMode = newMode;
-        console.log('MatterbridgeRvcRunModeServer changeToMode called with newMode:', newMode);
-        return { status: Status.Success, statusText: 'Success' };
-    }
-}
-export const RvcCleanModeBehavior = ClusterBehavior.withInterface().for(RvcCleanMode.Cluster);
-export class MatterbridgeRvcCleanModeServer extends RvcCleanModeBehavior.with(RvcRunMode.Feature.OnOff) {
-    initialize() {
-    }
-    changeToMode({ newMode }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
-        device.changeToMode({ newMode });
-        this.state.currentMode = newMode;
-        console.log('MatterbridgeRvcCleanModeServer changeToMode called with newMode:', newMode);
-        return { status: Status.Success, statusText: 'Success' };
-    }
-}
-export const RvcOperationalStateBehavior = ClusterBehavior.withInterface().for(RvcOperationalState.Cluster);
-export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateBehavior {
-    initialize() {
-        console.log('MatterbridgeRvcOperationalStateServer initialized: setting operational state to Docked');
-        this.state.operationalState = RvcOperationalState.OperationalState.Docked;
-        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error' };
-        this.reactTo(this.agent.get(OnOffServer).events.onOff$Changed, this.handleOnOffChange);
-    }
-    handleOnOffChange(onOff) {
-        if (onOff) {
-            console.log('OnOffServer changed to ON: setting operational state to Running');
-            this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2;
-            this.state.operationalState = RvcOperationalState.OperationalState.Running;
-            this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error' };
-        }
-        else {
-            console.log('OnOffServer changed to OFF: setting operational state to Docked');
-            this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
-            this.state.operationalState = RvcOperationalState.OperationalState.Docked;
-            this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error' };
-        }
-    }
-    pause() {
-        console.log('MatterbridgeRvcOperationalStateServer: pause called setting operational state to Paused and currentMode to Idle');
-        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
-        this.state.operationalState = RvcOperationalState.OperationalState.Paused;
-        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error' };
-        return { commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error' } };
-    }
-    resume() {
-        console.log('MatterbridgeRvcOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
-        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2;
-        this.state.operationalState = RvcOperationalState.OperationalState.Running;
-        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error' };
-        return { commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error' } };
-    }
-    goHome() {
-        console.log('MatterbridgeRvcOperationalStateServer: go home called setting operational state to Docked and currentMode to Idle');
-        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
-        this.state.operationalState = RvcOperationalState.OperationalState.Docked;
-        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error' };
-        return { commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error' } };
-    }
-}

package/dist/matterbridgeDeviceTypes.js

@@ -44,41 +44,35 @@ import { EnergyPreference } from '@matter/main/clusters/energy-preference';
 import { RvcRunMode } from '@matter/main/clusters/rvc-run-mode';
 import { RvcOperationalState } from '@matter/main/clusters/rvc-operational-state';
 import { RvcCleanMode } from '@matter/main/clusters/rvc-clean-mode';
-import { ScenesManagement } from '@matter/main/clusters/scenes-management';
 import { HepaFilterMonitoring } from '@matter/main/clusters/hepa-filter-monitoring';
 import { ActivatedCarbonFilterMonitoring } from '@matter/main/clusters/activated-carbon-filter-monitoring';
 import { DeviceEnergyManagementMode } from '@matter/main/clusters/device-energy-management-mode';
 import { AdministratorCommissioning } from '@matter/main/clusters/administrator-commissioning';
 import { EcosystemInformation } from '@matter/main/clusters/ecosystem-information';
-import { AccessControl } from '@matter/main/clusters/access-control';
 import { CommissionerControl } from '@matter/main/clusters/commissioner-control';
 import { ServiceArea } from '@matter/main/clusters';
 export var DeviceClasses;
 (function (DeviceClasses) {
     DeviceClasses["Node"] = "Node";
-    DeviceClasses["Utility"] = "Utility";
     DeviceClasses["App"] = "App";
+    DeviceClasses["Utility"] = "Utility";
     DeviceClasses["Simple"] = "Simple";
     DeviceClasses["Dynamic"] = "Dynamic";
     DeviceClasses["Client"] = "Client";
     DeviceClasses["Server"] = "Server";
     DeviceClasses["Composed"] = "Composed";
-    DeviceClasses["Multiple"] = "Multiple";
-    DeviceClasses["EZInitiator"] = "EZ-Initiator";
-    DeviceClasses["EZTarget"] = "EZ-Target";
+    DeviceClasses["Duplicate"] = "Duplicate";
     DeviceClasses["BridgedPowerSourceInfo"] = "BridgedPowerSourceInfo";
 })(DeviceClasses || (DeviceClasses = {}));
-export const DeviceTypeDefinition = ({ name, code, deviceClass, superSet, revision, requiredServerClusters = [], optionalServerClusters = [], requiredClientClusters = [], optionalClientClusters = [], unknown = false, }) => ({
+export const DeviceTypeDefinition = ({ name, code, deviceClass, revision, requiredServerClusters = [], optionalServerClusters = [], requiredClientClusters = [], optionalClientClusters = [], }) => ({
     name,
     code: DeviceTypeId(code),
     deviceClass,
-    superSet,
     revision,
     requiredServerClusters,
     optionalServerClusters,
     requiredClientClusters,
     optionalClientClusters,
-    unknown,
 });
 export const powerSource = DeviceTypeDefinition({
     name: 'MA-powerSource',
@@ -182,7 +176,7 @@ export const pumpDevice = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [OnOff.Cluster.id, PumpConfigurationAndControl.Cluster.id, Identify.Cluster.id],
-    optionalServerClusters: [LevelControl.Cluster.id, Groups.Cluster.id, ScenesManagement.Cluster.id, TemperatureMeasurement.Cluster.id, PressureMeasurement.Cluster.id, FlowMeasurement.Cluster.id],
+    optionalServerClusters: [LevelControl.Cluster.id, Groups.Cluster.id, TemperatureMeasurement.Cluster.id, PressureMeasurement.Cluster.id, FlowMeasurement.Cluster.id],
 });
 export const waterValve = DeviceTypeDefinition({
     name: 'MA-waterValve',
@@ -198,7 +192,7 @@ export const onOffSwitch = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [Identify.Cluster.id, OnOff.Cluster.id],
-    optionalServerClusters: [Groups.Cluster.id, ScenesManagement.Cluster.id],
+    optionalServerClusters: [Groups.Cluster.id],
 });
 export const dimmableSwitch = DeviceTypeDefinition({
     name: 'MA-dimmableswitch',
@@ -206,7 +200,7 @@ export const dimmableSwitch = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [Identify.Cluster.id, OnOff.Cluster.id, LevelControl.Cluster.id],
-    optionalServerClusters: [Groups.Cluster.id, ScenesManagement.Cluster.id],
+    optionalServerClusters: [Groups.Cluster.id],
 });
 export const colorTemperatureSwitch = DeviceTypeDefinition({
     name: 'MA-colortemperatureswitch',
@@ -214,7 +208,7 @@ export const colorTemperatureSwitch = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [Identify.Cluster.id, Groups.Cluster.id, OnOff.Cluster.id, LevelControl.Cluster.id, ColorControl.Cluster.id],
-    optionalServerClusters: [Groups.Cluster.id, ScenesManagement.Cluster.id],
+    optionalServerClusters: [Groups.Cluster.id],
 });
 export const genericSwitch = DeviceTypeDefinition({
     name: 'MA-genericswitch',
@@ -333,7 +327,7 @@ export const doorLockDevice = DeviceTypeDefinition({
     code: 0xa,
     deviceClass: DeviceClasses.Simple,
     revision: 3,
-    requiredServerClusters: [Identify.Cluster.id, DoorLock.Cluster.id, AccessControl.Cluster.id],
+    requiredServerClusters: [Identify.Cluster.id, DoorLock.Cluster.id],
     optionalServerClusters: [],
 });
 export const coverDevice = DeviceTypeDefinition({
@@ -398,5 +392,5 @@ export const airConditioner = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 2,
     requiredServerClusters: [Identify.Cluster.id, OnOff.Cluster.id, Thermostat.Cluster.id],
-    optionalServerClusters: [Groups.Cluster.id, ScenesManagement.Cluster.id, FanControl.Cluster.id, ThermostatUserInterfaceConfiguration.Cluster.id, TemperatureMeasurement.Cluster.id, RelativeHumidityMeasurement.Cluster.id],
+    optionalServerClusters: [Groups.Cluster.id, FanControl.Cluster.id, ThermostatUserInterfaceConfiguration.Cluster.id, TemperatureMeasurement.Cluster.id, RelativeHumidityMeasurement.Cluster.id],
 });