@matterbridge/core 3.7.1-dev-20260323-0a65511 → 3.7.1-dev-20260324-9c29691

package/dist/devices/roboticVacuumCleaner.d.ts

@@ -9,10 +9,10 @@ import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
 import { ServiceArea } from '@matter/types/clusters/service-area';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class RoboticVacuumCleaner extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string, mode?: 'server' | 'matter' | undefined, currentRunMode?: number, supportedRunModes?: RvcRunMode.ModeOption[], currentCleanMode?: number, supportedCleanModes?: RvcCleanMode.ModeOption[], currentPhase?: number | null, phaseList?: string[] | null, operationalState?: RvcOperationalState.OperationalState, operationalStateList?: RvcOperationalState.OperationalStateStruct[], supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number, supportedMaps?: ServiceArea.Map[]);
+    constructor(name: string, serial: string, mode?: 'server' | 'matter' | undefined, currentRunMode?: number, supportedRunModes?: RvcRunMode.ModeOption[], currentCleanMode?: number, supportedCleanModes?: RvcCleanMode.ModeOption[], currentPhase?: number | null, phaseList?: string[] | null, operationalState?: RvcOperationalState.OperationalState, operationalStateList?: RvcOperationalState.OperationalStateStruct[], supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number | null, supportedMaps?: ServiceArea.Map[]);
     createDefaultRvcRunModeClusterServer(currentMode?: number, supportedModes?: RvcRunMode.ModeOption[]): this;
     createDefaultRvcCleanModeClusterServer(currentMode?: number, supportedModes?: RvcCleanMode.ModeOption[]): this;
-    createDefaultServiceAreaClusterServer(supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number, supportedMaps?: ServiceArea.Map[]): this;
+    createDefaultServiceAreaClusterServer(supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number | null, supportedMaps?: ServiceArea.Map[]): this;
     createDefaultRvcOperationalStateClusterServer(phaseList?: string[] | null, currentPhase?: number | null, operationalStateList?: RvcOperationalState.OperationalStateStruct[], operationalState?: RvcOperationalState.OperationalState, operationalError?: RvcOperationalState.ErrorStateStruct): this;
 }
 export declare class MatterbridgeRvcRunModeServer extends RvcRunModeServer {

package/dist/devices/roboticVacuumCleaner.js

@@ -71,7 +71,7 @@ export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
                 },
             ],
             selectedAreas: selectedAreas ?? [],
-            currentArea: currentArea ?? 1,
+            currentArea: currentArea !== undefined ? currentArea : 1,
             supportedMaps: supportedMaps ?? [],
             estimatedEndTime: null,
         });

package/dist/helpers.js

@@ -13,6 +13,8 @@ import { Identify } from '@matter/types/clusters/identify';
 import { OnOff } from '@matter/types/clusters/on-off';
 import { VendorId } from '@matter/types/datatype';
 import { hasParameter } from '@matterbridge/utils/cli';
+import { doorLockDevice } from './matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 export async function addVirtualDevice(aggregatorEndpoint, name, type, callback) {
     let deviceType;
     switch (type) {
@@ -36,7 +38,7 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
             vendorName: 'Matterbridge',
             productName: 'Matterbridge Virtual Device',
             nodeLabel: name.slice(0, 32),
-            softwareVersion: 2000,
+            softwareVersion: 20000,
             softwareVersionString: '2.0.0',
         },
         onOff: { onOff: false },
@@ -71,6 +73,13 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
     return device;
 }
 export async function addVirtualDevices(matterbridge, aggregatorEndpoint) {
+    if (hasParameter('experimental') && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
+        const lock = new MatterbridgeEndpoint(doorLockDevice, { id: 'system_lock' });
+        lock.createDefaultBridgedDeviceBasicInformationClusterServer('Matterbridge System Lock', 'sn_system_lock', 0xfff1, 'Matterbridge', 'Matterbridge Virtual Device', 20000, '2.0.0');
+        lock.createPinDoorLockClusterServer();
+        lock.addRequiredClusterServers();
+        await aggregatorEndpoint.add(lock);
+    }
     if (matterbridge.virtualMode !== 'disabled' && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
         matterbridge.log.notice(`Creating virtual devices for Matterbridge server node...`);
         await addVirtualDevice(aggregatorEndpoint, 'Restart Matterbridge', matterbridge.virtualMode, async () => {
@@ -80,13 +89,7 @@ export async function addVirtualDevices(matterbridge, aggregatorEndpoint) {
                 await matterbridge.shutdownProcess();
         });
         await addVirtualDevice(aggregatorEndpoint, 'Update Matterbridge', matterbridge.virtualMode, async () => {
-            if (hasParameter('shelly')) {
-            }
-            else {
-                await matterbridge.updateProcess();
-            }
+            await matterbridge.updateProcess();
         });
-        if (hasParameter('shelly')) {
-        }
     }
 }

package/dist/matterbridge.js

@@ -1197,11 +1197,33 @@ export class Matterbridge extends EventEmitter {
             }
             if (message === 'shutting down with reset...') {
                 this.log.info('Resetting Matterbridge commissioning information...');
-                await this.matterStorageManager?.createContext('events')?.clearAll();
-                await this.matterStorageManager?.createContext('fabrics')?.clearAll();
-                await this.matterStorageManager?.createContext('root')?.clearAll();
-                await this.matterStorageManager?.createContext('sessions')?.clearAll();
                 await this.matterbridgeContext?.clearAll();
+                if (this.bridgeMode === 'bridge') {
+                    await this.matterStorageManager?.createContext('events')?.clearAll();
+                    await this.matterStorageManager?.createContext('fabrics')?.clearAll();
+                    await this.matterStorageManager?.createContext('root')?.clearAll();
+                    await this.matterStorageManager?.createContext('sessions')?.clearAll();
+                }
+                else if (this.bridgeMode === 'childbridge') {
+                    for (const plugin of this.plugins.array()) {
+                        plugin.storageContext?.clearAll();
+                        const storageManager = await this.matterStorageService?.open(plugin.name);
+                        await storageManager?.createContext('events')?.clearAll();
+                        await storageManager?.createContext('fabrics')?.clearAll();
+                        await storageManager?.createContext('root')?.clearAll();
+                        await storageManager?.createContext('sessions')?.clearAll();
+                    }
+                }
+                for (const device of this.devices.array()) {
+                    if (device.mode === 'server' && device.deviceName) {
+                        const storageManager = await this.matterStorageService?.open(device.deviceName.replaceAll(' ', ''));
+                        await storageManager?.createContext('persist')?.clearAll();
+                        await storageManager?.createContext('events')?.clearAll();
+                        await storageManager?.createContext('fabrics')?.clearAll();
+                        await storageManager?.createContext('root')?.clearAll();
+                        await storageManager?.createContext('sessions')?.clearAll();
+                    }
+                }
                 this.log.info('Matter storage reset done! Remove the bridge from the controller.');
             }
             if (message === 'unregistered all devices and shutting down...') {

package/dist/matterbridgeBehaviorsServer.d.ts

@@ -24,6 +24,7 @@ import { ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activate
 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 { DoorLock } from '@matter/types/clusters/door-lock';
 import { FanControl } from '@matter/types/clusters/fan-control';
 import { HepaFilterMonitoring } from '@matter/types/clusters/hepa-filter-monitoring';
 import { Identify } from '@matter/types/clusters/identify';
@@ -452,15 +453,17 @@ declare const MatterbridgeColorControlServer_base: import("@matter/node").Cluste
         };
         readonly component: false;
     }];
-}>, readonly [ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature]>, typeof ColorControlServer, import("@matter/node/behaviors/color-control").ColorControlInterface>;
+}>, readonly [ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature, ColorControl.Feature.EnhancedHue]>, typeof ColorControlServer, import("@matter/node/behaviors/color-control").ColorControlInterface>;
 export declare class MatterbridgeColorControlServer extends MatterbridgeColorControlServer_base {
     moveToHue(request: ColorControl.MoveToHueRequest): Promise<void>;
+    enhancedMoveToHue(request: ColorControl.EnhancedMoveToHueRequest): Promise<void>;
     moveToSaturation(request: ColorControl.MoveToSaturationRequest): Promise<void>;
     moveToHueAndSaturation(request: ColorControl.MoveToHueAndSaturationRequest): Promise<void>;
+    enhancedMoveToHueAndSaturation(request: ColorControl.EnhancedMoveToHueAndSaturationRequest): Promise<void>;
     moveToColor(request: ColorControl.MoveToColorRequest): Promise<void>;
     moveToColorTemperature(request: ColorControl.MoveToColorTemperatureRequest): Promise<void>;
 }
-declare const MatterbridgeEnhancedColorControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
+declare const MatterbridgeEnhancedColorControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
     readonly id: 768;
     readonly name: "ColorControl";
     readonly revision: 7;
@@ -846,15 +849,8 @@ declare const MatterbridgeEnhancedColorControlServer_base: import("@matter/node"
         };
         readonly component: false;
     }];
-}>, readonly [ColorControl.Feature.HueSaturation, ColorControl.Feature.EnhancedHue, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature]>, typeof ColorControlServer, import("@matter/node/behaviors/color-control").ColorControlInterface>;
+}>, readonly [ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature, ColorControl.Feature.EnhancedHue]>, readonly [ColorControl.Feature.HueSaturation, ColorControl.Feature.EnhancedHue, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature]>, typeof MatterbridgeColorControlServer, import("@matter/node/behaviors/color-control").ColorControlInterface>;
 export declare class MatterbridgeEnhancedColorControlServer extends MatterbridgeEnhancedColorControlServer_base {
-    moveToHue(request: ColorControl.MoveToHueRequest): Promise<void>;
-    enhancedMoveToHue(request: ColorControl.EnhancedMoveToHueRequest): Promise<void>;
-    moveToSaturation(request: ColorControl.MoveToSaturationRequest): Promise<void>;
-    moveToHueAndSaturation(request: ColorControl.MoveToHueAndSaturationRequest): Promise<void>;
-    enhancedMoveToHueAndSaturation(request: ColorControl.EnhancedMoveToHueAndSaturationRequest): Promise<void>;
-    moveToColor(request: ColorControl.MoveToColorRequest): Promise<void>;
-    moveToColorTemperature(request: ColorControl.MoveToColorTemperatureRequest): Promise<void>;
 }
 declare const MatterbridgeWindowCoveringServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
     readonly id: 258;
@@ -1435,9 +1431,14 @@ declare const MatterbridgeLiftTiltWindowCoveringServer_base: import("@matter/nod
 }>, readonly [WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift, WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt]>, readonly [WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift, WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt]>, typeof MatterbridgeWindowCoveringServer, import("@matter/node/behaviors/window-covering").WindowCoveringInterface>;
 export declare class MatterbridgeLiftTiltWindowCoveringServer extends MatterbridgeLiftTiltWindowCoveringServer_base {
 }
-export declare class MatterbridgeDoorLockServer extends DoorLockServer {
-    lockDoor(): Promise<void>;
-    unlockDoor(): Promise<void>;
+declare const MatterbridgeDoorLockServer_base: 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>;
+export declare class MatterbridgeDoorLockServer extends MatterbridgeDoorLockServer_base {
+    lockDoor(request: DoorLock.LockDoorRequest): Promise<void>;
+    unlockDoor(request: DoorLock.UnlockDoorRequest): Promise<void>;
+    setPinCode(request: DoorLock.SetPinCodeRequest): Promise<void>;
+    getPinCode(request: DoorLock.GetPinCodeRequest): Promise<DoorLock.GetPinCodeResponse>;
+    clearPinCode(request: DoorLock.ClearPinCodeRequest): Promise<void>;
+    clearAllPinCodes(): Promise<void>;
 }
 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 {
@@ -1803,10 +1804,11 @@ declare const MatterbridgeThermostatServer_base: import("@matter/node").ClusterB
         };
         readonly component: false;
     }];
-}>, readonly [Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode]>, typeof ThermostatServer, import("@matter/node/behaviors/thermostat").ThermostatInterface>;
+}>, readonly [Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode, Thermostat.Feature.Presets]>, typeof ThermostatServer, import("@matter/node/behaviors/thermostat").ThermostatInterface>;
 export declare class MatterbridgeThermostatServer extends MatterbridgeThermostatServer_base {
     initialize(): Promise<void>;
     setpointRaiseLower(request: Thermostat.SetpointRaiseLowerRequest): Promise<void>;
+    setActivePresetRequest(request: Thermostat.SetActivePresetRequest): Promise<void>;
 }
 declare const MatterbridgePresetThermostatServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
     readonly id: 513;
@@ -2170,8 +2172,6 @@ declare const MatterbridgePresetThermostatServer_base: import("@matter/node").Cl
     }];
 }>, readonly [Thermostat.Feature.Presets, Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode]>, typeof ThermostatServer, import("@matter/node/behaviors/thermostat").ThermostatInterface>;
 export declare class MatterbridgePresetThermostatServer extends MatterbridgePresetThermostatServer_base {
-    setpointRaiseLower(request: Thermostat.SetpointRaiseLowerRequest): Promise<void>;
-    setActivePresetRequest(request: Thermostat.SetActivePresetRequest): Promise<void>;
 }
 declare const MatterbridgeValveConfigurationAndControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<ValveConfigurationAndControl.Cluster, readonly [ValveConfigurationAndControl.Feature.Level]>, typeof ValveConfigurationAndControlServer, import("@matter/node/behaviors/valve-configuration-and-control").ValveConfigurationAndControlInterface>;
 export declare class MatterbridgeValveConfigurationAndControlServer extends MatterbridgeValveConfigurationAndControlServer_base {

package/dist/matterbridgeBehaviorsServer.js

@@ -23,15 +23,16 @@ import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-
 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 { ServiceArea } from '@matter/types/clusters/service-area';
 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 { getEnumDescription } from '@matterbridge/utils';
 export class MatterbridgeServer extends Behavior {
     static id = 'matterbridge';
     initialize() {
@@ -162,74 +163,7 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
         await super.moveToLevelWithOnOff(request);
     }
 }
-export class MatterbridgeColorControlServer extends ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature) {
-    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 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 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 ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.EnhancedHue, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature) {
+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})`);
@@ -322,6 +256,8 @@ export class MatterbridgeEnhancedColorControlServer extends ColorControlServer.w
         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() {
@@ -407,32 +343,85 @@ export class MatterbridgeLiftWindowCoveringServer extends MatterbridgeWindowCove
 }
 export class MatterbridgeLiftTiltWindowCoveringServer extends MatterbridgeWindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift, WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt) {
 }
-export class MatterbridgeDoorLockServer extends DoorLockServer {
-    async lockDoor() {
+export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess) {
+    async lockDoor(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Locking door (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        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: {},
+            request,
             cluster: DoorLockServer.id,
             attributes: this.state,
             endpoint: this.endpoint,
         });
         device.log.debug(`MatterbridgeDoorLockServer: lockDoor called`);
-        await super.lockDoor();
+        await super.lockDoor(request);
     }
-    async unlockDoor() {
+    async unlockDoor(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Unlocking door (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        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: {},
+            request,
             cluster: DoorLockServer.id,
             attributes: this.state,
             endpoint: this.endpoint,
         });
         device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called`);
-        await super.unlockDoor();
+        await super.unlockDoor(request);
+    }
+    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');
     }
 }
 export class MatterbridgeFanControlServer extends FanControlServer.with(FanControl.Feature.Auto, FanControl.Feature.Step) {
@@ -466,7 +455,7 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
         device.log.debug('Set percentCurrent to:', this.state.percentCurrent);
     }
 }
-export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode) {
+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 () => {
@@ -492,22 +481,6 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
         device.log.debug(`MatterbridgeThermostatServer: setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[request.mode]} amount: ${request.amount / 10}`);
         await super.setpointRaiseLower(request);
     }
-}
-export class MatterbridgePresetThermostatServer extends ThermostatServer.with(Thermostat.Feature.Presets, Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode) {
-    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(`MatterbridgePresetThermostatServer: 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';
@@ -519,12 +492,14 @@ export class MatterbridgePresetThermostatServer extends ThermostatServer.with(Th
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        device.log.debug(`MatterbridgePresetThermostatServer: setActivePresetRequest called with presetHandle: ${presetHandle}`);
+        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(`MatterbridgePresetThermostatServer: setActivePresetRequest completed with activePresetHandle: ${activePresetHandle} occupiedHeatingSetpoint: ${this.state.occupiedHeatingSetpoint} occupiedCoolingSetpoint: ${this.state.occupiedCoolingSetpoint}`);
+        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);
@@ -676,7 +651,7 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
 export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
     async selectAreas(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Selecting areas ${request.newAreas} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`Selecting areas [${request.newAreas.join(', ')}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ServiceArea.selectAreas', {
             command: 'selectAreas',
             request,
@@ -684,15 +659,7 @@ export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        for (const area of request.newAreas) {
-            const supportedArea = this.state.supportedAreas.find((supportedArea) => supportedArea.areaId === area);
-            if (!supportedArea) {
-                device.log.error(`MatterbridgeServiceAreaServer selectAreas called with unsupported area: ${area}`);
-                return { status: ServiceArea.SelectAreasStatus.UnsupportedArea, statusText: 'Unsupported areas' };
-            }
-        }
-        this.state.selectedAreas = request.newAreas;
-        device.log.debug(`MatterbridgeServiceAreaServer selectAreas called with: ${request.newAreas.map((area) => area.toString()).join(', ')}`);
+        device.log.debug(`MatterbridgeServiceAreaServer selectAreas called with: [${request.newAreas.join(', ')}]`);
         return await super.selectAreas(request);
     }
 }

package/dist/matterbridgeEndpoint.d.ts

@@ -172,6 +172,7 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     createDefaultHepaFilterMonitoringClusterServer(condition?: number, changeIndication?: ResourceMonitoring.ChangeIndication, inPlaceIndicator?: boolean | undefined, lastChangedTime?: number | null | undefined, replacementProductList?: ResourceMonitoring.ReplacementProduct[]): this;
     createDefaultActivatedCarbonFilterMonitoringClusterServer(condition?: number, changeIndication?: ResourceMonitoring.ChangeIndication, inPlaceIndicator?: boolean | undefined, lastChangedTime?: number | null | undefined, replacementProductList?: ResourceMonitoring.ReplacementProduct[]): this;
     createDefaultDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType): this;
+    createPinDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType): this;
     createDefaultModeSelectClusterServer(description: string, supportedModes: ModeSelect.ModeOption[], currentMode?: number, startUpMode?: number): this;
     createDefaultValveConfigurationAndControlClusterServer(valveState?: ValveConfigurationAndControl.ValveState, valveLevel?: number): this;
     createDefaultPumpConfigurationAndControlClusterServer(pumpMode?: PumpConfigurationAndControl.OperationMode): this;

package/dist/matterbridgeEndpoint.js

@@ -62,7 +62,7 @@ import { VendorId } from '@matter/types/datatype';
 import { inspectError } from '@matterbridge/utils/error';
 import { isValidNumber, isValidObject, isValidString } from '@matterbridge/utils/validate';
 import { AnsiLogger, CYAN, db, debugStringify, hk, or, YELLOW, zb } from 'node-ansi-logger';
-import { MatterbridgeActivatedCarbonFilterMonitoringServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeColorControlServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeDoorLockServer, MatterbridgeEnhancedColorControlServer, MatterbridgeFanControlServer, MatterbridgeHepaFilterMonitoringServer, MatterbridgeIdentifyServer, MatterbridgeLevelControlServer, MatterbridgeModeSelectServer, MatterbridgeOnOffServer, MatterbridgeOperationalStateServer, MatterbridgePowerSourceServer, MatterbridgePresetThermostatServer, MatterbridgeServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeSwitchServer, MatterbridgeThermostatServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeWindowCoveringServer, } from './matterbridgeBehaviorsServer.js';
+import { MatterbridgeActivatedCarbonFilterMonitoringServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeColorControlServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeDoorLockServer, MatterbridgeFanControlServer, MatterbridgeHepaFilterMonitoringServer, MatterbridgeIdentifyServer, MatterbridgeLevelControlServer, MatterbridgeModeSelectServer, MatterbridgeOnOffServer, MatterbridgeOperationalStateServer, MatterbridgePowerSourceServer, MatterbridgeServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeSwitchServer, MatterbridgeThermostatServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeWindowCoveringServer, } from './matterbridgeBehaviorsServer.js';
 import { CommandHandler } from './matterbridgeEndpointCommandHandler.js';
 import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, checkNotLatinCharacters, createUniqueId, featuresFor, generateUniqueId, getApparentElectricalPowerMeasurementClusterServer, getAttribute, getAttributeId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getCluster, getClusterId, getDefaultDeviceEnergyManagementClusterServer, getDefaultDeviceEnergyManagementModeClusterServer, getDefaultElectricalEnergyMeasurementClusterServer, getDefaultElectricalPowerMeasurementClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultOccupancySensingClusterServer, getDefaultOperationalStateClusterServer, getDefaultPowerSourceBatteryClusterServer, getDefaultPowerSourceRechargeableBatteryClusterServer, getDefaultPowerSourceReplaceableBatteryClusterServer, getDefaultPowerSourceWiredClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, invokeBehaviorCommand, lowercaseFirstLetter, setAttribute, setCluster, subscribeAttribute, triggerEvent, updateAttribute, } from './matterbridgeEndpointHelpers.js';
 const MATTERBRIDGE_ENDPOINT_BRAND = Symbol('MatterbridgeEndpoint.brand');
@@ -639,7 +639,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
     createEnhancedColorControlClusterServer(currentX = 0, currentY = 0, enhancedCurrentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
-        this.behaviors.require(MatterbridgeEnhancedColorControlServer.with(ColorControl.Feature.Xy, ColorControl.Feature.HueSaturation, ColorControl.Feature.EnhancedHue, ColorControl.Feature.ColorTemperature), {
+        this.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.Xy, ColorControl.Feature.HueSaturation, ColorControl.Feature.EnhancedHue, ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.CurrentHueAndCurrentSaturation,
             enhancedColorMode: ColorControl.EnhancedColorMode.EnhancedCurrentHueAndCurrentSaturation,
             colorCapabilities: { xy: true, hueSaturation: true, colorLoop: false, enhancedHue: true, colorTemperature: true },
@@ -893,7 +893,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
     createDefaultPresetsThermostatClusterServer(localTemperature = 23, occupiedHeatingSetpoint = 21, occupiedCoolingSetpoint = 25, minSetpointDeadBand = 0, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50, unoccupiedHeatingSetpoint = undefined, unoccupiedCoolingSetpoint = undefined, occupied = undefined, outdoorTemperature = undefined, activePresetHandle = null, presetsList = undefined, presetTypes = undefined) {
-        this.behaviors.require(MatterbridgePresetThermostatServer.with(Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : []), Thermostat.Feature.Presets), {
+        this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : []), Thermostat.Feature.Presets), {
             localTemperature: localTemperature * 100,
             externalMeasuredIndoorTemperature: localTemperature * 100,
             ...(outdoorTemperature !== undefined ? { outdoorTemperature: outdoorTemperature !== null ? outdoorTemperature * 100 : outdoorTemperature } : {}),
@@ -1048,7 +1048,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
     createDefaultDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt) {
-        this.behaviors.require(MatterbridgeDoorLockServer.enable({ events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true } }), {
+        this.behaviors.require(MatterbridgeDoorLockServer.with().enable({ events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true } }), {
             lockState,
             lockType,
             actuatorEnabled: true,
@@ -1058,6 +1058,26 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    createPinDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt) {
+        this.behaviors.require(MatterbridgeDoorLockServer.with(DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess).enable({
+            events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
+        }), {
+            lockState,
+            lockType,
+            actuatorEnabled: true,
+            operatingMode: DoorLock.OperatingMode.Normal,
+            supportedOperatingModes: { normal: false, vacation: true, privacy: true, noRemoteLockUnlock: false, passage: true, alwaysSet: 2047 },
+            autoRelockTime: 0,
+            numberOfPinUsersSupported: 10,
+            minPinCodeLength: 4,
+            maxPinCodeLength: 10,
+            sendPinOverTheAir: true,
+            requirePinForRemoteOperation: true,
+            wrongCodeEntryLimit: 5,
+            userCodeTemporaryDisableTime: 60,
+        });
+        return this;
+    }
     createDefaultModeSelectClusterServer(description, supportedModes, currentMode = 0, startUpMode = 0) {
         this.behaviors.require(MatterbridgeModeSelectServer, {
             description: description,

package/dist/matterbridgeEndpointCommandHandler.d.ts

@@ -71,6 +71,16 @@ export interface MatterbridgeEndpointCommands {
     setTarget: HandlerFunction;
     lockDoor: HandlerFunction;
     unlockDoor: HandlerFunction;
+    setPinCode: HandlerFunction;
+    getPinCode: HandlerFunction;
+    clearPinCode: HandlerFunction;
+    clearAllPinCodes: HandlerFunction;
+    setUser: HandlerFunction;
+    getUser: HandlerFunction;
+    clearUser: HandlerFunction;
+    setCredential: HandlerFunction;
+    getCredentialStatus: HandlerFunction;
+    clearCredential: HandlerFunction;
     setpointRaiseLower: HandlerFunction;
     setActivePresetRequest: HandlerFunction;
     step: HandlerFunction;
@@ -383,6 +393,16 @@ export type CommandHandlerDataMap = {
     };
     'lockDoor': CommandHandlerData<'DoorLock.lockDoor'>;
     'unlockDoor': CommandHandlerData<'DoorLock.unlockDoor'>;
+    'setPinCode': CommandHandlerData<'DoorLock.setPinCode'>;
+    'getPinCode': CommandHandlerData<'DoorLock.getPinCode'>;
+    'clearPinCode': CommandHandlerData<'DoorLock.clearPinCode'>;
+    'clearAllPinCodes': CommandHandlerData<'DoorLock.clearAllPinCodes'>;
+    'setUser': CommandHandlerData<'DoorLock.setUser'>;
+    'getUser': CommandHandlerData<'DoorLock.getUser'>;
+    'clearUser': CommandHandlerData<'DoorLock.clearUser'>;
+    'setCredential': CommandHandlerData<'DoorLock.setCredential'>;
+    'getCredentialStatus': CommandHandlerData<'DoorLock.getCredentialStatus'>;
+    'clearCredential': CommandHandlerData<'DoorLock.clearCredential'>;
     'DoorLock.lockDoor': {
         command: 'lockDoor';
         request: DoorLock.LockDoorRequest;
@@ -397,6 +417,76 @@ export type CommandHandlerDataMap = {
         attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
         endpoint: MatterbridgeEndpoint;
     };
+    'DoorLock.setPinCode': {
+        command: 'setPinCode';
+        request: DoorLock.SetPinCodeRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DoorLock.getPinCode': {
+        command: 'getPinCode';
+        request: DoorLock.GetPinCodeRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DoorLock.clearPinCode': {
+        command: 'clearPinCode';
+        request: DoorLock.ClearPinCodeRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DoorLock.clearAllPinCodes': {
+        command: 'clearAllPinCodes';
+        request: {};
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DoorLock.setUser': {
+        command: 'setUser';
+        request: DoorLock.SetUserRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DoorLock.getUser': {
+        command: 'getUser';
+        request: DoorLock.GetUserRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DoorLock.clearUser': {
+        command: 'clearUser';
+        request: DoorLock.ClearUserRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DoorLock.setCredential': {
+        command: 'setCredential';
+        request: DoorLock.SetCredentialRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DoorLock.getCredentialStatus': {
+        command: 'getCredentialStatus';
+        request: DoorLock.GetCredentialStatusRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DoorLock.clearCredential': {
+        command: 'clearCredential';
+        request: DoorLock.ClearCredentialRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'setpointRaiseLower': CommandHandlerData<'Thermostat.setpointRaiseLower'>;
     'setActivePresetRequest': CommandHandlerData<'Thermostat.setActivePresetRequest'>;
     'Thermostat.setpointRaiseLower': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.7.1-dev-20260323-0a65511",
+  "version": "3.7.1-dev-20260324-9c29691",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -122,14 +122,14 @@
   ],
   "dependencies": {
     "@matter/main": "0.16.10",
-    "@matterbridge/dgram": "3.7.1-dev-20260323-0a65511",
-    "@matterbridge/thread": "3.7.1-dev-20260323-0a65511",
-    "@matterbridge/types": "3.7.1-dev-20260323-0a65511",
-    "@matterbridge/utils": "3.7.1-dev-20260323-0a65511",
+    "@matterbridge/dgram": "3.7.1-dev-20260324-9c29691",
+    "@matterbridge/thread": "3.7.1-dev-20260324-9c29691",
+    "@matterbridge/types": "3.7.1-dev-20260324-9c29691",
+    "@matterbridge/utils": "3.7.1-dev-20260324-9c29691",
     "express": "5.2.1",
     "multer": "2.1.1",
     "node-ansi-logger": "3.2.0",
     "node-persist-manager": "2.0.1",
-    "ws": "8.19.0"
+    "ws": "8.20.0"
   }
 }