@matterbridge/core 3.10.12-dev-20261001-3745ad2 → 3.10.12-dev-20261002-6a30fb3

package/dist/behaviors/activatedCarbonFilterMonitoringServer.d.ts

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

package/dist/behaviors/activatedCarbonFilterMonitoringServer.js

@@ -1,4 +1,5 @@
 import { ActivatedCarbonFilterMonitoringServer } from '@matter/node/behaviors/activated-carbon-filter-monitoring';
+import { ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
 import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeActivatedCarbonFilterMonitoringServer extends ActivatedCarbonFilterMonitoringServer.with(ResourceMonitoring.Feature.Condition, ResourceMonitoring.Feature.Warning, ResourceMonitoring.Feature.ReplacementProductList) {
@@ -13,9 +14,10 @@ export class MatterbridgeActivatedCarbonFilterMonitoringServer extends Activated
             endpoint: this.endpoint,
             context: this.context,
         });
-        this.state.condition = 100;
+        this.state.condition = this.state.degradationDirection === ResourceMonitoring.DegradationDirection.Up ? 0 : 100;
         this.state.changeIndication = ResourceMonitoring.ChangeIndication.Ok;
         this.state.lastChangedTime = Math.floor(new Date().getTime() / 1000);
         device.log.debug(`MatterbridgeActivatedCarbonFilterMonitoringServer: resetCondition called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(ActivatedCarbonFilterMonitoring, 'resetCondition', {}, this.context);
     }
 }

package/dist/behaviors/bindingServer.d.ts

@@ -2,7 +2,9 @@ import type { Endpoint } from '@matter/main/node';
 import { BindingBehavior, BindingServer } from '@matter/node/behaviors/binding';
 import type { ClusterId } from '@matter/types';
 import type { Binding } from '@matter/types/clusters/binding';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class MatterbridgeBindingServer extends BindingServer {
+    readonly endpoint: MatterbridgeEndpoint;
     protected internal: MatterbridgeBindingServer.Internal;
     state: MatterbridgeBindingServer.State;
     initialize(): void;

package/dist/behaviors/booleanStateConfigurationServer.d.ts

@@ -1,6 +1,7 @@
 import type { MaybePromise } from '@matter/general';
 import { BooleanStateConfigurationServer } from '@matter/node/behaviors/boolean-state-configuration';
 import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 declare const MatterbridgeBooleanStateConfigurationServer_base: import("@matter/node").ClusterBehavior.Type<typeof BooleanStateConfigurationServer, import("@matter/types").ClusterType.WithSupportedFeatures<BooleanStateConfiguration, {
     alarmSuppress: true;
     audible: true;
@@ -10,6 +11,7 @@ declare const MatterbridgeBooleanStateConfigurationServer_base: import("@matter/
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "booleanStateConfiguration">;
 export declare class MatterbridgeBooleanStateConfigurationServer extends MatterbridgeBooleanStateConfigurationServer_base {
     #private;
+    readonly endpoint: MatterbridgeEndpoint;
     initialize(): MaybePromise;
     suppressAlarm(request: BooleanStateConfiguration.SuppressAlarmRequest): Promise<void>;
     enableDisableAlarm(request: BooleanStateConfiguration.EnableDisableAlarmRequest): Promise<void>;

package/dist/behaviors/booleanStateConfigurationServer.js

@@ -70,6 +70,7 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
         this.#assertSuppressAlarmAllowed(request.alarmsToSuppress);
         this.state.alarmsSuppressed = this.#mergeAlarmsSuppressed(request.alarmsToSuppress);
         device.log.debug(`MatterbridgeBooleanStateConfigurationServer: suppressAlarm called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(BooleanStateConfiguration, 'suppressAlarm', request, this.context);
     }
     async enableDisableAlarm(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -85,5 +86,6 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
         this.#assertAlarmModesSupported(request.alarmsToEnableDisable);
         this.#applyAlarmsEnabled(request.alarmsToEnableDisable);
         device.log.debug(`MatterbridgeBooleanStateConfigurationServer: enableDisableAlarm called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(BooleanStateConfiguration, 'enableDisableAlarm', request, this.context);
     }
 }

package/dist/behaviors/cameraAvStreamManagementServer.js

@@ -331,10 +331,11 @@ export class MatterbridgeCameraAvStreamManagementServer extends MatterbridgeCame
         this.endpoint.emitCommand(CameraAvStreamManagement, 'snapshotStreamDeallocate', request, this.context);
     }
     #resolveSnapshotSource() {
-        const endpoint = `(endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`;
         const fail = (reason) => {
-            this.endpoint.stateOf(MatterbridgeServer).log.error(`MatterbridgeCameraAvStreamManagementServer: cannot capture snapshot: ${reason} ${endpoint}`);
-            return new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: cannot capture snapshot: ${reason} ${endpoint}`, Status.Failure);
+            this.endpoint
+                .stateOf(MatterbridgeServer)
+                .log.error(`MatterbridgeCameraAvStreamManagementServer: cannot capture snapshot: ${reason} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            return new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: cannot capture snapshot: ${reason} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.Failure);
         };
         const sourceFor = (source, device, sourceOption, deviceOption) => {
             if (source === 'test')

package/dist/behaviors/deviceEnergyManagementModeServer.d.ts

@@ -1,5 +1,7 @@
 import { DeviceEnergyManagementModeServer } from '@matter/node/behaviors/device-energy-management-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class MatterbridgeDeviceEnergyManagementModeServer extends DeviceEnergyManagementModeServer {
+    readonly endpoint: MatterbridgeEndpoint;
     changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;
 }

package/dist/behaviors/deviceEnergyManagementModeServer.js

@@ -37,6 +37,8 @@ export class MatterbridgeDeviceEnergyManagementModeServer extends DeviceEnergyMa
             }
         }
         device.log.debug(`MatterbridgeDeviceEnergyManagementModeServer: changeToMode called with newMode ${request.newMode} => ${supported.label} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        return await super.changeToMode(request);
+        const response = await super.changeToMode(request);
+        this.endpoint.emitCommand(DeviceEnergyManagementMode, 'changeToMode', request, this.context);
+        return response;
     }
 }

package/dist/behaviors/deviceEnergyManagementServer.d.ts

@@ -1,6 +1,7 @@
 import { type Timer } from '@matter/general';
 import { DeviceEnergyManagementServer } from '@matter/node/behaviors/device-energy-management';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 declare const MatterbridgeDeviceEnergyManagementServer_base: import("@matter/node").ClusterBehavior.Type<typeof DeviceEnergyManagementServer, import("@matter/types").ClusterType.WithSupportedFeatures<DeviceEnergyManagement, {
     constraintBasedAdjustment: false;
     forecastAdjustment: false;
@@ -12,6 +13,7 @@ declare const MatterbridgeDeviceEnergyManagementServer_base: import("@matter/nod
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "deviceEnergyManagement">;
 export declare class MatterbridgeDeviceEnergyManagementServer extends MatterbridgeDeviceEnergyManagementServer_base {
     #private;
+    readonly endpoint: MatterbridgeEndpoint;
     protected internal: MatterbridgeDeviceEnergyManagementServer.Internal;
     initialize(): Promise<void>;
     powerAdjustRequest(request: DeviceEnergyManagement.PowerAdjustRequest): Promise<void>;

package/dist/behaviors/deviceEnergyManagementServer.js

@@ -49,6 +49,7 @@ export class MatterbridgeDeviceEnergyManagementServer extends DeviceEnergyManage
             this.events.powerAdjustStart.emit(undefined, this.context);
         }
         this.internal.powerAdjustCompletionTimer = Time.getTimer('DeviceEnergyManagement power adjust completion', Seconds(duration), this.callback(this.#completePowerAdjustmentOnTimeout, { lock: true })).start();
+        this.endpoint.emitCommand(DeviceEnergyManagement, 'powerAdjustRequest', request, this.context);
     }
     async cancelPowerAdjustRequest() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -66,6 +67,7 @@ export class MatterbridgeDeviceEnergyManagementServer extends DeviceEnergyManage
             throw new StatusResponseError(`MatterbridgeDeviceEnergyManagementServer: no power adjustment is currently active (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidInState);
         }
         this.#endPowerAdjustment(DeviceEnergyManagement.Cause.Cancelled);
+        this.endpoint.emitCommand(DeviceEnergyManagement, 'cancelPowerAdjustRequest', {}, this.context);
     }
     #handleOptOutStateChanged(optOutState) {
         if (this.state.esaState !== DeviceEnergyManagement.EsaState.PowerAdjustActive)

package/dist/behaviors/doorLockServer.d.ts

@@ -1,5 +1,6 @@
 import { DoorLockServer } from '@matter/node/behaviors/door-lock';
 import { DoorLock } from '@matter/types/clusters/door-lock';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/node").ClusterBehavior.Type<typeof DoorLockServer, import("@matter/types").ClusterType.WithSupportedFeatures<DoorLock, {
     aliroBleuwb: false;
     aliroProvisioning: false;
@@ -30,6 +31,7 @@ declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBeh
     yearDayAccessSchedules: true;
 }>, "doorLockAlarm" | "lockOperation" | "lockOperationError">, never>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/door-lock").DoorLockBaseServer.Internal, "doorLock">;
 export declare class MatterbridgeDoorLockServer extends MatterbridgeDoorLockServer_base {
+    readonly endpoint: MatterbridgeEndpoint;
     initialize(): void;
     lockDoor(request: DoorLock.LockDoorRequest): Promise<void>;
     unlockDoor(request: DoorLock.UnlockDoorRequest): Promise<void>;

package/dist/behaviors/doorLockServer.js

@@ -28,6 +28,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         }
         device.log.debug(`MatterbridgeDoorLockServer: lockDoor called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.lockDoor(request);
+        this.endpoint.emitCommand(DoorLock, 'lockDoor', request, this.context);
     }
     async unlockDoor(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -46,6 +47,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         }
         device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called ${this.state.autoRelockTime ? 'with ' + this.state.autoRelockTime + ' seconds' : 'without'} autoRelockTime (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.unlockDoor(request);
+        this.endpoint.emitCommand(DoorLock, 'unlockDoor', request, this.context);
     }
     async unlockWithTimeout(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -64,6 +66,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         }
         device.log.debug(`MatterbridgeDoorLockServer: unlockWithTimeout called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.unlockWithTimeout(request);
+        this.endpoint.emitCommand(DoorLock, 'unlockWithTimeout', request, this.context);
     }
     async setUser(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -78,6 +81,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         });
         device.log.debug(`MatterbridgeDoorLockServer: setUser called for userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.setUser(request);
+        this.endpoint.emitCommand(DoorLock, 'setUser', request, this.context);
     }
     async getUser(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -91,10 +95,13 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             context: this.context,
         });
         if (response !== undefined) {
+            this.endpoint.emitCommand(DoorLock, 'getUser', request, this.context);
             return response;
         }
         device.log.debug(`MatterbridgeDoorLockServer: getUser called for userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        return await super.getUser(request);
+        const result = await super.getUser(request);
+        this.endpoint.emitCommand(DoorLock, 'getUser', request, this.context);
+        return result;
     }
     async clearUser(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -109,6 +116,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         });
         device.log.debug(`MatterbridgeDoorLockServer: clearUser called for userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.clearUser(request);
+        this.endpoint.emitCommand(DoorLock, 'clearUser', request, this.context);
     }
     async setCredential(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -128,7 +136,9 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         if (request.operationType === DoorLock.DataOperationType.Add && this.auth.findCredential(request.credential.credentialType, request.credential.credentialIndex)) {
             throw new DoorLock.OccupiedError(`MatterbridgeDoorLockServer: add operation targets an occupied credential index (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         }
-        return await super.setCredential(request);
+        const result = await super.setCredential(request);
+        this.endpoint.emitCommand(DoorLock, 'setCredential', request, this.context);
+        return result;
     }
     async getCredentialStatus(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -142,7 +152,9 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             context: this.context,
         });
         device.log.debug(`MatterbridgeDoorLockServer: getCredentialStatus called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        return await super.getCredentialStatus(request);
+        const result = await super.getCredentialStatus(request);
+        this.endpoint.emitCommand(DoorLock, 'getCredentialStatus', request, this.context);
+        return result;
     }
     async clearCredential(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -157,6 +169,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         });
         device.log.debug(`MatterbridgeDoorLockServer: clearCredential called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.clearCredential(request);
+        this.endpoint.emitCommand(DoorLock, 'clearCredential', request, this.context);
     }
     async setWeekDaySchedule(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -171,6 +184,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         });
         device.log.debug(`MatterbridgeDoorLockServer: setWeekDaySchedule called for userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.setWeekDaySchedule(request);
+        this.endpoint.emitCommand(DoorLock, 'setWeekDaySchedule', request, this.context);
     }
     async getWeekDaySchedule(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -183,10 +197,14 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             endpoint: this.endpoint,
             context: this.context,
         });
-        if (response !== undefined)
+        if (response !== undefined) {
+            this.endpoint.emitCommand(DoorLock, 'getWeekDaySchedule', request, this.context);
             return response;
+        }
         device.log.debug(`MatterbridgeDoorLockServer: getWeekDaySchedule called for userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        return await super.getWeekDaySchedule(request);
+        const result = await super.getWeekDaySchedule(request);
+        this.endpoint.emitCommand(DoorLock, 'getWeekDaySchedule', request, this.context);
+        return result;
     }
     async clearWeekDaySchedule(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -201,6 +219,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         });
         device.log.debug(`MatterbridgeDoorLockServer: clearWeekDaySchedule called for userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.clearWeekDaySchedule(request);
+        this.endpoint.emitCommand(DoorLock, 'clearWeekDaySchedule', request, this.context);
     }
     async setYearDaySchedule(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -215,6 +234,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         });
         device.log.debug(`MatterbridgeDoorLockServer: setYearDaySchedule called for userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.setYearDaySchedule(request);
+        this.endpoint.emitCommand(DoorLock, 'setYearDaySchedule', request, this.context);
     }
     async getYearDaySchedule(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -227,10 +247,14 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             endpoint: this.endpoint,
             context: this.context,
         });
-        if (response !== undefined)
+        if (response !== undefined) {
+            this.endpoint.emitCommand(DoorLock, 'getYearDaySchedule', request, this.context);
             return response;
+        }
         device.log.debug(`MatterbridgeDoorLockServer: getYearDaySchedule called for userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        return await super.getYearDaySchedule(request);
+        const result = await super.getYearDaySchedule(request);
+        this.endpoint.emitCommand(DoorLock, 'getYearDaySchedule', request, this.context);
+        return result;
     }
     async clearYearDaySchedule(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -245,6 +269,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         });
         device.log.debug(`MatterbridgeDoorLockServer: clearYearDaySchedule called for userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.clearYearDaySchedule(request);
+        this.endpoint.emitCommand(DoorLock, 'clearYearDaySchedule', request, this.context);
     }
     async setHolidaySchedule(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -259,6 +284,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         });
         device.log.debug(`MatterbridgeDoorLockServer: setHolidaySchedule called for holidayIndex ${request.holidayIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.setHolidaySchedule(request);
+        this.endpoint.emitCommand(DoorLock, 'setHolidaySchedule', request, this.context);
     }
     async getHolidaySchedule(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -271,10 +297,14 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             endpoint: this.endpoint,
             context: this.context,
         });
-        if (response !== undefined)
+        if (response !== undefined) {
+            this.endpoint.emitCommand(DoorLock, 'getHolidaySchedule', request, this.context);
             return response;
+        }
         device.log.debug(`MatterbridgeDoorLockServer: getHolidaySchedule called for holidayIndex ${request.holidayIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        return await super.getHolidaySchedule(request);
+        const result = await super.getHolidaySchedule(request);
+        this.endpoint.emitCommand(DoorLock, 'getHolidaySchedule', request, this.context);
+        return result;
     }
     async clearHolidaySchedule(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -289,5 +319,6 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         });
         device.log.debug(`MatterbridgeDoorLockServer: clearHolidaySchedule called for holidayIndex ${request.holidayIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.clearHolidaySchedule(request);
+        this.endpoint.emitCommand(DoorLock, 'clearHolidaySchedule', request, this.context);
     }
 }

package/dist/behaviors/fanControlServer.d.ts

@@ -1,6 +1,7 @@
 import type { MaybePromise } from '@matter/general';
 import { FanControlServer } from '@matter/node/behaviors/fan-control';
 import { FanControl } from '@matter/types/clusters/fan-control';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 declare const MatterbridgeFanControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof FanControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<FanControl, {
     airflowDirection: false;
     auto: true;
@@ -11,6 +12,7 @@ declare const MatterbridgeFanControlServer_base: import("@matter/node").ClusterB
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "fanControl">;
 export declare class MatterbridgeFanControlServer extends MatterbridgeFanControlServer_base {
     #private;
+    readonly endpoint: MatterbridgeEndpoint;
     initialize(): MaybePromise;
     step(request: FanControl.StepRequest): Promise<void>;
 }

package/dist/behaviors/fanControlServer.js

@@ -196,5 +196,6 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
         device.log.debug(`MatterbridgeFanControlServer: step applied fanMode ${lookupFanMode[this.state.fanMode]}, percentCurrent ${this.state.percentCurrent}` +
             (this.features.multiSpeed ? `, speedCurrent ${this.state.speedCurrent}` : '') +
             ` (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(FanControl, 'step', request, this.context);
     }
 }

package/dist/behaviors/hepaFilterMonitoringServer.d.ts

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

package/dist/behaviors/hepaFilterMonitoringServer.js

@@ -1,4 +1,5 @@
 import { HepaFilterMonitoringServer } from '@matter/node/behaviors/hepa-filter-monitoring';
+import { HepaFilterMonitoring } from '@matter/types/clusters/hepa-filter-monitoring';
 import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeHepaFilterMonitoringServer extends HepaFilterMonitoringServer.with(ResourceMonitoring.Feature.Condition, ResourceMonitoring.Feature.Warning, ResourceMonitoring.Feature.ReplacementProductList) {
@@ -13,9 +14,10 @@ export class MatterbridgeHepaFilterMonitoringServer extends HepaFilterMonitoring
             endpoint: this.endpoint,
             context: this.context,
         });
-        this.state.condition = 100;
+        this.state.condition = this.state.degradationDirection === ResourceMonitoring.DegradationDirection.Up ? 0 : 100;
         this.state.changeIndication = ResourceMonitoring.ChangeIndication.Ok;
         this.state.lastChangedTime = Math.floor(new Date().getTime() / 1000);
         device.log.debug(`MatterbridgeHepaFilterMonitoringServer: resetCondition called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(HepaFilterMonitoring, 'resetCondition', {}, this.context);
     }
 }

package/dist/behaviors/identifyServer.d.ts

@@ -1,6 +1,8 @@
 import { IdentifyServer } from '@matter/node/behaviors/identify';
-import type { Identify } from '@matter/types/clusters/identify';
+import { Identify } from '@matter/types/clusters/identify';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class MatterbridgeIdentifyServer extends IdentifyServer {
+    readonly endpoint: MatterbridgeEndpoint;
     identify(request: Identify.IdentifyRequest): Promise<void>;
     triggerEffect(request: Identify.TriggerEffectRequest): Promise<void>;
 }

package/dist/behaviors/identifyServer.js

@@ -1,4 +1,5 @@
 import { IdentifyServer } from '@matter/node/behaviors/identify';
+import { Identify } from '@matter/types/clusters/identify';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeIdentifyServer extends IdentifyServer {
     async identify(request) {
@@ -14,6 +15,7 @@ export class MatterbridgeIdentifyServer extends IdentifyServer {
         });
         device.log.debug(`MatterbridgeIdentifyServer: identify called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.identify(request);
+        this.endpoint.emitCommand(Identify, 'identify', request, this.context);
     }
     async triggerEffect(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -28,5 +30,6 @@ export class MatterbridgeIdentifyServer extends IdentifyServer {
         });
         device.log.debug(`MatterbridgeIdentifyServer: triggerEffect called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.triggerEffect(request);
+        this.endpoint.emitCommand(Identify, 'triggerEffect', request, this.context);
     }
 }

package/dist/behaviors/modeSelectServer.d.ts

@@ -1,5 +1,7 @@
 import { ModeSelectServer } from '@matter/node/behaviors/mode-select';
-import type { ModeSelect } from '@matter/types/clusters/mode-select';
+import { ModeSelect } from '@matter/types/clusters/mode-select';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class MatterbridgeModeSelectServer extends ModeSelectServer {
+    readonly endpoint: MatterbridgeEndpoint;
     changeToMode(request: ModeSelect.ChangeToModeRequest): Promise<void>;
 }

package/dist/behaviors/modeSelectServer.js

@@ -1,4 +1,5 @@
 import { ModeSelectServer } from '@matter/node/behaviors/mode-select';
+import { ModeSelect } from '@matter/types/clusters/mode-select';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeModeSelectServer extends ModeSelectServer {
     async changeToMode(request) {
@@ -14,5 +15,6 @@ export class MatterbridgeModeSelectServer extends ModeSelectServer {
         });
         device.log.debug(`MatterbridgeModeSelectServer: changeToMode called with mode ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.changeToMode(request);
+        this.endpoint.emitCommand(ModeSelect, 'changeToMode', request, this.context);
     }
 }

package/dist/behaviors/occupancySensingServer.d.ts

@@ -1,6 +1,7 @@
 import type { MaybePromise } from '@matter/general';
 import { OccupancySensingServer } from '@matter/node/behaviors/occupancy-sensing';
 import { OccupancySensing } from '@matter/types/clusters/occupancy-sensing';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 declare const MatterbridgeOccupancySensingServer_base: import("@matter/node").ClusterBehavior.Type<typeof OccupancySensingServer, import("@matter/types").ClusterType.WithSupportedFeatures<OccupancySensing, {
     activeInfrared: false;
     occupancyEvent: false;
@@ -14,6 +15,7 @@ declare const MatterbridgeOccupancySensingServer_base: import("@matter/node").Cl
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "occupancySensing">;
 export declare class MatterbridgeOccupancySensingServer extends MatterbridgeOccupancySensingServer_base {
     #private;
+    readonly endpoint: MatterbridgeEndpoint;
     initialize(): MaybePromise;
 }
 export {};

package/dist/behaviors/operationalStateServer.d.ts

@@ -1,8 +1,10 @@
 import type { MaybePromise } from '@matter/general';
 import { OperationalStateServer } from '@matter/node/behaviors/operational-state';
 import { OperationalState } from '@matter/types/clusters/operational-state';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 declare const MatterbridgeOperationalStateServerBase: import("@matter/node").ClusterBehavior.Type<typeof OperationalStateServer, import("@matter/types").ClusterType.WithEnabledAttributes<import("@matter/types").ClusterType.WithEnabledEvents<OperationalState, "operationCompletion">, never>, import("@matter/types").ClusterType.Concrete, new () => {}, "operationalState">;
 export declare class MatterbridgeOperationalStateServer extends MatterbridgeOperationalStateServerBase {
+    readonly endpoint: MatterbridgeEndpoint;
     protected internal: MatterbridgeOperationalStateServer.Internal;
     initialize(): MaybePromise;
     pause(): Promise<OperationalState.OperationalCommandResponse>;

package/dist/behaviors/operationalStateServer.js

@@ -38,6 +38,7 @@ export class MatterbridgeOperationalStateServer extends MatterbridgeOperationalS
         this.internal.pausedSinceMs = Date.now();
         this.state.operationalState = OperationalState.OperationalStateEnum.Paused;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
+        this.endpoint.emitCommand(OperationalState, 'pause', {}, this.context);
         return {
             commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
         };
@@ -71,6 +72,7 @@ export class MatterbridgeOperationalStateServer extends MatterbridgeOperationalS
         this.events.operationCompletion.emit({ completionErrorCode: OperationalState.ErrorState.NoError, totalOperationalTime, pausedTime }, this.context);
         this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
+        this.endpoint.emitCommand(OperationalState, 'stop', {}, this.context);
         return {
             commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
         };
@@ -109,6 +111,7 @@ export class MatterbridgeOperationalStateServer extends MatterbridgeOperationalS
         }
         this.state.operationalState = OperationalState.OperationalStateEnum.Running;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
+        this.endpoint.emitCommand(OperationalState, 'start', {}, this.context);
         return {
             commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
         };
@@ -143,6 +146,7 @@ export class MatterbridgeOperationalStateServer extends MatterbridgeOperationalS
         }
         this.state.operationalState = this.internal.operationalStateBeforePause;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
+        this.endpoint.emitCommand(OperationalState, 'resume', {}, this.context);
         return {
             commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
         };

package/dist/behaviors/powerSourceServer.d.ts

@@ -1,4 +1,6 @@
 import { PowerSourceServer } from '@matter/node/behaviors/power-source';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class MatterbridgePowerSourceServer extends PowerSourceServer {
+    readonly endpoint: MatterbridgeEndpoint;
     initialize(): Promise<void>;
 }

package/dist/behaviors/pumpConfigurationAndControlServer.d.ts

@@ -1,6 +1,7 @@
 import type { MaybePromise } from '@matter/general';
 import { PumpConfigurationAndControlServer } from '@matter/node/behaviors/pump-configuration-and-control';
 import { PumpConfigurationAndControl } from '@matter/types/clusters/pump-configuration-and-control';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 declare const MatterbridgePumpConfigurationAndControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof PumpConfigurationAndControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<PumpConfigurationAndControl, {
     automatic: false;
     compensatedPressure: false;
@@ -12,6 +13,7 @@ declare const MatterbridgePumpConfigurationAndControlServer_base: import("@matte
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "pumpConfigurationAndControl">;
 export declare class MatterbridgePumpConfigurationAndControlServer extends MatterbridgePumpConfigurationAndControlServer_base {
     #private;
+    readonly endpoint: MatterbridgeEndpoint;
     protected internal: MatterbridgePumpConfigurationAndControlServer.Internal;
     initialize(): MaybePromise;
 }

package/dist/behaviors/serviceAreaServer.d.ts

@@ -1,5 +1,7 @@
 import { ServiceAreaServer } from '@matter/node/behaviors/service-area';
-import type { ServiceArea } from '@matter/types/clusters/service-area';
+import { ServiceArea } from '@matter/types/clusters/service-area';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class MatterbridgeServiceAreaServer extends ServiceAreaServer {
+    readonly endpoint: MatterbridgeEndpoint;
     selectAreas(request: ServiceArea.SelectAreasRequest): Promise<ServiceArea.SelectAreasResponse>;
 }

package/dist/behaviors/serviceAreaServer.js

@@ -1,4 +1,5 @@
 import { ServiceAreaServer } from '@matter/node/behaviors/service-area';
+import { ServiceArea } from '@matter/types/clusters/service-area';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
     async selectAreas(request) {
@@ -13,6 +14,9 @@ export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
             context: this.context,
         });
         device.log.debug(`MatterbridgeServiceAreaServer: selectAreas called with [${request.newAreas.join(', ')}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        return await super.selectAreas(request);
+        const response = await super.selectAreas(request);
+        if (response.status === ServiceArea.SelectAreasStatus.Success)
+            this.endpoint.emitCommand(ServiceArea, 'selectAreas', request, this.context);
+        return response;
     }
 }

package/dist/behaviors/smokeCoAlarmServer.d.ts

@@ -1,12 +1,14 @@
 import { type Timer } from '@matter/general';
 import { SmokeCoAlarmServer } from '@matter/node/behaviors/smoke-co-alarm';
 import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 declare const MatterbridgeSmokeCoAlarmServer_base: import("@matter/node").ClusterBehavior.Type<typeof SmokeCoAlarmServer, import("@matter/types").ClusterType.WithSupportedFeatures<SmokeCoAlarm, {
     coAlarm: true;
     smokeAlarm: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "smokeCoAlarm">;
 export declare class MatterbridgeSmokeCoAlarmServer extends MatterbridgeSmokeCoAlarmServer_base {
     #private;
+    readonly endpoint: MatterbridgeEndpoint;
     protected internal: MatterbridgeSmokeCoAlarmServer.Internal;
     static selfTestDurationSeconds: number;
     selfTestRequest(): Promise<void>;

package/dist/behaviors/smokeCoAlarmServer.js

@@ -17,12 +17,13 @@ export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(Smok
             context: this.context,
         });
         if (this.state.expressedState !== SmokeCoAlarm.ExpressedState.Normal || this.state.testInProgress) {
-            throw new StatusResponseError(`MatterbridgeSmokeCoAlarmServer: SmokeCOAlarm self-test is busy (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.Busy);
+            throw new StatusResponseError(`MatterbridgeSmokeCoAlarmServer: self-test is busy (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.Busy);
         }
         this.state.testInProgress = true;
         this.state.expressedState = SmokeCoAlarm.ExpressedState.Testing;
         this.#scheduleSelfTestComplete();
         device.log.debug(`MatterbridgeSmokeCoAlarmServer: selfTestRequest called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(SmokeCoAlarm, 'selfTestRequest', {}, this.context);
     }
     #stopSelfTestTimer() {
         this.internal.selfTestTimer?.stop();

package/dist/behaviors/switchServer.d.ts

@@ -1,4 +1,6 @@
 import { SwitchServer } from '@matter/node/behaviors/switch';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class MatterbridgeSwitchServer extends SwitchServer {
+    readonly endpoint: MatterbridgeEndpoint;
     initialize(): void;
 }