@matterbridge/core 3.10.8-dev-20260902-361500d → 3.10.8-dev-20260903-014e30e

package/dist/behaviors/export.d.ts

@@ -19,6 +19,8 @@ export * from './pumpConfigurationAndControlServer.js';
 export * from './serviceAreaServer.js';
 export * from './smokeCoAlarmServer.js';
 export * from './switchServer.js';
+export * from './temperatureAlarmServer.js';
 export * from './thermostatServer.js';
 export * from './valveConfigurationAndControlServer.js';
+export * from './waterTankLevelMonitoringServer.js';
 export * from './windowCoveringServer.js';

package/dist/behaviors/export.js

@@ -19,6 +19,8 @@ export * from './pumpConfigurationAndControlServer.js';
 export * from './serviceAreaServer.js';
 export * from './smokeCoAlarmServer.js';
 export * from './switchServer.js';
+export * from './temperatureAlarmServer.js';
 export * from './thermostatServer.js';
 export * from './valveConfigurationAndControlServer.js';
+export * from './waterTankLevelMonitoringServer.js';
 export * from './windowCoveringServer.js';

package/dist/behaviors/temperatureAlarmServer.d.ts

@@ -0,0 +1,26 @@
+import type { MaybePromise } from '@matter/general';
+import { TemperatureAlarmServer } from '@matter/node/behaviors/temperature-alarm';
+import { TemperatureAlarm } from '@matter/types/clusters/temperature-alarm';
+declare class TemperatureAlarmBaseServer extends TemperatureAlarmServer {
+    static readonly schema: import("@matter/model").ClusterModel;
+}
+declare const MatterbridgeTemperatureAlarmServer_base: import("@matter/node").ClusterBehavior.Type<typeof TemperatureAlarmBaseServer, import("@matter/types").ClusterType.WithSupportedFeatures<TemperatureAlarm, {
+    majorThreshold: false;
+    minorThreshold: false;
+    overCriticalAdjustable: false;
+    overMajorAdjustable: false;
+    overMinorAdjustable: false;
+    overTemperature: true;
+    reset: true;
+    underCriticalAdjustable: false;
+    underMajorAdjustable: false;
+    underMinorAdjustable: false;
+    underTemperature: true;
+}>, import("@matter/types").ClusterType.Concrete, new () => {}, "temperatureAlarm">;
+export declare class MatterbridgeTemperatureAlarmServer extends MatterbridgeTemperatureAlarmServer_base {
+    #private;
+    initialize(): MaybePromise;
+    reset(request: TemperatureAlarm.ResetRequest): Promise<void>;
+    modifyEnabledAlarms(request: TemperatureAlarm.ModifyEnabledAlarmsRequest): Promise<void>;
+}
+export {};

package/dist/behaviors/temperatureAlarmServer.js

@@ -0,0 +1,96 @@
+import { AttributeElement, CommandElement, EventElement, FieldElement } from '@matter/model';
+import { TemperatureAlarmServer } from '@matter/node/behaviors/temperature-alarm';
+import { Status, StatusResponseError } from '@matter/types';
+import { TemperatureAlarm } from '@matter/types/clusters/temperature-alarm';
+import { debugStringify, nf } from 'node-ansi-logger';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+const MatterbridgeTemperatureAlarmSchema = TemperatureAlarmServer.schema.extend({}, AttributeElement({ name: 'Mask', id: 0x0000, type: 'AlarmBitmap', access: 'R V', conformance: 'M' }), AttributeElement({ name: 'Latch', id: 0x0001, type: 'AlarmBitmap', access: 'R V', conformance: 'RESET', quality: 'F' }), AttributeElement({ name: 'State', id: 0x0002, type: 'AlarmBitmap', access: 'R V', conformance: 'M' }), AttributeElement({ name: 'Supported', id: 0x0003, type: 'AlarmBitmap', access: 'R V', conformance: 'M', quality: 'F' }), CommandElement({ name: 'Reset', id: 0x0000, access: 'O', conformance: 'RESET', direction: 'request', response: 'status' }, FieldElement({ name: 'Alarms', id: 0x0000, type: 'AlarmBitmap', conformance: 'M' })), CommandElement({ name: 'ModifyEnabledAlarms', id: 0x0001, access: 'O', conformance: 'O', direction: 'request', response: 'status' }, FieldElement({ name: 'Mask', id: 0x0000, type: 'AlarmBitmap', conformance: 'M' })), EventElement({ name: 'Notify', id: 0x0000, access: 'V', conformance: 'M', priority: 'info' }, FieldElement({ name: 'Active', id: 0x0000, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'Inactive', id: 0x0001, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'State', id: 0x0002, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'Mask', id: 0x0003, type: 'AlarmBitmap', conformance: 'M' })));
+class TemperatureAlarmBaseServer extends TemperatureAlarmServer {
+    static schema = MatterbridgeTemperatureAlarmSchema;
+}
+export class MatterbridgeTemperatureAlarmServer extends TemperatureAlarmBaseServer.with(TemperatureAlarm.Feature.Reset, TemperatureAlarm.Feature.OverTemperature, TemperatureAlarm.Feature.UnderTemperature) {
+    initialize() {
+        this.reactTo(this.events.state$Changed, this.#emitNotify);
+    }
+    #emitNotify(state, oldState) {
+        const active = {
+            criticalOverTemperatureAlarm: Boolean(state.criticalOverTemperatureAlarm && !oldState.criticalOverTemperatureAlarm),
+            majorOverTemperatureAlarm: Boolean(state.majorOverTemperatureAlarm && !oldState.majorOverTemperatureAlarm),
+            minorOverTemperatureAlarm: Boolean(state.minorOverTemperatureAlarm && !oldState.minorOverTemperatureAlarm),
+            minorUnderTemperatureAlarm: Boolean(state.minorUnderTemperatureAlarm && !oldState.minorUnderTemperatureAlarm),
+            majorUnderTemperatureAlarm: Boolean(state.majorUnderTemperatureAlarm && !oldState.majorUnderTemperatureAlarm),
+            criticalUnderTemperatureAlarm: Boolean(state.criticalUnderTemperatureAlarm && !oldState.criticalUnderTemperatureAlarm),
+        };
+        const inactive = {
+            criticalOverTemperatureAlarm: Boolean(!state.criticalOverTemperatureAlarm && oldState.criticalOverTemperatureAlarm),
+            majorOverTemperatureAlarm: Boolean(!state.majorOverTemperatureAlarm && oldState.majorOverTemperatureAlarm),
+            minorOverTemperatureAlarm: Boolean(!state.minorOverTemperatureAlarm && oldState.minorOverTemperatureAlarm),
+            minorUnderTemperatureAlarm: Boolean(!state.minorUnderTemperatureAlarm && oldState.minorUnderTemperatureAlarm),
+            majorUnderTemperatureAlarm: Boolean(!state.majorUnderTemperatureAlarm && oldState.majorUnderTemperatureAlarm),
+            criticalUnderTemperatureAlarm: Boolean(!state.criticalUnderTemperatureAlarm && oldState.criticalUnderTemperatureAlarm),
+        };
+        this.events.notify.emit({ active, inactive, state, mask: this.state.mask }, this.context);
+    }
+    #assertAlarmsSupported(alarms, status) {
+        const unsupported = {
+            criticalOverTemperatureAlarm: Boolean(alarms.criticalOverTemperatureAlarm && !this.state.supported.criticalOverTemperatureAlarm),
+            majorOverTemperatureAlarm: Boolean(alarms.majorOverTemperatureAlarm && !this.state.supported.majorOverTemperatureAlarm),
+            minorOverTemperatureAlarm: Boolean(alarms.minorOverTemperatureAlarm && !this.state.supported.minorOverTemperatureAlarm),
+            minorUnderTemperatureAlarm: Boolean(alarms.minorUnderTemperatureAlarm && !this.state.supported.minorUnderTemperatureAlarm),
+            majorUnderTemperatureAlarm: Boolean(alarms.majorUnderTemperatureAlarm && !this.state.supported.majorUnderTemperatureAlarm),
+            criticalUnderTemperatureAlarm: Boolean(alarms.criticalUnderTemperatureAlarm && !this.state.supported.criticalUnderTemperatureAlarm),
+        };
+        if (Object.values(unsupported).some(Boolean)) {
+            throw new StatusResponseError(`MatterbridgeTemperatureAlarmServer: requested alarm is not supported (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, status);
+        }
+    }
+    #clearAlarms(alarms) {
+        return {
+            criticalOverTemperatureAlarm: Boolean(this.state.state.criticalOverTemperatureAlarm && !alarms.criticalOverTemperatureAlarm),
+            majorOverTemperatureAlarm: Boolean(this.state.state.majorOverTemperatureAlarm && !alarms.majorOverTemperatureAlarm),
+            minorOverTemperatureAlarm: Boolean(this.state.state.minorOverTemperatureAlarm && !alarms.minorOverTemperatureAlarm),
+            minorUnderTemperatureAlarm: Boolean(this.state.state.minorUnderTemperatureAlarm && !alarms.minorUnderTemperatureAlarm),
+            majorUnderTemperatureAlarm: Boolean(this.state.state.majorUnderTemperatureAlarm && !alarms.majorUnderTemperatureAlarm),
+            criticalUnderTemperatureAlarm: Boolean(this.state.state.criticalUnderTemperatureAlarm && !alarms.criticalUnderTemperatureAlarm),
+        };
+    }
+    #applyMaskToState(mask) {
+        return {
+            criticalOverTemperatureAlarm: Boolean(this.state.state.criticalOverTemperatureAlarm && mask.criticalOverTemperatureAlarm),
+            majorOverTemperatureAlarm: Boolean(this.state.state.majorOverTemperatureAlarm && mask.majorOverTemperatureAlarm),
+            minorOverTemperatureAlarm: Boolean(this.state.state.minorOverTemperatureAlarm && mask.minorOverTemperatureAlarm),
+            minorUnderTemperatureAlarm: Boolean(this.state.state.minorUnderTemperatureAlarm && mask.minorUnderTemperatureAlarm),
+            majorUnderTemperatureAlarm: Boolean(this.state.state.majorUnderTemperatureAlarm && mask.majorUnderTemperatureAlarm),
+            criticalUnderTemperatureAlarm: Boolean(this.state.state.criticalUnderTemperatureAlarm && mask.criticalUnderTemperatureAlarm),
+        };
+    }
+    async reset(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeTemperatureAlarmServer: resetting alarms ${debugStringify(request.alarms)}${nf} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('TemperatureAlarm.reset', {
+            command: 'reset',
+            request,
+            cluster: MatterbridgeTemperatureAlarmServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        this.#assertAlarmsSupported(request.alarms, Status.Failure);
+        this.state.state = this.#clearAlarms(request.alarms);
+    }
+    async modifyEnabledAlarms(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeTemperatureAlarmServer: modifying enabled alarms ${debugStringify(request.mask)}${nf} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('TemperatureAlarm.modifyEnabledAlarms', {
+            command: 'modifyEnabledAlarms',
+            request,
+            cluster: MatterbridgeTemperatureAlarmServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        this.#assertAlarmsSupported(request.mask, Status.InvalidCommand);
+        this.state.mask = request.mask;
+        this.state.state = this.#applyMaskToState(request.mask);
+    }
+}

package/dist/behaviors/waterTankLevelMonitoringServer.d.ts

@@ -0,0 +1,11 @@
+import { WaterTankLevelMonitoringServer } from '@matter/node/behaviors/water-tank-level-monitoring';
+import type { WaterTankLevelMonitoring } from '@matter/types/clusters/water-tank-level-monitoring';
+declare const MatterbridgeWaterTankLevelMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<typeof WaterTankLevelMonitoringServer, import("@matter/types").ClusterType.WithSupportedFeatures<WaterTankLevelMonitoring, {
+    condition: true;
+    replacementProductList: true;
+    warning: true;
+}>, import("@matter/types").ClusterType.Concrete, new () => {}, "waterTankLevelMonitoring">;
+export declare class MatterbridgeWaterTankLevelMonitoringServer extends MatterbridgeWaterTankLevelMonitoringServer_base {
+    resetCondition(): Promise<void>;
+}
+export {};

package/dist/behaviors/waterTankLevelMonitoringServer.js

@@ -0,0 +1,21 @@
+import { WaterTankLevelMonitoringServer } from '@matter/node/behaviors/water-tank-level-monitoring';
+import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeWaterTankLevelMonitoringServer extends WaterTankLevelMonitoringServer.with(ResourceMonitoring.Feature.Condition, ResourceMonitoring.Feature.Warning, ResourceMonitoring.Feature.ReplacementProductList) {
+    async resetCondition() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeWaterTankLevelMonitoringServer: resetting condition (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('WaterTankLevelMonitoring.resetCondition', {
+            command: 'resetCondition',
+            request: {},
+            cluster: MatterbridgeWaterTankLevelMonitoringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        this.state.condition = 100;
+        this.state.changeIndication = ResourceMonitoring.ChangeIndication.Ok;
+        this.state.lastChangedTime = Math.floor(new Date().getTime() / 1000);
+        device.log.debug(`MatterbridgeWaterTankLevelMonitoringServer: resetCondition called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+    }
+}

package/dist/behaviors/windowCoveringServer.js

@@ -32,7 +32,8 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
         return current < target ? WindowCovering.MovementStatus.Closing : WindowCovering.MovementStatus.Opening;
     }
     #updateGlobalOperationalStatus() {
-        const { lift, tilt } = this.state.operationalStatus;
+        const lift = this.state.operationalStatus.lift ?? WindowCovering.MovementStatus.Stopped;
+        const tilt = this.state.operationalStatus.tilt ?? WindowCovering.MovementStatus.Stopped;
         this.state.operationalStatus.global = lift === WindowCovering.MovementStatus.Stopped ? tilt : lift;
     }
     #startLiftMovement(targetPercent100ths) {
@@ -133,7 +134,11 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
                 this.state.targetPositionLiftPercent100ths = this.state.currentPositionLiftPercent100ths;
             if (this.features.positionAwareTilt)
                 this.state.targetPositionTiltPercent100ths = this.state.currentPositionTiltPercent100ths;
-            this.state.operationalStatus = { global: WindowCovering.MovementStatus.Stopped, lift: WindowCovering.MovementStatus.Stopped, tilt: WindowCovering.MovementStatus.Stopped };
+            this.state.operationalStatus = {
+                global: WindowCovering.MovementStatus.Stopped,
+                ...(this.features.lift ? { lift: WindowCovering.MovementStatus.Stopped } : {}),
+                ...(this.features.tilt ? { tilt: WindowCovering.MovementStatus.Stopped } : {}),
+            };
         }
         device.log.debug(`MatterbridgeWindowCoveringServer: stopMotion result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} status global ${this.getMovementStatusLabel(this.state.operationalStatus.global)} lift ${this.getMovementStatusLabel(this.state.operationalStatus.lift)} tilt ${this.getMovementStatusLabel(this.state.operationalStatus.tilt)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
     }

package/dist/chipTests.js

@@ -24,7 +24,6 @@ import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
 import { TariffPriceType, TariffUnit } from '@matter/types/globals';
 import { MatterbridgeOccupancySensingServer } from './behaviors/occupancySensingServer.js';
 import { cliEmitter } from './cliEmitter.js';
-import { MatterbridgeRefrigeratorAlarmServer } from './devices/refrigerator.js';
 import { MatterbridgeRvcOperationalStateServer, MatterbridgeRvcRunModeServer } from './devices/roboticVacuumCleaner.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 const chipTestAppPipePath = '/tmp/matterbridge-chip-test-app-pipe';
@@ -1019,14 +1018,7 @@ async function handleChipTestAppPipeCommand(matterbridge, command) {
             return;
         case 'SetRefrigeratorDoorStatus': {
             const doorOpen = Boolean(command.DoorOpen);
-            const wasDoorOpen = Boolean(endpoint.stateOf(MatterbridgeRefrigeratorAlarmServer).state.doorOpen);
             await endpoint.setCluster(RefrigeratorAlarm, { state: { doorOpen } }, matterbridge.log);
-            await endpoint.triggerEvent('RefrigeratorAlarm', 'notify', {
-                active: { doorOpen: doorOpen && !wasDoorOpen },
-                inactive: { doorOpen: !doorOpen && wasDoorOpen },
-                state: { doorOpen },
-                mask: endpoint.stateOf(MatterbridgeRefrigeratorAlarmServer).mask,
-            }, matterbridge.log);
             matterbridge.log.info(`CHIP test app pipe set RefrigeratorAlarm.State.DoorOpen to ${doorOpen} on endpoint ${endpointId}`);
             return;
         }

package/dist/demoDevices.js

@@ -372,16 +372,20 @@ export async function createDemoDevices(matterbridge) {
     ep.createDefaultPowerSourceBatteryClusterServer();
     ep.createUserPinDoorLockClusterServer(DoorLock.LockState.Locked, DoorLock.LockType.DeadBolt, 0, 4, 10, 2, 3, 4);
     await registerDevice(ep, 'Door Lock User PIN Schedules', 'ENTRY-08-01-2');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('DoorLock'), bridgedNode, powerSource], { id: 'DoorLockUserPinExpiring', number: EndpointNumber(8_01_3) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createUserPinDoorLockClusterServer(DoorLock.LockState.Locked, DoorLock.LockType.DeadBolt, 0, 4, 10, undefined, undefined, undefined, 10);
+    await registerDevice(ep, 'Door Lock User PIN Expiring', 'ENTRY-08-01-3');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('DoorLockController'), bridgedNode, powerSource], { id: 'DoorLockController', number: EndpointNumber(8_02) });
     await registerDevice(ep, 'Door Lock Controller', 'ENTRY-08-02');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCovering'), bridgedNode, powerSource], { id: 'WindowCoveringLift', number: EndpointNumber(8_03) });
-    ep.createDefaultWindowCoveringClusterServer();
+    ep.createDefaultWindowCoveringClusterServer(100_00, undefined, undefined, 10_000);
     await registerDevice(ep, 'Window Covering Lift', 'ENTRY-08-03');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCovering'), bridgedNode, powerSource], { id: 'WindowCoveringTilt', number: EndpointNumber(8_03_1) });
-    ep.createDefaultTiltWindowCoveringClusterServer();
+    ep.createDefaultTiltWindowCoveringClusterServer(100_00, undefined, undefined, 10_000);
     await registerDevice(ep, 'Window Covering Tilt', 'ENTRY-08-03-1');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCovering'), bridgedNode, powerSource], { id: 'WindowCoveringLiftTilt', number: EndpointNumber(8_03_2) });
-    ep.createDefaultLiftTiltWindowCoveringClusterServer();
+    ep.createDefaultLiftTiltWindowCoveringClusterServer(100_00, 100_00, undefined, undefined, 10_000);
     await registerDevice(ep, 'Window Covering LiftTilt', 'ENTRY-08-03-2');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCoveringController'), bridgedNode, powerSource], { id: 'WindowCoveringController', number: EndpointNumber(8_04) });
     await registerDevice(ep, 'Window Covering Controller', 'ENTRY-08-04');

package/dist/devices/dishwasher.d.ts

@@ -1,6 +1,8 @@
+import type { MaybePromise } from '@matter/general';
 import { DishwasherAlarmServer } from '@matter/node/behaviors/dishwasher-alarm';
 import { DishwasherModeServer } from '@matter/node/behaviors/dishwasher-mode';
-import type { EndpointNumber } from '@matter/types';
+import { type EndpointNumber } from '@matter/types';
+import { DishwasherAlarm } from '@matter/types/clusters/dishwasher-alarm';
 import { DishwasherMode } from '@matter/types/clusters/dishwasher-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
 import type { OperationalState } from '@matter/types/clusters/operational-state';
@@ -32,6 +34,16 @@ export declare class MatterbridgeDishwasherModeServer extends DishwasherModeServ
     protected handleOnOffChange(onOff: boolean): void;
     changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;
 }
-export declare class MatterbridgeDishwasherAlarmServer extends DishwasherAlarmServer {
+declare class DishwasherAlarmBaseServer extends DishwasherAlarmServer {
     static readonly schema: import("@matter/model").ClusterModel;
 }
+declare const MatterbridgeDishwasherAlarmServer_base: import("@matter/node").ClusterBehavior.Type<typeof DishwasherAlarmBaseServer, import("@matter/types").ClusterType.WithSupportedFeatures<DishwasherAlarm, {
+    reset: true;
+}>, import("@matter/types").ClusterType.Concrete, new () => {}, "dishwasherAlarm">;
+export declare class MatterbridgeDishwasherAlarmServer extends MatterbridgeDishwasherAlarmServer_base {
+    #private;
+    initialize(): MaybePromise;
+    reset(request: DishwasherAlarm.ResetRequest): Promise<void>;
+    modifyEnabledAlarms(request: DishwasherAlarm.ModifyEnabledAlarmsRequest): Promise<void>;
+}
+export {};

package/dist/devices/dishwasher.js

@@ -1,9 +1,12 @@
-import { AttributeElement, EventElement, FieldElement } from '@matter/model';
+import { AttributeElement, CommandElement, EventElement, FieldElement } from '@matter/model';
 import { DishwasherAlarmServer } from '@matter/node/behaviors/dishwasher-alarm';
 import { DishwasherModeServer } from '@matter/node/behaviors/dishwasher-mode';
+import { Status, StatusResponseError } from '@matter/types';
+import { DishwasherAlarm } from '@matter/types/clusters/dishwasher-alarm';
 import { DishwasherMode } from '@matter/types/clusters/dishwasher-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
 import { OnOff } from '@matter/types/clusters/on-off';
+import { debugStringify, nf } from 'node-ansi-logger';
 import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
 import { MatterbridgeOnOffServer } from '../behaviors/onOffServer.js';
 import { dishwasher, powerSource } from '../matterbridgeDeviceTypes.js';
@@ -56,6 +59,7 @@ export class Dishwasher extends MatterbridgeEndpoint {
     createDefaultDishwasherAlarmClusterServer() {
         this.behaviors.require(MatterbridgeDishwasherAlarmServer, {
             mask: { inflowError: false, drainError: false, doorError: true, tempTooLow: false, tempTooHigh: false, waterLevelError: false },
+            latch: { inflowError: false, drainError: false, doorError: false, tempTooLow: false, tempTooHigh: false, waterLevelError: false },
             state: { inflowError: false, drainError: false, doorError: false, tempTooLow: false, tempTooHigh: false, waterLevelError: false },
             supported: { inflowError: false, drainError: false, doorError: true, tempTooLow: false, tempTooHigh: false, waterLevelError: false },
         });
@@ -98,7 +102,93 @@ export class MatterbridgeDishwasherModeServer extends DishwasherModeServer {
         }
     }
 }
-const MatterbridgeDishwasherAlarmSchema = DishwasherAlarmServer.schema.extend({}, AttributeElement({ name: 'Mask', id: 0x0000, type: 'AlarmBitmap', access: 'R V', conformance: 'M' }), AttributeElement({ name: 'State', id: 0x0002, type: 'AlarmBitmap', access: 'R V', conformance: 'M' }), AttributeElement({ name: 'Supported', id: 0x0003, type: 'AlarmBitmap', access: 'R V', conformance: 'M', quality: 'F' }), EventElement({ name: 'Notify', id: 0x0000, access: 'V', conformance: 'M', priority: 'info' }, FieldElement({ name: 'Active', id: 0x0000, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'Inactive', id: 0x0001, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'State', id: 0x0002, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'Mask', id: 0x0003, type: 'AlarmBitmap', conformance: 'M' })));
-export class MatterbridgeDishwasherAlarmServer extends DishwasherAlarmServer {
+const MatterbridgeDishwasherAlarmSchema = DishwasherAlarmServer.schema.extend({}, AttributeElement({ name: 'Mask', id: 0x0000, type: 'AlarmBitmap', access: 'R V', conformance: 'M' }), AttributeElement({ name: 'Latch', id: 0x0001, type: 'AlarmBitmap', access: 'R V', conformance: 'RESET', quality: 'F' }), AttributeElement({ name: 'State', id: 0x0002, type: 'AlarmBitmap', access: 'R V', conformance: 'M' }), AttributeElement({ name: 'Supported', id: 0x0003, type: 'AlarmBitmap', access: 'R V', conformance: 'M', quality: 'F' }), CommandElement({ name: 'Reset', id: 0x0000, access: 'O', conformance: 'RESET', direction: 'request', response: 'status' }, FieldElement({ name: 'Alarms', id: 0x0000, type: 'AlarmBitmap', conformance: 'M' })), CommandElement({ name: 'ModifyEnabledAlarms', id: 0x0001, access: 'O', conformance: 'O', direction: 'request', response: 'status' }, FieldElement({ name: 'Mask', id: 0x0000, type: 'AlarmBitmap', conformance: 'M' })), EventElement({ name: 'Notify', id: 0x0000, access: 'V', conformance: 'M', priority: 'info' }, FieldElement({ name: 'Active', id: 0x0000, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'Inactive', id: 0x0001, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'State', id: 0x0002, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'Mask', id: 0x0003, type: 'AlarmBitmap', conformance: 'M' })));
+class DishwasherAlarmBaseServer extends DishwasherAlarmServer {
     static schema = MatterbridgeDishwasherAlarmSchema;
 }
+export class MatterbridgeDishwasherAlarmServer extends DishwasherAlarmBaseServer.with(DishwasherAlarm.Feature.Reset) {
+    initialize() {
+        this.reactTo(this.events.state$Changed, this.#emitNotify);
+    }
+    #emitNotify(state, oldState) {
+        const active = {
+            inflowError: Boolean(state.inflowError && !oldState.inflowError),
+            drainError: Boolean(state.drainError && !oldState.drainError),
+            doorError: Boolean(state.doorError && !oldState.doorError),
+            tempTooLow: Boolean(state.tempTooLow && !oldState.tempTooLow),
+            tempTooHigh: Boolean(state.tempTooHigh && !oldState.tempTooHigh),
+            waterLevelError: Boolean(state.waterLevelError && !oldState.waterLevelError),
+        };
+        const inactive = {
+            inflowError: Boolean(!state.inflowError && oldState.inflowError),
+            drainError: Boolean(!state.drainError && oldState.drainError),
+            doorError: Boolean(!state.doorError && oldState.doorError),
+            tempTooLow: Boolean(!state.tempTooLow && oldState.tempTooLow),
+            tempTooHigh: Boolean(!state.tempTooHigh && oldState.tempTooHigh),
+            waterLevelError: Boolean(!state.waterLevelError && oldState.waterLevelError),
+        };
+        this.events.notify.emit({ active, inactive, state, mask: this.state.mask }, this.context);
+    }
+    #assertAlarmsSupported(alarms, status) {
+        const unsupported = {
+            inflowError: Boolean(alarms.inflowError && !this.state.supported.inflowError),
+            drainError: Boolean(alarms.drainError && !this.state.supported.drainError),
+            doorError: Boolean(alarms.doorError && !this.state.supported.doorError),
+            tempTooLow: Boolean(alarms.tempTooLow && !this.state.supported.tempTooLow),
+            tempTooHigh: Boolean(alarms.tempTooHigh && !this.state.supported.tempTooHigh),
+            waterLevelError: Boolean(alarms.waterLevelError && !this.state.supported.waterLevelError),
+        };
+        if (Object.values(unsupported).some(Boolean)) {
+            throw new StatusResponseError(`MatterbridgeDishwasherAlarmServer: requested alarm is not supported (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, status);
+        }
+    }
+    #clearAlarms(alarms) {
+        return {
+            inflowError: Boolean(this.state.state.inflowError && !alarms.inflowError),
+            drainError: Boolean(this.state.state.drainError && !alarms.drainError),
+            doorError: Boolean(this.state.state.doorError && !alarms.doorError),
+            tempTooLow: Boolean(this.state.state.tempTooLow && !alarms.tempTooLow),
+            tempTooHigh: Boolean(this.state.state.tempTooHigh && !alarms.tempTooHigh),
+            waterLevelError: Boolean(this.state.state.waterLevelError && !alarms.waterLevelError),
+        };
+    }
+    #applyMaskToState(mask) {
+        return {
+            inflowError: Boolean(this.state.state.inflowError && mask.inflowError),
+            drainError: Boolean(this.state.state.drainError && mask.drainError),
+            doorError: Boolean(this.state.state.doorError && mask.doorError),
+            tempTooLow: Boolean(this.state.state.tempTooLow && mask.tempTooLow),
+            tempTooHigh: Boolean(this.state.state.tempTooHigh && mask.tempTooHigh),
+            waterLevelError: Boolean(this.state.state.waterLevelError && mask.waterLevelError),
+        };
+    }
+    async reset(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeDishwasherAlarmServer: resetting alarms ${debugStringify(request.alarms)}${nf} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DishwasherAlarm.reset', {
+            command: 'reset',
+            request,
+            cluster: MatterbridgeDishwasherAlarmServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        this.#assertAlarmsSupported(request.alarms, Status.Failure);
+        this.state.state = this.#clearAlarms(request.alarms);
+    }
+    async modifyEnabledAlarms(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeDishwasherAlarmServer: modifying enabled alarms ${debugStringify(request.mask)}${nf} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DishwasherAlarm.modifyEnabledAlarms', {
+            command: 'modifyEnabledAlarms',
+            request,
+            cluster: MatterbridgeDishwasherAlarmServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        this.#assertAlarmsSupported(request.mask, Status.InvalidCommand);
+        this.state.mask = request.mask;
+        this.state.state = this.#applyMaskToState(request.mask);
+    }
+}

package/dist/devices/refrigerator.d.ts

@@ -38,5 +38,7 @@ export declare class MatterbridgeRefrigeratorAndTemperatureControlledCabinetMode
     changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
 }
 export declare class MatterbridgeRefrigeratorAlarmServer extends RefrigeratorAlarmServer {
+    #private;
     static readonly schema: import("@matter/model").ClusterModel;
+    initialize(): MaybePromise;
 }

package/dist/devices/refrigerator.js

@@ -100,4 +100,12 @@ export class MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer e
 const MatterbridgeRefrigeratorAlarmSchema = RefrigeratorAlarmServer.schema.extend({}, AttributeElement({ name: 'Mask', id: 0x0000, type: 'AlarmBitmap', access: 'R V', conformance: 'M' }), AttributeElement({ name: 'State', id: 0x0002, type: 'AlarmBitmap', access: 'R V', conformance: 'M' }), AttributeElement({ name: 'Supported', id: 0x0003, type: 'AlarmBitmap', access: 'R V', conformance: 'M', quality: 'F' }), EventElement({ name: 'Notify', id: 0x0000, access: 'V', conformance: 'M', priority: 'info' }, FieldElement({ name: 'Active', id: 0x0000, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'Inactive', id: 0x0001, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'State', id: 0x0002, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'Mask', id: 0x0003, type: 'AlarmBitmap', conformance: 'M' })));
 export class MatterbridgeRefrigeratorAlarmServer extends RefrigeratorAlarmServer {
     static schema = MatterbridgeRefrigeratorAlarmSchema;
+    initialize() {
+        this.reactTo(this.events.state$Changed, this.#emitNotify);
+    }
+    #emitNotify(state, oldState) {
+        const active = { doorOpen: Boolean(state.doorOpen && !oldState.doorOpen) };
+        const inactive = { doorOpen: Boolean(!state.doorOpen && oldState.doorOpen) };
+        this.events.notify.emit({ active, inactive, state, mask: this.state.mask }, this.context);
+    }
 }

package/dist/export.d.ts

@@ -19,6 +19,8 @@ export * from './behaviors/smokeCoAlarmServer.js';
 export * from './behaviors/switchServer.js';
 export * from './behaviors/thermostatServer.js';
 export * from './behaviors/valveConfigurationAndControlServer.js';
+export * from './behaviors/temperatureAlarmServer.js';
+export * from './behaviors/waterTankLevelMonitoringServer.js';
 export * from './behaviors/windowCoveringServer.js';
 export { addVirtualDevice } from './helpers.js';
 export * from './matterbridgeAccessoryPlatform.js';

package/dist/export.js

@@ -21,6 +21,8 @@ export * from './behaviors/smokeCoAlarmServer.js';
 export * from './behaviors/switchServer.js';
 export * from './behaviors/thermostatServer.js';
 export * from './behaviors/valveConfigurationAndControlServer.js';
+export * from './behaviors/temperatureAlarmServer.js';
+export * from './behaviors/waterTankLevelMonitoringServer.js';
 export * from './behaviors/windowCoveringServer.js';
 export { addVirtualDevice } from './helpers.js';
 export * from './matterbridgeAccessoryPlatform.js';

package/dist/frontend.js

@@ -1200,6 +1200,10 @@ export class Frontend extends EventEmitter {
                 attributes += `Hepa filter: ${attributeValue}% `;
             if (clusterName === 'activatedCarbonFilterMonitoring' && attributeName === 'condition')
                 attributes += `Carbon filter: ${attributeValue}% `;
+            if (clusterName === 'waterTankLevelMonitoring' && attributeName === 'condition')
+                attributes += `Water tank: ${attributeValue}% `;
+            if (clusterName === 'temperatureAlarm' && attributeName === 'state' && isValidObject(attributeValue))
+                attributes += `Temp alarm: ${stringify(attributeValue)} `;
             if (clusterName === 'occupancySensing' && attributeName === 'occupancy' && isValidObject(attributeValue, 1))
                 attributes += `Occupancy: ${attributeValue.occupied} `;
             if (clusterName === 'illuminanceMeasurement' && attributeName === 'measuredValue') {

package/dist/matterbridgeDeviceTypes.js

@@ -104,6 +104,7 @@ import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-confi
 import { WakeOnLan } from '@matter/types/clusters/wake-on-lan';
 import { WaterHeaterManagement } from '@matter/types/clusters/water-heater-management';
 import { WaterHeaterMode } from '@matter/types/clusters/water-heater-mode';
+import { WaterTankLevelMonitoring } from '@matter/types/clusters/water-tank-level-monitoring';
 import { WebRtcTransportProvider } from '@matter/types/clusters/web-rtc-transport-provider';
 import { WebRtcTransportRequestor } from '@matter/types/clusters/web-rtc-transport-requestor';
 import { WindowCovering } from '@matter/types/clusters/window-covering';
@@ -1264,6 +1265,7 @@ export const supportedClusters = [
     SoilMeasurement,
     Switch,
     TargetNavigator,
+    TemperatureAlarm,
     TemperatureControl,
     TemperatureMeasurement,
     Thermostat,
@@ -1276,6 +1278,7 @@ export const supportedClusters = [
     WakeOnLan,
     WaterHeaterManagement,
     WaterHeaterMode,
+    WaterTankLevelMonitoring,
     WebRtcTransportProvider,
     WebRtcTransportRequestor,
     WindowCovering,

package/dist/matterbridgeEndpoint.d.ts

@@ -18,6 +18,7 @@ import { PowerTopology } from '@matter/types/clusters/power-topology';
 import { PumpConfigurationAndControl } from '@matter/types/clusters/pump-configuration-and-control';
 import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
 import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
+import type { TemperatureAlarm } from '@matter/types/clusters/temperature-alarm';
 import { Thermostat } from '@matter/types/clusters/thermostat';
 import { ThermostatUserInterfaceConfiguration } from '@matter/types/clusters/thermostat-user-interface-configuration';
 import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
@@ -119,9 +120,9 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     addCommandHandler<C extends CommandHandlers>(command: C, handler: CommandHandlerFunction<C>): this;
     removeCommandHandler<C extends CommandHandlers>(command: C, handler: CommandHandlerFunction<C>): this;
     executeCommandHandler<C extends CommandHandlers>(command: C, request: CommandHandlerData<C>['request'], cluster: CommandHandlerData<C>['cluster'], attributes: CommandHandlerData<C>['attributes'], endpoint: CommandHandlerData<C>['endpoint']): Promise<CommandHandlerExecutionResult<C>>;
-    invokeBehaviorCommand<T extends Behavior.Type, C extends BehaviorCommandName<T>>(cluster: T, command: C, params?: BehaviorCommandParams<T, C>): Promise<void>;
-    invokeBehaviorCommand<T extends ClusterType, C extends ClusterCommandName<T>>(cluster: T, command: C, params?: ClusterCommandParams<T, C>): Promise<void>;
-    invokeBehaviorCommand(cluster: ClusterId | string, command: CommandHandlers, params?: Record<string, boolean | number | bigint | string | object | null>): Promise<void>;
+    invokeBehaviorCommand<T extends Behavior.Type, C extends BehaviorCommandName<T>>(cluster: T, command: C, params?: BehaviorCommandParams<T, C>, waiterCondition?: () => boolean): Promise<void>;
+    invokeBehaviorCommand<T extends ClusterType, C extends ClusterCommandName<T>>(cluster: T, command: C, params?: ClusterCommandParams<T, C>, waiterCondition?: () => boolean): Promise<void>;
+    invokeBehaviorCommand(cluster: ClusterId | string, command: CommandHandlers, params?: Record<string, boolean | number | bigint | string | object | null>, waiterCondition?: () => boolean): Promise<void>;
     addRequiredClusters(): MatterbridgeEndpoint;
     addRequiredClusterServers(): MatterbridgeEndpoint;
     addOptionalClusterServers(): MatterbridgeEndpoint;
@@ -207,8 +208,10 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     }, airflowDirection?: FanControl.AirflowDirection): this;
     createDefaultHepaFilterMonitoringClusterServer(condition?: number, changeIndication?: ResourceMonitoring.ChangeIndication, inPlaceIndicator?: boolean | undefined, lastChangedTime?: number | null | undefined, replacementProductList?: ResourceMonitoring.ReplacementProduct[]): this;
     createDefaultActivatedCarbonFilterMonitoringClusterServer(condition?: number, changeIndication?: ResourceMonitoring.ChangeIndication, inPlaceIndicator?: boolean | undefined, lastChangedTime?: number | null | undefined, replacementProductList?: ResourceMonitoring.ReplacementProduct[]): this;
+    createDefaultTemperatureAlarmClusterServer(criticalOverTemperatureThreshold?: number, criticalUnderTemperatureThreshold?: number, supported?: TemperatureAlarm.Alarm, mask?: TemperatureAlarm.Alarm, latch?: TemperatureAlarm.Alarm, state?: TemperatureAlarm.Alarm): this;
+    createDefaultWaterTankLevelMonitoringClusterServer(condition?: number, changeIndication?: ResourceMonitoring.ChangeIndication, inPlaceIndicator?: boolean | undefined, lastChangedTime?: number | null | undefined, replacementProductList?: ResourceMonitoring.ReplacementProduct[]): this;
     createDefaultDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType, autoRelockTime?: number, numberOfWeekDaySchedulesSupportedPerUser?: number, numberOfYearDaySchedulesSupportedPerUser?: number, numberOfHolidaySchedulesSupported?: number): this;
-    createUserPinDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType, autoRelockTime?: number, minPinCodeLength?: number, maxPinCodeLength?: number, numberOfWeekDaySchedulesSupportedPerUser?: number, numberOfYearDaySchedulesSupportedPerUser?: number, numberOfHolidaySchedulesSupported?: number): this;
+    createUserPinDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType, autoRelockTime?: number, minPinCodeLength?: number, maxPinCodeLength?: number, numberOfWeekDaySchedulesSupportedPerUser?: number, numberOfYearDaySchedulesSupportedPerUser?: number, numberOfHolidaySchedulesSupported?: number, expiringUserTimeout?: number, numberOfRfidUsersSupported?: number, minRfidCodeLength?: number, maxRfidCodeLength?: number): this;
     createDefaultModeSelectClusterServer(description: string, supportedModes: ModeSelect.ModeOption[], currentMode?: number, startUpMode?: number): this;
     createDefaultValveConfigurationAndControlClusterServer(valveState?: ValveConfigurationAndControl.ValveState, valveLevel?: number, movementDuration?: number, autoClose?: boolean): this;
     createDefaultPumpConfigurationAndControlClusterServer(pumpMode?: PumpConfigurationAndControl.OperationMode, maxPressure?: number | null, maxSpeed?: number | null, maxFlow?: number | null, minConstSpeed?: number | null, maxConstSpeed?: number | null, speed?: number | null): this;

package/dist/matterbridgeEndpoint.js

@@ -79,8 +79,10 @@ import { MatterbridgePowerSourceServer } from './behaviors/powerSourceServer.js'
 import { MatterbridgePumpConfigurationAndControlServer } from './behaviors/pumpConfigurationAndControlServer.js';
 import { MatterbridgeSmokeCoAlarmServer } from './behaviors/smokeCoAlarmServer.js';
 import { MatterbridgeSwitchServer } from './behaviors/switchServer.js';
+import { MatterbridgeTemperatureAlarmServer } from './behaviors/temperatureAlarmServer.js';
 import { MatterbridgeThermostatServer } from './behaviors/thermostatServer.js';
 import { MatterbridgeValveConfigurationAndControlServer } from './behaviors/valveConfigurationAndControlServer.js';
+import { MatterbridgeWaterTankLevelMonitoringServer } from './behaviors/waterTankLevelMonitoringServer.js';
 import { MatterbridgeWindowCoveringServer } from './behaviors/windowCoveringServer.js';
 import { CommandHandler, } from './matterbridgeEndpointCommandHandler.js';
 import { addClusterClients, addClusterServers, addFixedLabel, addOptionalClusterClients, addOptionalClusterServers, addRequiredClusterClients, addRequiredClusterServers, addUserLabel, checkNotLatinCharacters, createUniqueId, defaultFor, featuresFor, generateUniqueId, getApparentElectricalPowerMeasurementClusterServer, getAttribute, getAttributeId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getCluster, getClusterId, getDefaultDeviceEnergyManagementClusterServer, getDefaultDeviceEnergyManagementModeClusterServer, getDefaultElectricalEnergyMeasurementClusterServer, getDefaultElectricalPowerMeasurementClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultOccupancySensingClusterServer, getDefaultOperationalStateClusterServer, getDefaultPowerSourceBatteryClusterServer, getDefaultPowerSourceRechargeableBatteryClusterServer, getDefaultPowerSourceReplaceableBatteryClusterServer, getDefaultPowerSourceWiredClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultSoilMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getExportedElectricalEnergyMeasurementClusterServer, getImportedElectricalEnergyMeasurementClusterServer, invokeBehaviorCommand, lowercaseFirstLetter, setAttribute, setCluster, subscribeAttribute, triggerEvent, updateAttribute, } from './matterbridgeEndpointHelpers.js';
@@ -277,8 +279,8 @@ export class MatterbridgeEndpoint extends Endpoint {
     async executeCommandHandler(command, request, cluster, attributes, endpoint) {
         return this.commandHandler.executeHandler(command, { command, request, cluster, attributes, endpoint });
     }
-    async invokeBehaviorCommand(cluster, command, params) {
-        await invokeBehaviorCommand(this, cluster, command, params);
+    async invokeBehaviorCommand(cluster, command, params, waiterCondition) {
+        await invokeBehaviorCommand(this, cluster, command, params, waiterCondition);
     }
     addRequiredClusters() {
         addRequiredClusterServers(this);
@@ -831,14 +833,13 @@ export class MatterbridgeEndpoint extends Endpoint {
             numberOfActuationsLift: 0,
             configStatus: {
                 operational: true,
-                onlineReserved: false,
                 liftMovementReversed: false,
                 liftPositionAware: true,
                 tiltPositionAware: false,
                 liftEncoderControlled: false,
                 tiltEncoderControlled: false,
             },
-            operationalStatus: { global: WindowCovering.MovementStatus.Stopped, lift: WindowCovering.MovementStatus.Stopped, tilt: WindowCovering.MovementStatus.Stopped },
+            operationalStatus: { global: WindowCovering.MovementStatus.Stopped, lift: WindowCovering.MovementStatus.Stopped },
             endProductType,
             mode: { motorDirectionReversed: false, calibrationMode: false, maintenanceMode: false, ledFeedback: false },
             targetPositionLiftPercent100ths: positionPercent100ths,
@@ -855,7 +856,6 @@ export class MatterbridgeEndpoint extends Endpoint {
             numberOfActuationsTilt: 0,
             configStatus: {
                 operational: true,
-                onlineReserved: false,
                 liftMovementReversed: false,
                 liftPositionAware: true,
                 tiltPositionAware: true,
@@ -881,14 +881,13 @@ export class MatterbridgeEndpoint extends Endpoint {
             numberOfActuationsTilt: 0,
             configStatus: {
                 operational: true,
-                onlineReserved: false,
                 liftMovementReversed: false,
                 liftPositionAware: false,
                 tiltPositionAware: true,
                 liftEncoderControlled: false,
                 tiltEncoderControlled: false,
             },
-            operationalStatus: { global: WindowCovering.MovementStatus.Stopped, lift: WindowCovering.MovementStatus.Stopped, tilt: WindowCovering.MovementStatus.Stopped },
+            operationalStatus: { global: WindowCovering.MovementStatus.Stopped, tilt: WindowCovering.MovementStatus.Stopped },
             endProductType,
             mode: { motorDirectionReversed: false, calibrationMode: false, maintenanceMode: false, ledFeedback: false },
             targetPositionTiltPercent100ths: positionTiltPercent100ths,
@@ -899,39 +898,44 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
     async setWindowCoveringTargetAsCurrentAndStopped() {
-        const position = this.getAttribute(WindowCovering, 'currentPositionLiftPercent100ths', this.log);
-        if (isValidNumber(position, 0, 10000)) {
-            await this.setAttribute(WindowCovering, 'targetPositionLiftPercent100ths', position, this.log);
-            await this.setAttribute(WindowCovering, 'operationalStatus', {
-                global: WindowCovering.MovementStatus.Stopped,
-                lift: WindowCovering.MovementStatus.Stopped,
-                tilt: WindowCovering.MovementStatus.Stopped,
-            }, this.log);
+        const { lift, tilt } = featuresFor(this, WindowCovering);
+        if (lift) {
+            const position = this.getAttribute(WindowCovering, 'currentPositionLiftPercent100ths', this.log);
+            if (isValidNumber(position, 0, 10000)) {
+                await this.setAttribute(WindowCovering, 'targetPositionLiftPercent100ths', position, this.log);
+            }
+            this.log.debug(`Set WindowCovering currentPositionLiftPercent100ths and targetPositionLiftPercent100ths to ${position} and operationalStatus to Stopped.`);
         }
-        this.log.debug(`Set WindowCovering currentPositionLiftPercent100ths and targetPositionLiftPercent100ths to ${position} and operationalStatus to Stopped.`);
-        if (this.hasAttributeServer(WindowCovering, 'currentPositionTiltPercent100ths')) {
+        if (tilt) {
             const position = this.getAttribute(WindowCovering, 'currentPositionTiltPercent100ths', this.log);
             if (isValidNumber(position, 0, 10000)) {
                 await this.setAttribute(WindowCovering, 'targetPositionTiltPercent100ths', position, this.log);
             }
             this.log.debug(`Set WindowCovering currentPositionTiltPercent100ths and targetPositionTiltPercent100ths to ${position} and operationalStatus to Stopped.`);
         }
+        await this.setAttribute(WindowCovering, 'operationalStatus', {
+            global: WindowCovering.MovementStatus.Stopped,
+            ...(lift ? { lift: WindowCovering.MovementStatus.Stopped } : {}),
+            ...(tilt ? { tilt: WindowCovering.MovementStatus.Stopped } : {}),
+        }, this.log);
     }
     async setWindowCoveringCurrentTargetStatus(current, target, status) {
         await this.setAttribute(WindowCovering, 'currentPositionLiftPercent100ths', current, this.log);
         await this.setAttribute(WindowCovering, 'targetPositionLiftPercent100ths', target, this.log);
+        const { lift, tilt } = featuresFor(this, WindowCovering);
         await this.setAttribute(WindowCovering, 'operationalStatus', {
             global: status,
-            lift: status,
-            tilt: status,
+            ...(lift ? { lift: status } : {}),
+            ...(tilt ? { tilt: status } : {}),
         }, this.log);
         this.log.debug(`Set WindowCovering currentPositionLiftPercent100ths: ${current}, targetPositionLiftPercent100ths: ${target} and operationalStatus: ${status}.`);
     }
     async setWindowCoveringStatus(status) {
+        const { lift, tilt } = featuresFor(this, WindowCovering);
         await this.setAttribute(WindowCovering, 'operationalStatus', {
             global: status,
-            lift: status,
-            tilt: status,
+            ...(lift ? { lift: status } : {}),
+            ...(tilt ? { tilt: status } : {}),
         }, this.log);
         this.log.debug(`Set WindowCovering operationalStatus: ${status}`);
     }
@@ -947,7 +951,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         await this.setAttribute(WindowCovering, 'currentPositionLiftPercent100ths', liftPosition, this.log);
         await this.setAttribute(WindowCovering, 'targetPositionLiftPercent100ths', liftPosition, this.log);
         this.log.debug(`Set WindowCovering currentPositionLiftPercent100ths: ${liftPosition} and targetPositionLiftPercent100ths: ${liftPosition}.`);
-        if (tiltPosition && this.hasAttributeServer(WindowCovering, 'currentPositionTiltPercent100ths')) {
+        if (tiltPosition && featuresFor(this, WindowCovering).tilt) {
             await this.setAttribute(WindowCovering, 'currentPositionTiltPercent100ths', tiltPosition, this.log);
             await this.setAttribute(WindowCovering, 'targetPositionTiltPercent100ths', tiltPosition, this.log);
             this.log.debug(`Set WindowCovering currentPositionTiltPercent100ths: ${tiltPosition} and targetPositionTiltPercent100ths: ${tiltPosition}.`);
@@ -1282,6 +1286,36 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    createDefaultTemperatureAlarmClusterServer(criticalOverTemperatureThreshold = 60 * 100, criticalUnderTemperatureThreshold = -10 * 100, supported = { criticalOverTemperatureAlarm: true, criticalUnderTemperatureAlarm: true }, mask = supported, latch = {}, state = {}) {
+        const bitmap = (alarm) => ({
+            criticalOverTemperatureAlarm: Boolean(alarm.criticalOverTemperatureAlarm),
+            majorOverTemperatureAlarm: false,
+            minorOverTemperatureAlarm: false,
+            minorUnderTemperatureAlarm: false,
+            majorUnderTemperatureAlarm: false,
+            criticalUnderTemperatureAlarm: Boolean(alarm.criticalUnderTemperatureAlarm),
+        });
+        this.behaviors.require(MatterbridgeTemperatureAlarmServer, {
+            criticalOverTemperatureThreshold,
+            criticalUnderTemperatureThreshold,
+            latch: bitmap(latch),
+            supported: bitmap(supported),
+            mask: bitmap(mask),
+            state: bitmap(state),
+        });
+        return this;
+    }
+    createDefaultWaterTankLevelMonitoringClusterServer(condition = 100, changeIndication = ResourceMonitoring.ChangeIndication.Ok, inPlaceIndicator = true, lastChangedTime = null, replacementProductList = []) {
+        this.behaviors.require(MatterbridgeWaterTankLevelMonitoringServer.with(ResourceMonitoring.Feature.Condition, ResourceMonitoring.Feature.Warning, ResourceMonitoring.Feature.ReplacementProductList), {
+            condition,
+            degradationDirection: ResourceMonitoring.DegradationDirection.Down,
+            replacementProductList,
+            changeIndication,
+            inPlaceIndicator,
+            lastChangedTime,
+        });
+        return this;
+    }
     createDefaultDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt, autoRelockTime = 0, numberOfWeekDaySchedulesSupportedPerUser, numberOfYearDaySchedulesSupportedPerUser, numberOfHolidaySchedulesSupported) {
         this.behaviors.require(MatterbridgeDoorLockServer.with(...(numberOfWeekDaySchedulesSupportedPerUser !== undefined ? [DoorLock.Feature.WeekDayAccessSchedules] : []), ...(numberOfYearDaySchedulesSupportedPerUser !== undefined ? [DoorLock.Feature.YearDayAccessSchedules] : []), ...(numberOfHolidaySchedulesSupported !== undefined ? [DoorLock.Feature.HolidaySchedules] : [])).enable({
             events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
@@ -1299,8 +1333,8 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
-    createUserPinDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt, autoRelockTime = 0, minPinCodeLength = 4, maxPinCodeLength = 10, numberOfWeekDaySchedulesSupportedPerUser, numberOfYearDaySchedulesSupportedPerUser, numberOfHolidaySchedulesSupported) {
-        this.behaviors.require(MatterbridgeDoorLockServer.with(DoorLock.Feature.User, DoorLock.Feature.PinCredential, ...(numberOfWeekDaySchedulesSupportedPerUser !== undefined ? [DoorLock.Feature.WeekDayAccessSchedules] : []), ...(numberOfYearDaySchedulesSupportedPerUser !== undefined ? [DoorLock.Feature.YearDayAccessSchedules] : []), ...(numberOfHolidaySchedulesSupported !== undefined ? [DoorLock.Feature.HolidaySchedules] : [])).enable({
+    createUserPinDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt, autoRelockTime = 0, minPinCodeLength = 4, maxPinCodeLength = 10, numberOfWeekDaySchedulesSupportedPerUser, numberOfYearDaySchedulesSupportedPerUser, numberOfHolidaySchedulesSupported, expiringUserTimeout, numberOfRfidUsersSupported, minRfidCodeLength = 8, maxRfidCodeLength = 20) {
+        this.behaviors.require(MatterbridgeDoorLockServer.with(DoorLock.Feature.User, DoorLock.Feature.PinCredential, ...(numberOfWeekDaySchedulesSupportedPerUser !== undefined ? [DoorLock.Feature.WeekDayAccessSchedules] : []), ...(numberOfYearDaySchedulesSupportedPerUser !== undefined ? [DoorLock.Feature.YearDayAccessSchedules] : []), ...(numberOfHolidaySchedulesSupported !== undefined ? [DoorLock.Feature.HolidaySchedules] : []), ...(numberOfRfidUsersSupported !== undefined ? [DoorLock.Feature.RfidCredential] : [])).enable({
             events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
             commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true },
         }), {
@@ -1318,9 +1352,11 @@ export class MatterbridgeEndpoint extends Endpoint {
             numberOfTotalUsersSupported: 10,
             credentialRulesSupport: { single: true },
             numberOfCredentialsSupportedPerUser: 10,
+            ...(expiringUserTimeout !== undefined ? { expiringUserTimeout } : {}),
             ...(numberOfWeekDaySchedulesSupportedPerUser !== undefined ? { numberOfWeekDaySchedulesSupportedPerUser } : {}),
             ...(numberOfYearDaySchedulesSupportedPerUser !== undefined ? { numberOfYearDaySchedulesSupportedPerUser } : {}),
             ...(numberOfHolidaySchedulesSupported !== undefined ? { numberOfHolidaySchedulesSupported } : {}),
+            ...(numberOfRfidUsersSupported !== undefined ? { numberOfRfidUsersSupported, minRfidCodeLength, maxRfidCodeLength } : {}),
         });
         return this;
     }

package/dist/matterbridgeEndpointCommandHandler.d.ts

@@ -8,6 +8,7 @@ import type { CommodityPrice } from '@matter/types/clusters/commodity-price';
 import type { CommodityTariff } from '@matter/types/clusters/commodity-tariff';
 import type { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
 import type { DeviceEnergyManagementMode } from '@matter/types/clusters/device-energy-management-mode';
+import type { DishwasherAlarm } from '@matter/types/clusters/dishwasher-alarm';
 import type { DishwasherMode } from '@matter/types/clusters/dishwasher-mode';
 import type { DoorLock } from '@matter/types/clusters/door-lock';
 import type { EnergyEvse } from '@matter/types/clusters/energy-evse';
@@ -30,6 +31,7 @@ import type { RvcOperationalState } from '@matter/types/clusters/rvc-operational
 import type { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
 import type { ServiceArea } from '@matter/types/clusters/service-area';
 import type { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
+import type { TemperatureAlarm } from '@matter/types/clusters/temperature-alarm';
 import type { TemperatureControl } from '@matter/types/clusters/temperature-control';
 import type { Thermostat } from '@matter/types/clusters/thermostat';
 import type { ThreadNetworkDiagnostics } from '@matter/types/clusters/thread-network-diagnostics';
@@ -37,6 +39,7 @@ import type { TimeSynchronization } from '@matter/types/clusters/time-synchroniz
 import type { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
 import type { WaterHeaterManagement } from '@matter/types/clusters/water-heater-management';
 import type { WaterHeaterMode } from '@matter/types/clusters/water-heater-mode';
+import type { WaterTankLevelMonitoring } from '@matter/types/clusters/water-tank-level-monitoring';
 import type { WindowCovering } from '@matter/types/clusters/window-covering';
 import type { ClosureControl } from './clusters/closure-control.js';
 import type { ClosureDimension } from './clusters/closure-dimension.js';
@@ -673,6 +676,34 @@ export type CommandHandlerDataMap = {
         attributes: ClusterAttributeValues<(typeof SmokeCoAlarm)['attributes']>;
         endpoint: MatterbridgeEndpoint;
     };
+    'DishwasherAlarm.reset': {
+        command: 'reset';
+        request: DishwasherAlarm.ResetRequest;
+        cluster: 'dishwasherAlarm';
+        attributes: ClusterAttributeValues<(typeof DishwasherAlarm)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DishwasherAlarm.modifyEnabledAlarms': {
+        command: 'modifyEnabledAlarms';
+        request: DishwasherAlarm.ModifyEnabledAlarmsRequest;
+        cluster: 'dishwasherAlarm';
+        attributes: ClusterAttributeValues<(typeof DishwasherAlarm)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'TemperatureAlarm.reset': {
+        command: 'reset';
+        request: TemperatureAlarm.ResetRequest;
+        cluster: 'temperatureAlarm';
+        attributes: ClusterAttributeValues<(typeof TemperatureAlarm)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'TemperatureAlarm.modifyEnabledAlarms': {
+        command: 'modifyEnabledAlarms';
+        request: TemperatureAlarm.ModifyEnabledAlarmsRequest;
+        cluster: 'temperatureAlarm';
+        attributes: ClusterAttributeValues<(typeof TemperatureAlarm)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'resetCounts': CommandHandlerData<'ThreadNetworkDiagnostics.resetCounts'>;
     'ThreadNetworkDiagnostics.resetCounts': {
         command: 'resetCounts';
@@ -991,6 +1022,13 @@ export type CommandHandlerDataMap = {
         attributes: ClusterAttributeValues<(typeof ActivatedCarbonFilterMonitoring)['attributes']>;
         endpoint: MatterbridgeEndpoint;
     };
+    'WaterTankLevelMonitoring.resetCondition': {
+        command: 'resetCondition';
+        request: {};
+        cluster: 'waterTankLevelMonitoring';
+        attributes: ClusterAttributeValues<(typeof WaterTankLevelMonitoring)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'CommodityPrice.getDetailedPriceRequest': {
         command: 'getDetailedPriceRequest';
         request: CommodityPrice.GetDetailedPriceRequest;

package/dist/matterbridgeEndpointHelpers.d.ts

@@ -41,7 +41,7 @@ export declare function getBehaviourTypesFromClusterClientIds(clusterClientList:
 export declare function getBehaviourTypeFromClusterServerId(clusterId: ClusterId): Behavior.Type | undefined;
 export declare function getBehaviourTypeFromClusterClientId(clusterId: ClusterId): ClusterBehavior.Type | undefined;
 export declare function getBehavior(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string): Behavior.Type | undefined;
-export declare function invokeBehaviorCommand(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, command: CommandHandlers, params?: Record<string, boolean | number | bigint | string | object | null>): Promise<boolean>;
+export declare function invokeBehaviorCommand(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, command: CommandHandlers, params?: Record<string, boolean | number | bigint | string | object | null>, waiterCondition?: () => boolean): Promise<boolean>;
 export declare function invokeSubscribeHandler(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, newValue: unknown, oldValue: unknown): Promise<boolean>;
 export declare function addRequiredClusterServers(endpoint: MatterbridgeEndpoint): void;
 export declare function addOptionalClusterServers(endpoint: MatterbridgeEndpoint): void;

package/dist/matterbridgeEndpointHelpers.js

@@ -48,6 +48,7 @@ import { ThermostatClient } from '@matter/node/behaviors/thermostat';
 import { ThermostatUserInterfaceConfigurationServer } from '@matter/node/behaviors/thermostat-user-interface-configuration';
 import { TotalVolatileOrganicCompoundsConcentrationMeasurementServer } from '@matter/node/behaviors/total-volatile-organic-compounds-concentration-measurement';
 import { UserLabelServer } from '@matter/node/behaviors/user-label';
+import { WaterTankLevelMonitoringServer } from '@matter/node/behaviors/water-tank-level-monitoring';
 import { WindowCoveringClient } from '@matter/node/behaviors/window-covering';
 import { getClusterNameById } from '@matter/types/cluster';
 import { ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
@@ -98,18 +99,21 @@ import { ScenesManagement } from '@matter/types/clusters/scenes-management';
 import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
 import { SoilMeasurement } from '@matter/types/clusters/soil-measurement';
 import { Switch } from '@matter/types/clusters/switch';
+import { TemperatureAlarm } from '@matter/types/clusters/temperature-alarm';
 import { TemperatureMeasurement } from '@matter/types/clusters/temperature-measurement';
 import { Thermostat } from '@matter/types/clusters/thermostat';
 import { ThermostatUserInterfaceConfiguration } from '@matter/types/clusters/thermostat-user-interface-configuration';
 import { TotalVolatileOrganicCompoundsConcentrationMeasurement } from '@matter/types/clusters/total-volatile-organic-compounds-concentration-measurement';
 import { UserLabel } from '@matter/types/clusters/user-label';
 import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
+import { WaterTankLevelMonitoring } from '@matter/types/clusters/water-tank-level-monitoring';
 import { WindowCovering } from '@matter/types/clusters/window-covering';
 import { NodeId } from '@matter/types/datatype';
 import { MeasurementType } from '@matter/types/globals';
 import { deepEqual } from '@matterbridge/utils/deep-equal';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { isValidArray } from '@matterbridge/utils/validate';
+import { waiter } from '@matterbridge/utils/wait';
 import { BLUE, CYAN, db, debugStringify, er, hk, nf, or, wr, YELLOW, zb } from 'node-ansi-logger';
 import { MatterbridgeBindingServer } from './behaviors/bindingServer.js';
 import { MatterbridgeBooleanStateConfigurationServer } from './behaviors/booleanStateConfigurationServer.js';
@@ -127,6 +131,7 @@ import { MatterbridgeOperationalStateServer } from './behaviors/operationalState
 import { MatterbridgePowerSourceServer } from './behaviors/powerSourceServer.js';
 import { MatterbridgePumpConfigurationAndControlServer } from './behaviors/pumpConfigurationAndControlServer.js';
 import { MatterbridgeSmokeCoAlarmServer } from './behaviors/smokeCoAlarmServer.js';
+import { MatterbridgeTemperatureAlarmServer } from './behaviors/temperatureAlarmServer.js';
 import { MatterbridgeThermostatServer } from './behaviors/thermostatServer.js';
 import { MatterbridgeValveConfigurationAndControlServer } from './behaviors/valveConfigurationAndControlServer.js';
 import { MatterbridgeWindowCoveringServer } from './behaviors/windowCoveringServer.js';
@@ -305,6 +310,8 @@ export function getBehaviourTypeFromClusterServerId(clusterId) {
         return BooleanStateServer.enable({ events: { stateChange: true } });
     if (clusterId === BooleanStateConfiguration.id)
         return MatterbridgeBooleanStateConfigurationServer;
+    if (clusterId === TemperatureAlarm.id)
+        return MatterbridgeTemperatureAlarmServer;
     if (clusterId === PowerTopology.id)
         return PowerTopologyServer.with('TreeTopology');
     if (clusterId === ElectricalPowerMeasurement.id)
@@ -331,6 +338,8 @@ export function getBehaviourTypeFromClusterServerId(clusterId) {
         return HepaFilterMonitoringServer.with('Condition', 'Warning', 'ReplacementProductList');
     if (clusterId === ActivatedCarbonFilterMonitoring.id)
         return ActivatedCarbonFilterMonitoringServer.with('Condition', 'Warning', 'ReplacementProductList');
+    if (clusterId === WaterTankLevelMonitoring.id)
+        return WaterTankLevelMonitoringServer.with('Condition', 'Warning', 'ReplacementProductList');
     if (clusterId === CarbonMonoxideConcentrationMeasurement.id)
         return CarbonMonoxideConcentrationMeasurementServer.with('NumericMeasurement');
     if (clusterId === CarbonDioxideConcentrationMeasurement.id)
@@ -422,7 +431,7 @@ export function getBehavior(endpoint, cluster) {
     }
     return behavior;
 }
-export async function invokeBehaviorCommand(endpoint, cluster, command, params) {
+export async function invokeBehaviorCommand(endpoint, cluster, command, params, waiterCondition) {
     const behaviorId = getBehavior(endpoint, cluster)?.id;
     if (!behaviorId) {
         endpoint.log?.error(`invokeBehaviorCommand error: command ${hk}${command}${er} not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
@@ -439,6 +448,11 @@ export async function invokeBehaviorCommand(endpoint, cluster, command, params)
             return;
         }
         void behavior?.['state'];
+        if (endpoint.behaviors.supported[behaviorId]?.lockOnInvoke) {
+            const transaction = agent.context.transaction;
+            await transaction.addResources(behavior);
+            await transaction.begin();
+        }
         const injectedSubject = { kind: 'node', id: NodeId(100) };
         const patchedContext = new Proxy(agent.context, { get: (t, k) => (k === 'fabric' ? 1 : k === 'subject' ? injectedSubject : Reflect.get(t, k, t)) });
         Object.defineProperty(behavior, 'context', { configurable: true, value: patchedContext });
@@ -450,6 +464,8 @@ export async function invokeBehaviorCommand(endpoint, cluster, command, params)
             delete behavior.context;
         }
     });
+    if (invoked && waiterCondition)
+        return await waiter(`invokeBehaviorCommand ${command}`, waiterCondition, false, 1000, 50);
     return invoked;
 }
 export async function invokeSubscribeHandler(endpoint, cluster, attribute, newValue, oldValue) {
@@ -538,6 +554,8 @@ export function addClusterServers(endpoint, serverList) {
         endpoint.createDefaultBooleanStateClusterServer();
     if (serverList.includes(BooleanStateConfiguration.id))
         endpoint.createDefaultBooleanStateConfigurationClusterServer();
+    if (serverList.includes(TemperatureAlarm.id))
+        endpoint.createDefaultTemperatureAlarmClusterServer();
     if (serverList.includes(PowerTopology.id))
         endpoint.createDefaultPowerTopologyClusterServer();
     if (serverList.includes(ElectricalPowerMeasurement.id))
@@ -564,6 +582,8 @@ export function addClusterServers(endpoint, serverList) {
         endpoint.createDefaultHepaFilterMonitoringClusterServer();
     if (serverList.includes(ActivatedCarbonFilterMonitoring.id))
         endpoint.createDefaultActivatedCarbonFilterMonitoringClusterServer();
+    if (serverList.includes(WaterTankLevelMonitoring.id))
+        endpoint.createDefaultWaterTankLevelMonitoringClusterServer();
     if (serverList.includes(CarbonMonoxideConcentrationMeasurement.id))
         endpoint.createDefaultCarbonMonoxideConcentrationMeasurementClusterServer();
     if (serverList.includes(CarbonDioxideConcentrationMeasurement.id))

package/dist/matterbridgeFactory.js

@@ -46,12 +46,15 @@ export async function getServerBehaviorFromClusterId(clusterId, features) {
     const base = mod[`${name}Server`];
     if (!base || !ClusterBehavior.isType(base) || isClientBehavior(base))
         return undefined;
+    const knownFeatureNames = new Set(Object.keys(base.cluster.features ?? {}).map((key) => pascalCase(key)));
     const featureNames = (Array.isArray(features)
         ? features
         : Object.entries(features ?? {})
             .filter(([, enabled]) => enabled)
-            .map(([key]) => key)).map((key) => pascalCase(key));
-    return featureNames.length > 0 ? base.with(...featureNames) : base;
+            .map(([key]) => key))
+        .map((key) => pascalCase(key))
+        .filter((key) => knownFeatureNames.has(key));
+    return features === undefined ? base : base.with(...featureNames);
 }
 export async function getClientBehaviorFromClusterId(clusterId) {
     const name = getClusterNameById(clusterId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.8-dev-20260902-361500d",
+  "version": "3.10.8-dev-20260903-014e30e",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -132,10 +132,10 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.8-dev-20260902-361500d",
-    "@matterbridge/thread": "3.10.8-dev-20260902-361500d",
-    "@matterbridge/types": "3.10.8-dev-20260902-361500d",
-    "@matterbridge/utils": "3.10.8-dev-20260902-361500d",
+    "@matterbridge/dgram": "3.10.8-dev-20260903-014e30e",
+    "@matterbridge/thread": "3.10.8-dev-20260903-014e30e",
+    "@matterbridge/types": "3.10.8-dev-20260903-014e30e",
+    "@matterbridge/utils": "3.10.8-dev-20260903-014e30e",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.7.0",