@matterbridge/core 3.10.8-dev-20260903-4ab4a0f → 3.10.8-dev-20260903-014e30e

package/dist/behaviors/export.d.ts

@@ -19,6 +19,7 @@ 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';

package/dist/behaviors/export.js

@@ -19,6 +19,7 @@ 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';

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/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) {

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,6 +372,10 @@ 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) });

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,7 @@ 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';

package/dist/export.js

@@ -21,6 +21,7 @@ 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';

package/dist/frontend.js

@@ -1202,6 +1202,8 @@ export class Frontend extends EventEmitter {
                 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

@@ -1265,6 +1265,7 @@ export const supportedClusters = [
     SoilMeasurement,
     Switch,
     TargetNavigator,
+    TemperatureAlarm,
     TemperatureControl,
     TemperatureMeasurement,
     Thermostat,

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,9 +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,6 +79,7 @@ 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';
@@ -278,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);
@@ -1285,6 +1286,25 @@ 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,
@@ -1313,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 },
         }), {
@@ -1332,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';
@@ -674,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';

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

@@ -99,6 +99,7 @@ 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';
@@ -112,6 +113,7 @@ 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';
@@ -129,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';
@@ -307,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)
@@ -426,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}`);
@@ -459,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) {
@@ -547,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))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.8-dev-20260903-4ab4a0f",
+  "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-20260903-4ab4a0f",
-    "@matterbridge/thread": "3.10.8-dev-20260903-4ab4a0f",
-    "@matterbridge/types": "3.10.8-dev-20260903-4ab4a0f",
-    "@matterbridge/utils": "3.10.8-dev-20260903-4ab4a0f",
+    "@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",