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

package/dist/matterbridgeBehaviorsServer.js

@@ -1,1222 +0,0 @@
-import { Behavior } from '@matter/node';
-import { ActivatedCarbonFilterMonitoringServer } from '@matter/node/behaviors/activated-carbon-filter-monitoring';
-import { BooleanStateConfigurationServer } from '@matter/node/behaviors/boolean-state-configuration';
-import { ColorControlServer } from '@matter/node/behaviors/color-control';
-import { DeviceEnergyManagementServer } from '@matter/node/behaviors/device-energy-management';
-import { DeviceEnergyManagementModeServer } from '@matter/node/behaviors/device-energy-management-mode';
-import { DoorLockServer } from '@matter/node/behaviors/door-lock';
-import { FanControlServer } from '@matter/node/behaviors/fan-control';
-import { HepaFilterMonitoringServer } from '@matter/node/behaviors/hepa-filter-monitoring';
-import { IdentifyServer } from '@matter/node/behaviors/identify';
-import { LevelControlServer } from '@matter/node/behaviors/level-control';
-import { ModeSelectServer } from '@matter/node/behaviors/mode-select';
-import { OnOffServer } from '@matter/node/behaviors/on-off';
-import { OperationalStateServer } from '@matter/node/behaviors/operational-state';
-import { PowerSourceServer } from '@matter/node/behaviors/power-source';
-import { ServiceAreaServer } from '@matter/node/behaviors/service-area';
-import { SmokeCoAlarmServer } from '@matter/node/behaviors/smoke-co-alarm';
-import { SwitchServer } from '@matter/node/behaviors/switch';
-import { ThermostatServer } from '@matter/node/behaviors/thermostat';
-import { ValveConfigurationAndControlServer } from '@matter/node/behaviors/valve-configuration-and-control';
-import { WindowCoveringServer } from '@matter/node/behaviors/window-covering';
-import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
-import { ColorControl } from '@matter/types/clusters/color-control';
-import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
-import { DeviceEnergyManagementMode } from '@matter/types/clusters/device-energy-management-mode';
-import { DoorLock } from '@matter/types/clusters/door-lock';
-import { FanControl } from '@matter/types/clusters/fan-control';
-import { ModeBase } from '@matter/types/clusters/mode-base';
-import { OperationalState } from '@matter/types/clusters/operational-state';
-import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
-import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
-import { Thermostat } from '@matter/types/clusters/thermostat';
-import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
-import { WindowCovering } from '@matter/types/clusters/window-covering';
-import { StatusResponse } from '@matter/types/common';
-import { FabricIndex } from '@matter/types/datatype';
-import { Status } from '@matter/types/globals';
-import { getEnumDescription } from '@matterbridge/utils';
-import { debugStringify } from 'node-ansi-logger';
-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 = {}));
-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(', ')}`);
-        });
-    }
-}
-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,
-        });
-        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,
-        });
-        device.log.debug(`MatterbridgeIdentifyServer: triggerEffect called`);
-        await super.triggerEffect(request);
-    }
-}
-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,
-        });
-        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,
-        });
-        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,
-        });
-        device.log.debug(`MatterbridgeOnOffServer: toggle called`);
-        await super.toggle();
-    }
-}
-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,
-        });
-        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,
-        });
-        device.log.debug(`MatterbridgeLevelControlServer: moveToLevelWithOnOff called`);
-        await super.moveToLevelWithOnOff(request);
-    }
-}
-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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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) {
-}
-export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift, WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt) {
-    lookupMovementStatus = ['Stopped', 'Opening', 'Closing', 'Unknown'];
-    async initialize() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Initializing MatterbridgeWindowCoveringServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        this.internal.disableOperationalModeHandling = true;
-        await super.initialize();
-    }
-    async upOrOpen() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Opening cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('WindowCovering.upOrOpen', {
-            command: 'upOrOpen',
-            request: {},
-            cluster: WindowCoveringServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeWindowCoveringServer: upOrOpen called`);
-        await super.upOrOpen();
-        device.log.debug(`MatterbridgeWindowCoveringServer: upOrOpen result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} status global ${this.lookupMovementStatus[this.state.operationalStatus.global ?? 3]} lift ${this.lookupMovementStatus[this.state.operationalStatus.lift ?? 3]} tilt ${this.lookupMovementStatus[this.state.operationalStatus.tilt ?? 3]}`);
-    }
-    async downOrClose() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Closing cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('WindowCovering.downOrClose', {
-            command: 'downOrClose',
-            request: {},
-            cluster: WindowCoveringServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeWindowCoveringServer: downOrClose called`);
-        await super.downOrClose();
-        device.log.debug(`MatterbridgeWindowCoveringServer: downOrClose result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} status global ${this.lookupMovementStatus[this.state.operationalStatus.global ?? 3]} lift ${this.lookupMovementStatus[this.state.operationalStatus.lift ?? 3]} tilt ${this.lookupMovementStatus[this.state.operationalStatus.tilt ?? 3]}`);
-    }
-    async stopMotion() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stopping cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('WindowCovering.stopMotion', {
-            command: 'stopMotion',
-            request: {},
-            cluster: WindowCoveringServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeWindowCoveringServer: stopMotion called`);
-        await super.stopMotion();
-        device.log.debug(`MatterbridgeWindowCoveringServer: stopMotion result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} status global ${this.lookupMovementStatus[this.state.operationalStatus.global ?? 3]} lift ${this.lookupMovementStatus[this.state.operationalStatus.lift ?? 3]} tilt ${this.lookupMovementStatus[this.state.operationalStatus.tilt ?? 3]}`);
-    }
-    async goToLiftPercentage(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting cover lift percentage to ${request.liftPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('WindowCovering.goToLiftPercentage', {
-            command: 'goToLiftPercentage',
-            request,
-            cluster: WindowCoveringServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeWindowCoveringServer: goToLiftPercentage with ${request.liftPercent100thsValue}`);
-        await super.goToLiftPercentage(request);
-        device.log.debug(`MatterbridgeWindowCoveringServer: goToLiftPercentage result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} status global ${this.lookupMovementStatus[this.state.operationalStatus.global ?? 3]} lift ${this.lookupMovementStatus[this.state.operationalStatus.lift ?? 3]} tilt ${this.lookupMovementStatus[this.state.operationalStatus.tilt ?? 3]}`);
-    }
-    async goToTiltPercentage(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting cover tilt percentage to ${request.tiltPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('WindowCovering.goToTiltPercentage', {
-            command: 'goToTiltPercentage',
-            request,
-            cluster: WindowCoveringServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeWindowCoveringServer: goToTiltPercentage with ${request.tiltPercent100thsValue}`);
-        await super.goToTiltPercentage(request);
-        device.log.debug(`MatterbridgeWindowCoveringServer: goToTiltPercentage result target ${this.state.targetPositionTiltPercent100ths} current ${this.state.currentPositionTiltPercent100ths} status global ${this.lookupMovementStatus[this.state.operationalStatus.global ?? 3]} lift ${this.lookupMovementStatus[this.state.operationalStatus.lift ?? 3]} tilt ${this.lookupMovementStatus[this.state.operationalStatus.tilt ?? 3]}`);
-    }
-    async handleMovement(type, reversed, direction, targetPercent100ths) {
-    }
-}
-export class MatterbridgeLiftWindowCoveringServer extends MatterbridgeWindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift) {
-}
-export class MatterbridgeLiftTiltWindowCoveringServer extends MatterbridgeWindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift, WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt) {
-}
-export class MatterbridgeDoorLockServer extends DoorLockServer.enable({
-    events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
-    commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true },
-}) {
-    async lockDoor(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        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,
-        });
-        device.log.debug(`MatterbridgeDoorLockServer: lockDoor called`);
-        await super.lockDoor(request);
-    }
-    async unlockDoor(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        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,
-        });
-        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 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,
-        });
-        device.log.debug(`MatterbridgeDoorLockServer: unlockWithTimeout called`);
-        this.state.lockState = DoorLock.LockState.Unlocked;
-    }
-}
-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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        device.log.debug(`MatterbridgeDoorLockServer: getUserType called for user ${request.userId}`);
-        return {
-            userId: request.userId,
-            userType: DoorLock.UserType.UnrestrictedUser,
-        };
-    }
-}
-export class MatterbridgeUserPinDoorLockServer extends DoorLockServer.with(DoorLock.Feature.User, DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess).enable({
-    events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
-    commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true },
-}) {
-    getAccessingFabricIndex() {
-        let fabricIndex;
-        try {
-            fabricIndex = this.context.fabric;
-        }
-        catch {
-            return null;
-        }
-        if (fabricIndex === undefined || fabricIndex === FabricIndex.NO_FABRIC) {
-            return null;
-        }
-        return fabricIndex;
-    }
-    findStoredCredential(credential) {
-        for (const user of this.internal.users) {
-            for (const storedCredential of user.credentials ?? []) {
-                if (storedCredential.credentialType === credential.credentialType && storedCredential.credentialIndex === credential.credentialIndex) {
-                    return { user, storedCredential };
-                }
-            }
-        }
-        return null;
-    }
-    getStoredCredentialStateDebug() {
-        if (this.internal.users.length === 0) {
-            return 'no users';
-        }
-        return this.internal.users
-            .map((user) => {
-            const credentials = user.credentials
-                ?.map((credential) => `${getEnumDescription(DoorLock.CredentialType, credential.credentialType)}:${credential.credentialIndex}=0x${Buffer.from(credential.credentialData).toString('hex')}`)
-                .join(', ') ?? 'none';
-            return `user ${user.userIndex} [${credentials}]`;
-        })
-            .join('; ');
-    }
-    logStoredCredentialState(reason) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.debug(`MatterbridgeDoorLockServer: ${reason}; stored credentials: ${this.getStoredCredentialStateDebug()}`);
-    }
-    hasMatchingPinCredential(pinCode) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.debug(`MatterbridgeDoorLockServer: checking remote PIN 0x${Buffer.from(pinCode).toString('hex')} against ${this.internal.users.length} user(s)`);
-        for (const user of this.internal.users) {
-            for (const storedCredential of user.credentials ?? []) {
-                if (storedCredential.credentialType !== DoorLock.CredentialType.Pin) {
-                    continue;
-                }
-                if (Buffer.from(storedCredential.credentialData).equals(Buffer.from(pinCode))) {
-                    device.log.debug(`MatterbridgeDoorLockServer: remote PIN matched userIndex ${user.userIndex} credentialIndex ${storedCredential.credentialIndex}`);
-                    return true;
-                }
-            }
-        }
-        device.log.debug(`MatterbridgeDoorLockServer: remote PIN 0x${Buffer.from(pinCode).toString('hex')} did not match any stored PIN credential`);
-        return false;
-    }
-    validateRemotePinCode(pinCode) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        if (!this.state.requirePinForRemoteOperation) {
-            device.log.debug('MatterbridgeDoorLockServer: skipping remote PIN validation because requirePinForRemoteOperation is false');
-            return;
-        }
-        if (pinCode === undefined) {
-            device.log.debug('MatterbridgeDoorLockServer: rejecting remote operation because the request did not include a PIN');
-            this.logStoredCredentialState('remote PIN validation failed');
-            throw new StatusResponse.FailureError('Missing or invalid PIN code for remote operation');
-        }
-        device.log.debug(`MatterbridgeDoorLockServer: validating remote PIN 0x${Buffer.from(pinCode).toString('hex')}`);
-        if (pinCode === undefined || !this.hasMatchingPinCredential(pinCode)) {
-            this.logStoredCredentialState('remote PIN validation failed');
-            throw new StatusResponse.FailureError('Missing or invalid PIN code for remote operation');
-        }
-        device.log.debug(`MatterbridgeDoorLockServer: accepted remote PIN 0x${Buffer.from(pinCode).toString('hex')}`);
-    }
-    getNextOccupiedCredentialIndex(credential) {
-        let nextCredentialIndex = null;
-        for (const user of this.internal.users) {
-            for (const storedCredential of user.credentials ?? []) {
-                if (storedCredential.credentialType !== credential.credentialType || storedCredential.credentialIndex <= credential.credentialIndex) {
-                    continue;
-                }
-                if (nextCredentialIndex === null || storedCredential.credentialIndex < nextCredentialIndex) {
-                    nextCredentialIndex = storedCredential.credentialIndex;
-                }
-            }
-        }
-        return nextCredentialIndex;
-    }
-    upsertStoredCredential(userIndex, credential, credentialData) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        if (userIndex === null) {
-            device.log.debug(`MatterbridgeDoorLockServer: not storing credentialType ${getEnumDescription(DoorLock.CredentialType, credential.credentialType)} credentialIndex ${credential.credentialIndex} because userIndex is null`);
-            return;
-        }
-        const user = this.internal.users.find((storedUser) => storedUser.userIndex === userIndex);
-        if (!user) {
-            device.log.debug(`MatterbridgeDoorLockServer: not storing credentialType ${getEnumDescription(DoorLock.CredentialType, credential.credentialType)} credentialIndex ${credential.credentialIndex} because userIndex ${userIndex} was not found`);
-            return;
-        }
-        let removedCredentials = 0;
-        for (const storedUser of this.internal.users) {
-            const nextCredentials = storedUser.credentials?.filter((storedCredential) => storedCredential.credentialType !== credential.credentialType || storedCredential.credentialIndex !== credential.credentialIndex) ?? null;
-            removedCredentials += (storedUser.credentials?.length ?? 0) - (nextCredentials?.length ?? 0);
-            storedUser.credentials = nextCredentials && nextCredentials.length > 0 ? nextCredentials : null;
-        }
-        if (!user.credentials) {
-            user.credentials = [];
-        }
-        user.credentials.push({
-            credentialType: credential.credentialType,
-            credentialIndex: credential.credentialIndex,
-            credentialData: Uint8Array.from(credentialData),
-        });
-        device.log.debug(`MatterbridgeDoorLockServer: stored credentialType ${getEnumDescription(DoorLock.CredentialType, credential.credentialType)} credentialIndex ${credential.credentialIndex} for userIndex ${userIndex} (removed ${removedCredentials} replaced credential(s))`);
-        this.logStoredCredentialState('credential stored');
-    }
-    clearStoredCredential(credential) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        for (const user of this.internal.users) {
-            if (credential === null) {
-                user.credentials = null;
-                continue;
-            }
-            const nextCredentials = user.credentials?.filter((storedCredential) => storedCredential.credentialType !== credential.credentialType || storedCredential.credentialIndex !== credential.credentialIndex) ?? null;
-            user.credentials = nextCredentials && nextCredentials.length > 0 ? nextCredentials : null;
-        }
-        device.log.debug(`MatterbridgeDoorLockServer: cleared ${credential ? `${getEnumDescription(DoorLock.CredentialType, credential.credentialType)} credentialIndex ${credential.credentialIndex}` : 'all credentials'} from internal state`);
-        this.logStoredCredentialState('credential cleared');
-    }
-    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})`);
-        this.validateRemotePinCode(request.pinCode);
-        device.log.debug(`MatterbridgeDoorLockServer: remote lockDoor PIN validation completed`);
-        await device.commandHandler.executeHandler('DoorLock.lockDoor', {
-            command: 'lockDoor',
-            request,
-            cluster: DoorLockServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        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})`);
-        this.validateRemotePinCode(request.pinCode);
-        device.log.debug(`MatterbridgeDoorLockServer: remote unlockDoor PIN validation completed`);
-        await device.commandHandler.executeHandler('DoorLock.unlockDoor', {
-            command: 'unlockDoor',
-            request,
-            cluster: DoorLockServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        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})`);
-        this.validateRemotePinCode(request.pinCode);
-        device.log.debug(`MatterbridgeDoorLockServer: remote unlockWithTimeout PIN validation completed`);
-        await device.commandHandler.executeHandler('DoorLock.unlockWithTimeout', {
-            command: 'unlockWithTimeout',
-            request,
-            cluster: DoorLockServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeDoorLockServer: unlockWithTimeout called`);
-        this.state.lockState = DoorLock.LockState.Unlocked;
-    }
-    async setUser(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        const accessingFabricIndex = this.getAccessingFabricIndex();
-        device.log.info(`Setting user operationType ${getEnumDescription(DoorLock.DataOperationType, request.operationType)} userIndex ${request.userIndex} userName ${request.userName ?? 'null'} userUniqueId ${request.userUniqueId ?? 'null'} userStatus ${getEnumDescription(DoorLock.UserStatus, request.userStatus, { fallback: 'null' })} userType ${getEnumDescription(DoorLock.UserType, request.userType, { fallback: 'null' })} credentialRule ${getEnumDescription(DoorLock.CredentialRule, request.credentialRule, { fallback: 'null' })} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.log.debug(`MatterbridgeDoorLockServer: setUser accessingFabricIndex ${accessingFabricIndex ?? 'null'}`);
-        await device.commandHandler.executeHandler('DoorLock.setUser', {
-            command: 'setUser',
-            request,
-            cluster: DoorLockServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        const user = this.internal.users.find((user) => user.userIndex === request.userIndex);
-        device.log.debug(`MatterbridgeDoorLockServer: setUser called for userIndex ${request.userIndex} (${user ? 'existing user ' + debugStringify(user) : 'new user'})`);
-        if (!user && request.operationType === DoorLock.DataOperationType.Add) {
-            this.internal.users.push({
-                userIndex: request.userIndex,
-                userName: request.userName,
-                userUniqueId: request.userUniqueId,
-                userStatus: request.userStatus,
-                userType: request.userType,
-                credentialRule: request.credentialRule,
-                credentials: null,
-                creatorFabricIndex: accessingFabricIndex,
-                lastModifiedFabricIndex: accessingFabricIndex,
-                nextUserIndex: null,
-            });
-            device.log.debug(`MatterbridgeDoorLockServer: added userIndex ${request.userIndex} (total users: ${this.internal.users.length}) to internal state: ${debugStringify(this.internal.users.find((user) => user.userIndex === request.userIndex))}`);
-            this.logStoredCredentialState('user added');
-            return;
-        }
-        this.logStoredCredentialState(`setUser completed for userIndex ${request.userIndex} without adding a new internal user`);
-    }
-    async getUser(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Getting userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('DoorLock.getUser', {
-            command: 'getUser',
-            request,
-            cluster: DoorLockServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        const user = this.internal.users.find((user) => user.userIndex === request.userIndex);
-        device.log.debug(`MatterbridgeDoorLockServer: getUser called for userIndex ${request.userIndex} (total users: ${this.internal.users.length}) (${user ? 'existing user: ' + debugStringify(user) : 'new user'})`);
-        this.logStoredCredentialState(`getUser returning state for userIndex ${request.userIndex}`);
-        if (user) {
-            return {
-                ...user,
-                credentials: user.credentials?.map(({ credentialType, credentialIndex }) => ({ credentialType, credentialIndex })) ?? null,
-            };
-        }
-        return {
-            userIndex: request.userIndex,
-            userName: null,
-            userUniqueId: null,
-            userStatus: null,
-            userType: null,
-            credentialRule: null,
-            credentials: null,
-            creatorFabricIndex: null,
-            lastModifiedFabricIndex: null,
-            nextUserIndex: null,
-        };
-    }
-    async clearUser(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Clearing userIndex ${request.userIndex} ${request.userIndex === 0xfffe ? '(all users)' : ''} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('DoorLock.clearUser', {
-            command: 'clearUser',
-            request,
-            cluster: DoorLockServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeDoorLockServer: clearUser called for userIndex ${request.userIndex}`);
-        this.logStoredCredentialState(`clearUser completed for userIndex ${request.userIndex}`);
-    }
-    async setCredential(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        const accessingFabricIndex = this.getAccessingFabricIndex();
-        device.log.info(`Setting credential operationType ${getEnumDescription(DoorLock.DataOperationType, request.operationType)} credentialType ${getEnumDescription(DoorLock.CredentialType, request.credential.credentialType)} credentialIndex ${request.credential.credentialIndex} credentialData ${Buffer.from(request.credentialData).toString('hex') ? '0x' + Buffer.from(request.credentialData).toString('hex') : '0x'} userIndex ${request.userIndex ?? 'null'} userStatus ${getEnumDescription(DoorLock.UserStatus, request.userStatus, { fallback: 'null' })} userType ${getEnumDescription(DoorLock.UserType, request.userType, { fallback: 'null' })} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('DoorLock.setCredential', {
-            command: 'setCredential',
-            request,
-            cluster: DoorLockServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        const user = this.internal.users.find((user) => user.userIndex === request.userIndex);
-        const existingCredential = this.findStoredCredential(request.credential);
-        device.log.debug(`MatterbridgeDoorLockServer: setCredential pre-update lookup for credentialIndex ${request.credential.credentialIndex} (${existingCredential ? 'existing credential found' : 'no existing credential'})`);
-        device.log.debug(`MatterbridgeDoorLockServer: setCredential called for credentialIndex ${request.credential.credentialIndex}`);
-        if (user && (request.operationType === DoorLock.DataOperationType.Add || request.operationType === DoorLock.DataOperationType.Modify)) {
-            this.upsertStoredCredential(request.userIndex, request.credential, request.credentialData);
-            user.lastModifiedFabricIndex = accessingFabricIndex;
-            device.log.debug(`MatterbridgeDoorLockServer: setCredential updated lastModifiedFabricIndex for userIndex ${user.userIndex} to ${accessingFabricIndex ?? 'null'}`);
-        }
-        else {
-            device.log.debug(`MatterbridgeDoorLockServer: setCredential did not update internal state for credentialIndex ${request.credential.credentialIndex} (user ${request.userIndex ?? 'null'} not found or operation not handled)`);
-        }
-        return {
-            status: Status.Success,
-            userIndex: request.userIndex,
-        };
-    }
-    async getCredentialStatus(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Getting credential status for credentialType ${getEnumDescription(DoorLock.CredentialType, request.credential.credentialType)} credentialIndex ${request.credential.credentialIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('DoorLock.getCredentialStatus', {
-            command: 'getCredentialStatus',
-            request,
-            cluster: DoorLockServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        const credentialRecord = this.findStoredCredential(request.credential);
-        const nextCredentialIndex = this.getNextOccupiedCredentialIndex(request.credential);
-        device.log.debug(`MatterbridgeDoorLockServer: getCredentialStatus called`);
-        device.log.debug(`MatterbridgeDoorLockServer: getCredentialStatus result for credentialIndex ${request.credential.credentialIndex} (${credentialRecord ? `userIndex ${credentialRecord.user.userIndex} credentialData 0x${Buffer.from(credentialRecord.storedCredential.credentialData).toString('hex')}` : 'credential missing'}, nextCredentialIndex ${nextCredentialIndex ?? 'null'})`);
-        return {
-            credentialExists: credentialRecord !== null,
-            userIndex: credentialRecord?.user.userIndex ?? null,
-            creatorFabricIndex: credentialRecord?.user.creatorFabricIndex ?? null,
-            lastModifiedFabricIndex: credentialRecord?.user.lastModifiedFabricIndex ?? null,
-            nextCredentialIndex,
-            credentialData: credentialRecord?.storedCredential.credentialData ?? null,
-        };
-    }
-    async clearCredential(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Clearing credentialType ${request.credential ? getEnumDescription(DoorLock.CredentialType, request.credential.credentialType) : 'null'} credentialIndex ${request.credential ? request.credential.credentialIndex : 'null'} ${request.credential === null ? '(all credentials)' : ''} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('DoorLock.clearCredential', {
-            command: 'clearCredential',
-            request,
-            cluster: DoorLockServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        this.clearStoredCredential(request.credential);
-        device.log.debug('MatterbridgeDoorLockServer: clearCredential called');
-        this.logStoredCredentialState(`clearCredential completed for ${request.credential
-            ? `${getEnumDescription(DoorLock.CredentialType, request.credential.credentialType)} credentialIndex ${request.credential.credentialIndex}`
-            : 'all credentials'}`);
-    }
-}
-(function (MatterbridgeUserPinDoorLockServer) {
-    class Internal {
-        users = [];
-    }
-    MatterbridgeUserPinDoorLockServer.Internal = Internal;
-})(MatterbridgeUserPinDoorLockServer || (MatterbridgeUserPinDoorLockServer = {}));
-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,
-        });
-        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);
-    }
-}
-export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode, Thermostat.Feature.Presets) {
-    async initialize() {
-        await super.initialize();
-        this.endpoint.construction.onSuccess(async () => {
-            const device = this.endpoint.stateOf(MatterbridgeServer);
-            device.log.debug(`Removing atomic commands (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-            await this.endpoint.setStateOf(ThermostatServer, {
-                acceptedCommandList: [0],
-                generatedCommandList: [],
-            });
-        });
-    }
-    async setpointRaiseLower(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting setpoint by ${request.amount} in mode ${request.mode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('Thermostat.setpointRaiseLower', {
-            command: 'setpointRaiseLower',
-            request,
-            cluster: ThermostatServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        const lookupSetpointAdjustMode = ['Heat', 'Cool', 'Both'];
-        device.log.debug(`MatterbridgeThermostatServer: setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[request.mode]} amount: ${request.amount / 10}`);
-        await super.setpointRaiseLower(request);
-    }
-    async setActivePresetRequest(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        const presetHandle = request.presetHandle ? `0x${Buffer.from(request.presetHandle).toString('hex')}` : 'null';
-        device.log.info(`Setting preset to ${presetHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('Thermostat.setActivePresetRequest', {
-            command: 'setActivePresetRequest',
-            request,
-            cluster: ThermostatServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeThermostatServer: setActivePresetRequest called with presetHandle: ${presetHandle}`);
-        await super.setActivePresetRequest(request);
-        const activePresetHandle = this.state.activePresetHandle ? `0x${Buffer.from(this.state.activePresetHandle).toString('hex')}` : 'null';
-        device.log.debug(`MatterbridgeThermostatServer: setActivePresetRequest completed with activePresetHandle: ${activePresetHandle} occupiedHeatingSetpoint: ${this.state.occupiedHeatingSetpoint} occupiedCoolingSetpoint: ${this.state.occupiedCoolingSetpoint}`);
-    }
-}
-export class MatterbridgePresetThermostatServer extends ThermostatServer.with(Thermostat.Feature.Presets, Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode) {
-}
-export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigurationAndControlServer.with(ValveConfigurationAndControl.Feature.Level) {
-    async open(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Opening valve to ${request.targetLevel ? request.targetLevel + '%' : 'fully opened'} ${request.openDuration ? 'for ' + request.openDuration + 's' : 'until closed'} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('ValveConfigurationAndControl.open', {
-            command: 'open',
-            request,
-            cluster: ValveConfigurationAndControlServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeValveConfigurationAndControlServer: open called with openDuration: ${request.openDuration} targetLevel: ${request.targetLevel}`);
-        this.state.targetState = ValveConfigurationAndControl.ValveState.Open;
-        this.state.currentState = ValveConfigurationAndControl.ValveState.Open;
-        this.state.targetLevel = request.targetLevel ?? 100;
-        this.state.currentLevel = request.targetLevel ?? 100;
-        this.state.openDuration = request.openDuration ?? this.state.defaultOpenDuration;
-        if (this.state.openDuration === null)
-            this.state.remainingDuration = null;
-    }
-    async close() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Closing valve (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('ValveConfigurationAndControl.close', {
-            command: 'close',
-            request: {},
-            cluster: ValveConfigurationAndControlServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeValveConfigurationAndControlServer: close called`);
-        this.state.targetState = ValveConfigurationAndControl.ValveState.Closed;
-        this.state.currentState = ValveConfigurationAndControl.ValveState.Closed;
-        this.state.targetLevel = 0;
-        this.state.currentLevel = 0;
-        this.state.openDuration = null;
-        this.state.remainingDuration = null;
-    }
-}
-export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(SmokeCoAlarm.Feature.SmokeAlarm, SmokeCoAlarm.Feature.CoAlarm) {
-    async selfTestRequest() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Testing SmokeCOAlarm (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('SmokeCoAlarm.selfTestRequest', {
-            command: 'selfTestRequest',
-            request: {},
-            cluster: SmokeCoAlarmServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeSmokeCoAlarmServer: selfTestRequest called`);
-    }
-}
-export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.SensitivityLevel) {
-    async enableDisableAlarm(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Enabling/disabling alarm ${request.alarmsToEnableDisable} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('BooleanStateConfiguration.enableDisableAlarm', {
-            command: 'enableDisableAlarm',
-            request,
-            cluster: BooleanStateConfigurationServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeBooleanStateConfigurationServer: enableDisableAlarm called`);
-    }
-}
-export class MatterbridgeSwitchServer extends SwitchServer {
-    initialize() {
-    }
-}
-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,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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' },
-        };
-    }
-}
-export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
-    async selectAreas(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Selecting areas [${request.newAreas.join(', ')}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('ServiceArea.selectAreas', {
-            command: 'selectAreas',
-            request,
-            cluster: ServiceAreaServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        device.log.debug(`MatterbridgeServiceAreaServer selectAreas called with: [${request.newAreas.join(', ')}]`);
-        return await super.selectAreas(request);
-    }
-}
-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,
-        });
-        device.log.debug(`MatterbridgeModeSelectServer: changeToMode called with mode: ${request.newMode}`);
-        await super.changeToMode(request);
-    }
-}
-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,
-        });
-        this.state.condition = 100;
-        this.state.lastChangedTime = Math.floor(new Date().getTime() / 1000);
-        device.log.debug(`MatterbridgeHepaFilterMonitoringServer: resetCondition called`);
-    }
-}
-export class MatterbridgeActivatedCarbonFilterMonitoringServer extends ActivatedCarbonFilterMonitoringServer.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('ActivatedCarbonFilterMonitoring.resetCondition', {
-            command: 'resetCondition',
-            request: {},
-            cluster: MatterbridgeActivatedCarbonFilterMonitoringServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        this.state.condition = 100;
-        this.state.lastChangedTime = Math.floor(new Date().getTime() / 1000);
-        device.log.debug(`MatterbridgeActivatedCarbonFilterMonitoringServer: resetCondition called`);
-    }
-}
-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,
-        });
-        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,
-        });
-        device.log.debug(`MatterbridgeDeviceEnergyManagementServer cancelPowerAdjustRequest called`);
-    }
-}
-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,
-        });
-        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);
-    }
-}