@matterbridge/core 3.7.2-dev-20260328-c77b608 → 3.7.2-dev-20260330-bb55c39

package/dist/behaviors/colorControlServer.js

@@ -0,0 +1,105 @@
+import { ColorControlServer } from '@matter/node/behaviors/color-control';
+import { ColorControl } from '@matter/types/clusters/color-control';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeColorControlServer extends ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature, ColorControl.Feature.EnhancedHue) {
+    async moveToHue(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting hue to ${request.hue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.moveToHue', {
+            command: 'moveToHue',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: moveToHue called`);
+        await super.moveToHue(request);
+    }
+    async enhancedMoveToHue(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting enhanced hue to ${request.enhancedHue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.enhancedMoveToHue', {
+            command: 'enhancedMoveToHue',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: enhancedMoveToHue called`);
+        await super.enhancedMoveToHue(request);
+    }
+    async moveToSaturation(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.moveToSaturation', {
+            command: 'moveToSaturation',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: moveToSaturation called`);
+        await super.moveToSaturation(request);
+    }
+    async moveToHueAndSaturation(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting hue to ${request.hue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.moveToHueAndSaturation', {
+            command: 'moveToHueAndSaturation',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: moveToHueAndSaturation called`);
+        await super.moveToHueAndSaturation(request);
+    }
+    async enhancedMoveToHueAndSaturation(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting enhanced hue to ${request.enhancedHue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.enhancedMoveToHueAndSaturation', {
+            command: 'enhancedMoveToHueAndSaturation',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: enhancedMoveToHueAndSaturation called`);
+        await super.enhancedMoveToHueAndSaturation(request);
+    }
+    async moveToColor(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting color to ${request.colorX}, ${request.colorY} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.moveToColor', {
+            command: 'moveToColor',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: moveToColor called`);
+        await super.moveToColor(request);
+    }
+    async moveToColorTemperature(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting color temperature to ${request.colorTemperatureMireds} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.moveToColorTemperature', {
+            command: 'moveToColorTemperature',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: moveToColorTemperature called`);
+        await super.moveToColorTemperature(request);
+    }
+}
+export class MatterbridgeEnhancedColorControlServer extends MatterbridgeColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.EnhancedHue, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature) {
+}

package/dist/behaviors/deviceEnergyManagementModeServer.d.ts

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

package/dist/behaviors/deviceEnergyManagementModeServer.js

@@ -0,0 +1,42 @@
+import { DeviceEnergyManagementServer } from '@matter/node/behaviors/device-energy-management';
+import { DeviceEnergyManagementModeServer } from '@matter/node/behaviors/device-energy-management-mode';
+import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
+import { DeviceEnergyManagementMode } from '@matter/types/clusters/device-energy-management-mode';
+import { ModeBase } from '@matter/types/clusters/mode-base';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeDeviceEnergyManagementModeServer extends DeviceEnergyManagementModeServer {
+    async changeToMode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DeviceEnergyManagementMode.changeToMode', {
+            command: 'changeToMode',
+            request,
+            cluster: DeviceEnergyManagementModeServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        const supported = this.state.supportedModes.find((mode) => mode.mode === request.newMode);
+        if (!supported) {
+            device.log.error(`MatterbridgeDeviceEnergyManagementModeServer changeToMode called with unsupported newMode: ${request.newMode}`);
+            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
+        }
+        this.state.currentMode = request.newMode;
+        if (supported.modeTags.find((tag) => tag.value === DeviceEnergyManagementMode.ModeTag.NoOptimization)) {
+            if (this.endpoint.behaviors.has(DeviceEnergyManagementServer)) {
+                await this.endpoint.setStateOf(DeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment), {
+                    optOutState: DeviceEnergyManagement.OptOutState.OptOut,
+                });
+            }
+        }
+        else {
+            if (this.endpoint.behaviors.has(DeviceEnergyManagementServer)) {
+                await this.endpoint.setStateOf(DeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment), {
+                    optOutState: DeviceEnergyManagement.OptOutState.NoOptOut,
+                });
+            }
+        }
+        device.log.debug(`MatterbridgeDeviceEnergyManagementModeServer changeToMode called with newMode ${request.newMode} => ${supported.label}`);
+        return await super.changeToMode(request);
+    }
+}

package/dist/behaviors/deviceEnergyManagementServer.d.ts

@@ -0,0 +1,306 @@
+import { DeviceEnergyManagementServer } from '@matter/node/behaviors/device-energy-management';
+import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
+declare const MatterbridgeDeviceEnergyManagementServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
+    readonly id: 152;
+    readonly name: "DeviceEnergyManagement";
+    readonly revision: 4;
+    readonly features: {
+        readonly powerAdjustment: import("@matter/types").BitFlag;
+        readonly powerForecastReporting: import("@matter/types").BitFlag;
+        readonly stateForecastReporting: import("@matter/types").BitFlag;
+        readonly startTimeAdjustment: import("@matter/types").BitFlag;
+        readonly pausable: import("@matter/types").BitFlag;
+        readonly forecastAdjustment: import("@matter/types").BitFlag;
+        readonly constraintBasedAdjustment: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly esaType: import("@matter/types").FixedAttribute<DeviceEnergyManagement.EsaType, any>;
+        readonly esaCanGenerate: import("@matter/types").FixedAttribute<boolean, any>;
+        readonly esaState: import("@matter/types").Attribute<DeviceEnergyManagement.EsaState, any>;
+        readonly absMinPower: import("@matter/types").Attribute<number | bigint, any>;
+        readonly absMaxPower: import("@matter/types").Attribute<number | bigint, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly powerAdjustment: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly powerAdjustmentCapability: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+                    powerAdjustCapability: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                        minPower: import("@matter/types").FieldType<number | bigint>;
+                        maxPower: import("@matter/types").FieldType<number | bigint>;
+                        minDuration: import("@matter/types").FieldType<number>;
+                        maxDuration: import("@matter/types").FieldType<number>;
+                    }>[] | null>;
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.PowerAdjustReason>;
+                }> | null, any>;
+            };
+            readonly commands: {
+                readonly powerAdjustRequest: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                    power: import("@matter/types").FieldType<number | bigint>;
+                    duration: import("@matter/types").FieldType<number>;
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.AdjustmentCause>;
+                }>, void, any>;
+                readonly cancelPowerAdjustRequest: import("@matter/types").Command<void, void, any>;
+            };
+            readonly events: {
+                readonly powerAdjustStart: import("@matter/types").Event<void, any>;
+                readonly powerAdjustEnd: import("@matter/types").Event<import("@matter/types").TypeFromFields<{
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.Cause>;
+                    duration: import("@matter/types").FieldType<number>;
+                    energyUse: import("@matter/types").FieldType<number | bigint>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly powerForecastReporting: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly forecast: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+                    forecastId: import("@matter/types").FieldType<number>;
+                    activeSlotNumber: import("@matter/types").FieldType<number | null>;
+                    startTime: import("@matter/types").FieldType<number>;
+                    endTime: import("@matter/types").FieldType<number>;
+                    earliestStartTime: import("@matter/types").OptionalFieldType<number | null>;
+                    latestEndTime: import("@matter/types").OptionalFieldType<number>;
+                    isPausable: import("@matter/types").FieldType<boolean>;
+                    slots: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                        minDuration: import("@matter/types").FieldType<number>;
+                        maxDuration: import("@matter/types").FieldType<number>;
+                        defaultDuration: import("@matter/types").FieldType<number>;
+                        elapsedSlotTime: import("@matter/types").FieldType<number>;
+                        remainingSlotTime: import("@matter/types").FieldType<number>;
+                        slotIsPausable: import("@matter/types").OptionalFieldType<boolean>;
+                        minPauseDuration: import("@matter/types").OptionalFieldType<number>;
+                        maxPauseDuration: import("@matter/types").OptionalFieldType<number>;
+                        manufacturerEsaState: import("@matter/types").OptionalFieldType<number>;
+                        nominalPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        minPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        maxPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        nominalEnergy: import("@matter/types").OptionalFieldType<number | bigint>;
+                        costs: import("@matter/types").OptionalFieldType<import("@matter/types").TypeFromFields<{
+                            costType: import("@matter/types").FieldType<DeviceEnergyManagement.CostType>;
+                            value: import("@matter/types").FieldType<number>;
+                            decimalPoints: import("@matter/types").FieldType<number>;
+                            currency: import("@matter/types").OptionalFieldType<number>;
+                        }>[]>;
+                        minPowerAdjustment: import("@matter/types").OptionalFieldType<number | bigint>;
+                        maxPowerAdjustment: import("@matter/types").OptionalFieldType<number | bigint>;
+                        minDurationAdjustment: import("@matter/types").OptionalFieldType<number>;
+                        maxDurationAdjustment: import("@matter/types").OptionalFieldType<number>;
+                    }>[]>;
+                    forecastUpdateReason: import("@matter/types").FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
+                }> | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly stateForecastReporting: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly forecast: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+                    forecastId: import("@matter/types").FieldType<number>;
+                    activeSlotNumber: import("@matter/types").FieldType<number | null>;
+                    startTime: import("@matter/types").FieldType<number>;
+                    endTime: import("@matter/types").FieldType<number>;
+                    earliestStartTime: import("@matter/types").OptionalFieldType<number | null>;
+                    latestEndTime: import("@matter/types").OptionalFieldType<number>;
+                    isPausable: import("@matter/types").FieldType<boolean>;
+                    slots: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                        minDuration: import("@matter/types").FieldType<number>;
+                        maxDuration: import("@matter/types").FieldType<number>;
+                        defaultDuration: import("@matter/types").FieldType<number>;
+                        elapsedSlotTime: import("@matter/types").FieldType<number>;
+                        remainingSlotTime: import("@matter/types").FieldType<number>;
+                        slotIsPausable: import("@matter/types").OptionalFieldType<boolean>;
+                        minPauseDuration: import("@matter/types").OptionalFieldType<number>;
+                        maxPauseDuration: import("@matter/types").OptionalFieldType<number>;
+                        manufacturerEsaState: import("@matter/types").OptionalFieldType<number>;
+                        nominalPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        minPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        maxPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        nominalEnergy: import("@matter/types").OptionalFieldType<number | bigint>;
+                        costs: import("@matter/types").OptionalFieldType<import("@matter/types").TypeFromFields<{
+                            costType: import("@matter/types").FieldType<DeviceEnergyManagement.CostType>;
+                            value: import("@matter/types").FieldType<number>;
+                            decimalPoints: import("@matter/types").FieldType<number>;
+                            currency: import("@matter/types").OptionalFieldType<number>;
+                        }>[]>;
+                        minPowerAdjustment: import("@matter/types").OptionalFieldType<number | bigint>;
+                        maxPowerAdjustment: import("@matter/types").OptionalFieldType<number | bigint>;
+                        minDurationAdjustment: import("@matter/types").OptionalFieldType<number>;
+                        maxDurationAdjustment: import("@matter/types").OptionalFieldType<number>;
+                    }>[]>;
+                    forecastUpdateReason: import("@matter/types").FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
+                }> | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly powerAdjustment: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly optOutState: import("@matter/types").Attribute<DeviceEnergyManagement.OptOutState, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly startTimeAdjustment: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly optOutState: import("@matter/types").Attribute<DeviceEnergyManagement.OptOutState, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly pausable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly optOutState: import("@matter/types").Attribute<DeviceEnergyManagement.OptOutState, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly forecastAdjustment: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly optOutState: import("@matter/types").Attribute<DeviceEnergyManagement.OptOutState, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly constraintBasedAdjustment: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly optOutState: import("@matter/types").Attribute<DeviceEnergyManagement.OptOutState, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly pausable: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly pauseRequest: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                    duration: import("@matter/types").FieldType<number>;
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.AdjustmentCause>;
+                }>, void, any>;
+                readonly resumeRequest: import("@matter/types").Command<void, void, any>;
+            };
+            readonly events: {
+                readonly paused: import("@matter/types").Event<void, any>;
+                readonly resumed: import("@matter/types").Event<import("@matter/types").TypeFromFields<{
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.Cause>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly startTimeAdjustment: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly startTimeAdjustRequest: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                    requestedStartTime: import("@matter/types").FieldType<number>;
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.AdjustmentCause>;
+                }>, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly forecastAdjustment: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly modifyForecastRequest: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                    forecastId: import("@matter/types").FieldType<number>;
+                    slotAdjustments: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                        slotIndex: import("@matter/types").FieldType<number>;
+                        nominalPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        duration: import("@matter/types").FieldType<number>;
+                    }>[]>;
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.AdjustmentCause>;
+                }>, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly constraintBasedAdjustment: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly requestConstraintBasedForecast: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                    constraints: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                        startTime: import("@matter/types").FieldType<number>;
+                        duration: import("@matter/types").FieldType<number>;
+                        nominalPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        maximumEnergy: import("@matter/types").OptionalFieldType<number | bigint>;
+                        loadControl: import("@matter/types").OptionalFieldType<number>;
+                    }>[]>;
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.AdjustmentCause>;
+                }>, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly startTimeAdjustment: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly cancelRequest: import("@matter/types").Command<void, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly forecastAdjustment: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly cancelRequest: import("@matter/types").Command<void, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly constraintBasedAdjustment: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly cancelRequest: import("@matter/types").Command<void, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly staTrue: true;
+            readonly pauTrue: false;
+            readonly faTrue: false;
+            readonly conTrue: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly powerForecastReporting: true;
+            readonly stateForecastReporting: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly powerForecastReporting: false;
+            readonly stateForecastReporting: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment]>, typeof DeviceEnergyManagementServer, import("@matter/node/behaviors/device-energy-management").DeviceEnergyManagementInterface>;
+export declare class MatterbridgeDeviceEnergyManagementServer extends MatterbridgeDeviceEnergyManagementServer_base {
+    powerAdjustRequest(request: DeviceEnergyManagement.PowerAdjustRequest): Promise<void>;
+    cancelPowerAdjustRequest(): Promise<void>;
+}
+export {};

package/dist/behaviors/deviceEnergyManagementServer.js

@@ -0,0 +1,31 @@
+import { DeviceEnergyManagementServer } from '@matter/node/behaviors/device-energy-management';
+import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeDeviceEnergyManagementServer extends DeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment) {
+    async powerAdjustRequest(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Adjusting power to ${request.power} duration ${request.duration} cause ${request.cause} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DeviceEnergyManagement.powerAdjustRequest', {
+            command: 'powerAdjustRequest',
+            request,
+            cluster: DeviceEnergyManagementServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDeviceEnergyManagementServer powerAdjustRequest called with power ${request.power} duration ${request.duration} cause ${request.cause}`);
+    }
+    async cancelPowerAdjustRequest() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Cancelling power adjustment (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DeviceEnergyManagement.cancelPowerAdjustRequest', {
+            command: 'cancelPowerAdjustRequest',
+            request: {},
+            cluster: DeviceEnergyManagementServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDeviceEnergyManagementServer cancelPowerAdjustRequest called`);
+    }
+}

package/dist/behaviors/doorLockServer.d.ts

@@ -0,0 +1,28 @@
+import { DoorLockServer } from '@matter/node/behaviors/door-lock';
+import { DoorLock } from '@matter/types/clusters/door-lock';
+declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<DoorLock.Cluster, import("@matter/types").ClusterTypeModifier.ElementFlagAlterations<{
+    readonly events: {
+        readonly doorLockAlarm: true;
+        readonly lockOperation: true;
+        readonly lockOperationError: true;
+    };
+    readonly commands: {
+        readonly lockDoor: true;
+        readonly unlockDoor: true;
+        readonly unlockWithTimeout: true;
+    };
+}>>, typeof DoorLockServer, import("@matter/node/behaviors/door-lock").DoorLockInterface>;
+export declare class MatterbridgeDoorLockServer extends MatterbridgeDoorLockServer_base {
+    protected internal: MatterbridgeDoorLockServer.Internal;
+    initialize(): Promise<void>;
+    lockDoor(request: DoorLock.LockDoorRequest): Promise<void>;
+    unlockDoor(request: DoorLock.UnlockDoorRequest): Promise<void>;
+    unlockWithTimeout(request: DoorLock.UnlockWithTimeoutRequest): Promise<void>;
+}
+export declare namespace MatterbridgeDoorLockServer {
+    class Internal {
+        enableTimeout: boolean;
+        unlockTimeout: NodeJS.Timeout | undefined;
+    }
+}
+export {};

package/dist/behaviors/doorLockServer.js

@@ -0,0 +1,97 @@
+import { DoorLockServer } from '@matter/node/behaviors/door-lock';
+import { DoorLock } from '@matter/types/clusters/door-lock';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeDoorLockServer extends DoorLockServer.enable({
+    events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
+    commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true },
+}) {
+    async initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Initializing MatterbridgeDoorLockServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await super.initialize();
+    }
+    async lockDoor(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (!this.state.actuatorEnabled) {
+            device.log.warn(`Actuator disabled, cannot lock door (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            return;
+        }
+        device.log.info(`Locking door (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.lockDoor', {
+            command: 'lockDoor',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: lockDoor called`);
+        await super.lockDoor(request);
+    }
+    async unlockDoor(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (!this.state.actuatorEnabled) {
+            device.log.warn(`Actuator disabled, cannot unlock door (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            return;
+        }
+        device.log.info(`Unlocking door (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.unlockDoor', {
+            command: 'unlockDoor',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called`);
+        await super.unlockDoor(request);
+        if (!this.internal.enableTimeout)
+            return;
+        if (this.state.autoRelockTime) {
+            clearTimeout(this.internal.unlockTimeout);
+            this.internal.unlockTimeout = setTimeout(async () => {
+                this.internal.unlockTimeout = undefined;
+                const device = this.endpoint.stateOf(MatterbridgeServer);
+                const state = this.endpoint.stateOf(MatterbridgeDoorLockServer);
+                device.log.info(`Auto-relocking door after ${state.autoRelockTime} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+                await this.endpoint.act((agent) => agent.get(MatterbridgeDoorLockServer).lockDoor({ pinCode: request.pinCode }));
+            }, this.state.autoRelockTime * 1000).unref();
+        }
+    }
+    async unlockWithTimeout(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (!this.state.actuatorEnabled) {
+            device.log.warn(`Actuator disabled, cannot unlock door with timeout (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            return;
+        }
+        device.log.info(`Unlocking door with timeout ${request.timeout} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.unlockWithTimeout', {
+            command: 'unlockWithTimeout',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: unlockWithTimeout called`);
+        this.state.lockState = DoorLock.LockState.Unlocked;
+        if (!this.internal.enableTimeout)
+            return;
+        if (request.timeout) {
+            clearTimeout(this.internal.unlockTimeout);
+            this.internal.unlockTimeout = setTimeout(async () => {
+                this.internal.unlockTimeout = undefined;
+                const device = this.endpoint.stateOf(MatterbridgeServer);
+                device.log.info(`Locking door after ${request.timeout} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+                await this.endpoint.act((agent) => agent.get(MatterbridgeDoorLockServer).lockDoor({ pinCode: request.pinCode }));
+            }, request.timeout * 1000).unref();
+        }
+    }
+}
+(function (MatterbridgeDoorLockServer) {
+    class Internal {
+        enableTimeout = true;
+        unlockTimeout;
+    }
+    MatterbridgeDoorLockServer.Internal = Internal;
+})(MatterbridgeDoorLockServer || (MatterbridgeDoorLockServer = {}));

package/dist/behaviors/export.d.ts

@@ -1 +1,24 @@
-export {};
+export * from './activatedCarbonFilterMonitoringServer.js';
+export * from './bindingServer.js';
+export * from './booleanStateConfigurationServer.js';
+export * from './colorControlServer.js';
+export * from './deviceEnergyManagementModeServer.js';
+export * from './deviceEnergyManagementServer.js';
+export * from './doorLockServer.js';
+export * from './fanControlServer.js';
+export * from './hepaFilterMonitoringServer.js';
+export * from './identifyServer.js';
+export * from './levelControlServer.js';
+export * from './matterbridgeServer.js';
+export * from './modeSelectServer.js';
+export * from './onOffServer.js';
+export * from './operationalStateServer.js';
+export * from './pinDoorLockServer.js';
+export * from './powerSourceServer.js';
+export * from './serviceAreaServer.js';
+export * from './smokeCoAlarmServer.js';
+export * from './switchServer.js';
+export * from './thermostatServer.js';
+export * from './userPinDoorLockServer.js';
+export * from './valveConfigurationAndControlServer.js';
+export * from './windowCoveringServer.js';