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

package/dist/behaviors/export.js

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

package/dist/behaviors/fanControlServer.d.ts

@@ -0,0 +1,7 @@
+import { FanControlServer } from '@matter/node/behaviors/fan-control';
+import { FanControl } from '@matter/types/clusters/fan-control';
+declare const MatterbridgeFanControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<FanControl.Cluster, readonly [FanControl.Feature.Auto, FanControl.Feature.Step]>, typeof FanControlServer, import("@matter/node/behaviors/fan-control").FanControlInterface>;
+export declare class MatterbridgeFanControlServer extends MatterbridgeFanControlServer_base {
+    step(request: FanControl.StepRequest): Promise<void>;
+}
+export {};

package/dist/behaviors/fanControlServer.js

@@ -0,0 +1,35 @@
+import { FanControlServer } from '@matter/node/behaviors/fan-control';
+import { FanControl } from '@matter/types/clusters/fan-control';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeFanControlServer extends FanControlServer.with(FanControl.Feature.Auto, FanControl.Feature.Step) {
+    async step(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stepping fan with direction ${request.direction} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('FanControl.step', {
+            command: 'step',
+            request,
+            cluster: FanControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        const lookupStepDirection = ['Increase', 'Decrease'];
+        device.log.debug(`MatterbridgeFanControlServer: step called with direction: ${lookupStepDirection[request.direction]} wrap: ${request.wrap} lowestOff: ${request.lowestOff}`);
+        device.log.debug(`- current percentCurrent: ${this.state.percentCurrent}`);
+        if (request.direction === FanControl.StepDirection.Increase) {
+            if (request.wrap && this.state.percentCurrent === 100) {
+                this.state.percentCurrent = request.lowestOff ? 0 : 10;
+            }
+            else
+                this.state.percentCurrent = Math.min(this.state.percentCurrent + 10, 100);
+        }
+        else if (request.direction === FanControl.StepDirection.Decrease) {
+            if (request.wrap && this.state.percentCurrent === (request.lowestOff ? 0 : 10)) {
+                this.state.percentCurrent = 100;
+            }
+            else
+                this.state.percentCurrent = Math.max(this.state.percentCurrent - 10, request.lowestOff ? 0 : 10);
+        }
+        device.log.debug('Set percentCurrent to:', this.state.percentCurrent);
+    }
+}

package/dist/behaviors/hepaFilterMonitoringServer.d.ts

@@ -0,0 +1,8 @@
+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';
+declare const MatterbridgeHepaFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<HepaFilterMonitoring.Cluster, readonly [ResourceMonitoring.Feature.Condition]>, typeof HepaFilterMonitoringServer, import("@matter/node/behaviors").ResourceMonitoringInterface>;
+export declare class MatterbridgeHepaFilterMonitoringServer extends MatterbridgeHepaFilterMonitoringServer_base {
+    resetCondition(): Promise<void>;
+}
+export {};

package/dist/behaviors/hepaFilterMonitoringServer.js

@@ -0,0 +1,20 @@
+import { HepaFilterMonitoringServer } from '@matter/node/behaviors/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) {
+    async resetCondition() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Resetting condition (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('HepaFilterMonitoring.resetCondition', {
+            command: 'resetCondition',
+            request: {},
+            cluster: MatterbridgeHepaFilterMonitoringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        this.state.condition = 100;
+        this.state.lastChangedTime = Math.floor(new Date().getTime() / 1000);
+        device.log.debug(`MatterbridgeHepaFilterMonitoringServer: resetCondition called`);
+    }
+}

package/dist/behaviors/identifyServer.d.ts

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

package/dist/behaviors/identifyServer.js

@@ -0,0 +1,32 @@
+import { IdentifyServer } from '@matter/node/behaviors/identify';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeIdentifyServer extends IdentifyServer {
+    async identify(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Identifying device for ${request.identifyTime} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('Identify.identify', {
+            command: 'identify',
+            request,
+            cluster: IdentifyServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeIdentifyServer: identify called`);
+        await super.identify(request);
+    }
+    async triggerEffect(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Triggering effect ${request.effectIdentifier} variant ${request.effectVariant} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('Identify.triggerEffect', {
+            command: 'triggerEffect',
+            request,
+            cluster: IdentifyServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeIdentifyServer: triggerEffect called`);
+        await super.triggerEffect(request);
+    }
+}

package/dist/behaviors/levelControlServer.d.ts

@@ -0,0 +1,6 @@
+import { LevelControlServer } from '@matter/node/behaviors/level-control';
+import { LevelControl } from '@matter/types/clusters/level-control';
+export declare class MatterbridgeLevelControlServer extends LevelControlServer {
+    moveToLevel(request: LevelControl.MoveToLevelRequest): Promise<void>;
+    moveToLevelWithOnOff(request: LevelControl.MoveToLevelRequest): Promise<void>;
+}

package/dist/behaviors/levelControlServer.js

@@ -0,0 +1,32 @@
+import { LevelControlServer } from '@matter/node/behaviors/level-control';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeLevelControlServer extends LevelControlServer {
+    async moveToLevel(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('LevelControl.moveToLevel', {
+            command: 'moveToLevel',
+            request,
+            cluster: LevelControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeLevelControlServer: moveToLevel called`);
+        await super.moveToLevel(request);
+    }
+    async moveToLevelWithOnOff(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('LevelControl.moveToLevelWithOnOff', {
+            command: 'moveToLevelWithOnOff',
+            request,
+            cluster: LevelControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeLevelControlServer: moveToLevelWithOnOff called`);
+        await super.moveToLevelWithOnOff(request);
+    }
+}

package/dist/behaviors/matterbridgeServer.d.ts

@@ -0,0 +1,14 @@
+import { Behavior } from '@matter/node';
+import { AnsiLogger } from 'node-ansi-logger';
+import { CommandHandler } from '../matterbridgeEndpointCommandHandler.js';
+export declare class MatterbridgeServer extends Behavior {
+    static readonly id = "matterbridge";
+    state: MatterbridgeServer.State;
+    initialize(): void;
+}
+export declare namespace MatterbridgeServer {
+    class State {
+        log: AnsiLogger;
+        commandHandler: CommandHandler;
+    }
+}

package/dist/behaviors/matterbridgeServer.js

@@ -0,0 +1,15 @@
+import { Behavior } from '@matter/node';
+export class MatterbridgeServer extends Behavior {
+    static id = 'matterbridge';
+    initialize() {
+        this.state.log.debug(`MatterbridgeServer initialized (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        super.initialize();
+    }
+}
+(function (MatterbridgeServer) {
+    class State {
+        log;
+        commandHandler;
+    }
+    MatterbridgeServer.State = State;
+})(MatterbridgeServer || (MatterbridgeServer = {}));

package/dist/behaviors/modeSelectServer.d.ts

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

package/dist/behaviors/modeSelectServer.js

@@ -0,0 +1,18 @@
+import { ModeSelectServer } from '@matter/node/behaviors/mode-select';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeModeSelectServer extends ModeSelectServer {
+    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('ModeSelect.changeToMode', {
+            command: 'changeToMode',
+            request,
+            cluster: ModeSelectServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeModeSelectServer: changeToMode called with mode: ${request.newMode}`);
+        await super.changeToMode(request);
+    }
+}

package/dist/behaviors/onOffServer.d.ts

@@ -0,0 +1,6 @@
+import { OnOffServer } from '@matter/node/behaviors/on-off';
+export declare class MatterbridgeOnOffServer extends OnOffServer {
+    on(): Promise<void>;
+    off(): Promise<void>;
+    toggle(): Promise<void>;
+}

package/dist/behaviors/onOffServer.js

@@ -0,0 +1,46 @@
+import { OnOffServer } from '@matter/node/behaviors/on-off';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeOnOffServer extends OnOffServer {
+    async on() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Switching device on (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('OnOff.on', {
+            command: 'on',
+            request: {},
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeOnOffServer: on called`);
+        await super.on();
+    }
+    async off() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Switching device off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('OnOff.off', {
+            command: 'off',
+            request: {},
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeOnOffServer: off called`);
+        await super.off();
+    }
+    async toggle() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Toggle device on/off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('OnOff.toggle', {
+            command: 'toggle',
+            request: {},
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeOnOffServer: toggle called`);
+        await super.toggle();
+    }
+}

package/dist/behaviors/operationalStateServer.d.ts

@@ -0,0 +1,10 @@
+import { MaybePromise } from '@matter/general';
+import { OperationalStateServer } from '@matter/node/behaviors/operational-state';
+import { OperationalState } from '@matter/types/clusters/operational-state';
+export declare class MatterbridgeOperationalStateServer extends OperationalStateServer {
+    initialize(): MaybePromise;
+    pause(): Promise<OperationalState.OperationalCommandResponse>;
+    stop(): Promise<OperationalState.OperationalCommandResponse>;
+    start(): Promise<OperationalState.OperationalCommandResponse>;
+    resume(): Promise<OperationalState.OperationalCommandResponse>;
+}

package/dist/behaviors/operationalStateServer.js

@@ -0,0 +1,84 @@
+import { OperationalStateServer } from '@matter/node/behaviors/operational-state';
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeOperationalStateServer extends OperationalStateServer {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.debug('MatterbridgeOperationalStateServer initialized: setting operational state to Stopped');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
+        super.initialize();
+    }
+    async pause() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Pause (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('OperationalState.pause', {
+            command: 'pause',
+            request: {},
+            cluster: OperationalStateServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug('MatterbridgeOperationalStateServer: pause called setting operational state to Paused');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Paused;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
+        };
+    }
+    async stop() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stop (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('OperationalState.stop', {
+            command: 'stop',
+            request: {},
+            cluster: OperationalStateServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug('MatterbridgeOperationalStateServer: stop called setting operational state to Stopped');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
+        };
+    }
+    async start() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Start (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('OperationalState.start', {
+            command: 'start',
+            request: {},
+            cluster: OperationalStateServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug('MatterbridgeOperationalStateServer: start called setting operational state to Running');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Running;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
+        };
+    }
+    async resume() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Resume (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('OperationalState.resume', {
+            command: 'resume',
+            request: {},
+            cluster: OperationalStateServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug('MatterbridgeOperationalStateServer: resume called setting operational state to Running');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Running;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
+        };
+    }
+}

package/dist/behaviors/pinDoorLockServer.d.ts

@@ -0,0 +1,32 @@
+import { DoorLockServer } from '@matter/node/behaviors/door-lock';
+import { DoorLock } from '@matter/types/clusters/door-lock';
+declare const MatterbridgePinDoorLockServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types").ClusterComposer.WithFeatures<DoorLock.Cluster, readonly [DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess]>, 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;
+        readonly setUserStatus: true;
+        readonly getUserStatus: true;
+        readonly setUserType: true;
+        readonly getUserType: true;
+    };
+}>>, import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<DoorLock.Cluster, readonly [DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess]>, typeof DoorLockServer, import("@matter/node/behaviors/door-lock").DoorLockInterface>, import("@matter/node/behaviors/door-lock").DoorLockInterface>;
+export declare class MatterbridgePinDoorLockServer extends MatterbridgePinDoorLockServer_base {
+    lockDoor(request: DoorLock.LockDoorRequest): Promise<void>;
+    unlockDoor(request: DoorLock.UnlockDoorRequest): Promise<void>;
+    unlockWithTimeout(request: DoorLock.UnlockWithTimeoutRequest): Promise<void>;
+    setPinCode(request: DoorLock.SetPinCodeRequest): Promise<void>;
+    getPinCode(request: DoorLock.GetPinCodeRequest): Promise<DoorLock.GetPinCodeResponse>;
+    clearPinCode(request: DoorLock.ClearPinCodeRequest): Promise<void>;
+    clearAllPinCodes(): Promise<void>;
+    setUserStatus(request: DoorLock.SetUserStatusRequest): Promise<void>;
+    getUserStatus(request: DoorLock.GetUserStatusRequest): Promise<DoorLock.GetUserStatusResponse>;
+    setUserType(request: DoorLock.SetUserTypeRequest): Promise<void>;
+    getUserType(request: DoorLock.GetUserTypeRequest): Promise<DoorLock.GetUserTypeResponse>;
+}
+export {};

package/dist/behaviors/pinDoorLockServer.js

@@ -0,0 +1,168 @@
+import { DoorLockServer } from '@matter/node/behaviors/door-lock';
+import { DoorLock } from '@matter/types/clusters/door-lock';
+import { getEnumDescription } from '@matterbridge/utils';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgePinDoorLockServer extends DoorLockServer.with(DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess).enable({
+    events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
+    commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true, setUserStatus: true, getUserStatus: true, setUserType: true, getUserType: true },
+}) {
+    async lockDoor(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Locking door with pincode ${request.pinCode ? '0x' + Buffer.from(request.pinCode).toString('hex') : 'N/A'} (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);
+        device.log.info(`Unlocking door with pincode ${request.pinCode ? '0x' + Buffer.from(request.pinCode).toString('hex') : 'N/A'} (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);
+    }
+    async unlockWithTimeout(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Unlocking door with pincode ${request.pinCode ? '0x' + Buffer.from(request.pinCode).toString('hex') : 'N/A'} 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;
+    }
+    async setPinCode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting pin code ${request.pin ? '0x' + Buffer.from(request.pin).toString('hex') : 'N/A'} for user ${request.userId} type ${getEnumDescription(DoorLock.UserType, request.userType)} status ${getEnumDescription(DoorLock.UserStatus, request.userStatus)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.setPinCode', {
+            command: 'setPinCode',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: setPinCode called for user ${request.userId}`);
+    }
+    async getPinCode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Getting pin code for user ${request.userId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.getPinCode', {
+            command: 'getPinCode',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        return {
+            userId: request.userId,
+            userStatus: DoorLock.UserStatus.Available,
+            userType: DoorLock.UserType.UnrestrictedUser,
+            pinCode: Buffer.from('1234'),
+        };
+    }
+    async clearPinCode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Clearing pin code for ${request.pinSlotIndex === 0xfffe ? 'all slots' : 'slot ' + request.pinSlotIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.clearPinCode', {
+            command: 'clearPinCode',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: clearPinCode called for ${request.pinSlotIndex === 0xfffe ? 'all PIN slots' : 'PIN slot ' + request.pinSlotIndex}`);
+    }
+    async clearAllPinCodes() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Clearing all pin codes (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.clearAllPinCodes', {
+            command: 'clearAllPinCodes',
+            request: {},
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug('MatterbridgeDoorLockServer: clearAllPinCodes called');
+    }
+    async setUserStatus(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting user status for user ${request.userId} to ${getEnumDescription(DoorLock.UserStatus, request.userStatus)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.setUserStatus', {
+            command: 'setUserStatus',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: setUserStatus called for user ${request.userId}`);
+    }
+    async getUserStatus(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Getting user status for user ${request.userId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.getUserStatus', {
+            command: 'getUserStatus',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: getUserStatus called for user ${request.userId}`);
+        return {
+            userId: request.userId,
+            userStatus: DoorLock.UserStatus.Available,
+        };
+    }
+    async setUserType(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting user type for user ${request.userId} to ${getEnumDescription(DoorLock.UserType, request.userType)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.setUserType', {
+            command: 'setUserType',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: setUserType called for user ${request.userId}`);
+    }
+    async getUserType(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Getting user type for user ${request.userId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.getUserType', {
+            command: 'getUserType',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: getUserType called for user ${request.userId}`);
+        return {
+            userId: request.userId,
+            userType: DoorLock.UserType.UnrestrictedUser,
+        };
+    }
+}

package/dist/behaviors/powerSourceServer.d.ts

@@ -0,0 +1,4 @@
+import { PowerSourceServer } from '@matter/node/behaviors/power-source';
+export declare class MatterbridgePowerSourceServer extends PowerSourceServer {
+    initialize(): Promise<void>;
+}

package/dist/behaviors/powerSourceServer.js

@@ -0,0 +1,21 @@
+import { PowerSourceServer } from '@matter/node/behaviors/power-source';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgePowerSourceServer extends PowerSourceServer {
+    async initialize() {
+        await super.initialize();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Initializing MatterbridgePowerSourceServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.state.endpointList = [this.endpoint.number];
+        this.endpoint.construction.onSuccess(async () => {
+            device.log.debug(`MatterbridgePowerSourceServer: endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber} construction completed`);
+            const endpointList = [this.endpoint.number];
+            for (const endpoint of this.endpoint.parts) {
+                if (endpoint.lifecycle.isReady) {
+                    endpointList.push(endpoint.number);
+                }
+            }
+            await this.endpoint.setStateOf(PowerSourceServer, { endpointList });
+            device.log.debug(`MatterbridgePowerSourceServer: endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber} construction completed with endpointList: ${endpointList.join(', ')}`);
+        });
+    }
+}

package/dist/behaviors/serviceAreaServer.d.ts

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