@matterbridge/core 3.7.1-dev-20260326-7d15a50 → 3.7.1

package/dist/behaviors/export.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/behaviors/export.js

@@ -0,0 +1 @@
+export {};

package/dist/helpers.js

@@ -74,11 +74,16 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
 }
 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);
+        const lockPin = new MatterbridgeEndpoint(doorLockDevice, { id: 'door_lock_pin' });
+        lockPin.createDefaultBridgedDeviceBasicInformationClusterServer('Matterbridge Pin Lock', 'sn_system_lock', 0xfff1, 'Matterbridge', 'Matterbridge Virtual Device', 20000, '2.0.0');
+        lockPin.createPinDoorLockClusterServer();
+        lockPin.addRequiredClusterServers();
+        await aggregatorEndpoint.add(lockPin);
+        const lockUserPin = new MatterbridgeEndpoint(doorLockDevice, { id: 'door_lock_user_pin' });
+        lockUserPin.createDefaultBridgedDeviceBasicInformationClusterServer('Matterbridge User Pin Lock', 'sn_system_lock', 0xfff1, 'Matterbridge', 'Matterbridge Virtual Device', 20000, '2.0.0');
+        lockUserPin.createUserPinDoorLockClusterServer();
+        lockUserPin.addRequiredClusterServers();
+        await aggregatorEndpoint.add(lockUserPin);
     }
     if (matterbridge.virtualMode !== 'disabled' && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
         matterbridge.log.notice(`Creating virtual devices for Matterbridge server node...`);

package/dist/matterbridgeBehaviorsServer.d.ts

@@ -38,6 +38,8 @@ 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 { FabricIndex } from '@matter/types/datatype';
+import { Status } from '@matter/types/globals';
 import { AnsiLogger } from 'node-ansi-logger';
 import { CommandHandler } from './matterbridgeEndpointCommandHandler.js';
 export declare class MatterbridgeServer extends Behavior {
@@ -1431,14 +1433,104 @@ 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 {
 }
-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>;
+declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<DoorLock.Cluster, import("@matter/types").ClusterTypeModifier.ElementFlagAlterations<{
+    readonly events: {
+        readonly doorLockAlarm: true;
+        readonly lockOperation: true;
+        readonly lockOperationError: true;
+    };
+    readonly commands: {
+        readonly lockDoor: true;
+        readonly unlockDoor: true;
+        readonly unlockWithTimeout: true;
+    };
+}>>, typeof DoorLockServer, import("@matter/node/behaviors/door-lock").DoorLockInterface>;
 export declare class MatterbridgeDoorLockServer extends MatterbridgeDoorLockServer_base {
     lockDoor(request: DoorLock.LockDoorRequest): Promise<void>;
     unlockDoor(request: DoorLock.UnlockDoorRequest): Promise<void>;
+    unlockWithTimeout(request: DoorLock.UnlockWithTimeoutRequest): Promise<void>;
+}
+declare const MatterbridgePinDoorLockServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types").ClusterComposer.WithFeatures<DoorLock.Cluster, readonly [DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess]>, import("@matter/types").ClusterTypeModifier.ElementFlagAlterations<{
+    readonly events: {
+        readonly doorLockAlarm: true;
+        readonly lockOperation: true;
+        readonly lockOperationError: true;
+    };
+    readonly commands: {
+        readonly lockDoor: true;
+        readonly unlockDoor: true;
+        readonly unlockWithTimeout: true;
+        readonly setUserStatus: true;
+        readonly getUserStatus: true;
+        readonly setUserType: true;
+        readonly getUserType: true;
+    };
+}>>, import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<DoorLock.Cluster, readonly [DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess]>, typeof DoorLockServer, import("@matter/node/behaviors/door-lock").DoorLockInterface>, import("@matter/node/behaviors/door-lock").DoorLockInterface>;
+export declare class MatterbridgePinDoorLockServer extends MatterbridgePinDoorLockServer_base {
+    lockDoor(request: DoorLock.LockDoorRequest): Promise<void>;
+    unlockDoor(request: DoorLock.UnlockDoorRequest): Promise<void>;
+    unlockWithTimeout(request: DoorLock.UnlockWithTimeoutRequest): Promise<void>;
     setPinCode(request: DoorLock.SetPinCodeRequest): Promise<void>;
     getPinCode(request: DoorLock.GetPinCodeRequest): Promise<DoorLock.GetPinCodeResponse>;
     clearPinCode(request: DoorLock.ClearPinCodeRequest): Promise<void>;
     clearAllPinCodes(): Promise<void>;
+    setUserStatus(request: DoorLock.SetUserStatusRequest): Promise<void>;
+    getUserStatus(request: DoorLock.GetUserStatusRequest): Promise<DoorLock.GetUserStatusResponse>;
+    setUserType(request: DoorLock.SetUserTypeRequest): Promise<void>;
+    getUserType(request: DoorLock.GetUserTypeRequest): Promise<DoorLock.GetUserTypeResponse>;
+}
+declare const MatterbridgeUserPinDoorLockServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types").ClusterComposer.WithFeatures<DoorLock.Cluster, readonly [DoorLock.Feature.User, DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess]>, import("@matter/types").ClusterTypeModifier.ElementFlagAlterations<{
+    readonly events: {
+        readonly doorLockAlarm: true;
+        readonly lockOperation: true;
+        readonly lockOperationError: true;
+    };
+    readonly commands: {
+        readonly lockDoor: true;
+        readonly unlockDoor: true;
+        readonly unlockWithTimeout: true;
+    };
+}>>, import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<DoorLock.Cluster, readonly [DoorLock.Feature.User, DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess]>, typeof DoorLockServer, import("@matter/node/behaviors/door-lock").DoorLockInterface>, import("@matter/node/behaviors/door-lock").DoorLockInterface>;
+export declare class MatterbridgeUserPinDoorLockServer extends MatterbridgeUserPinDoorLockServer_base {
+    protected internal: MatterbridgeUserPinDoorLockServer.Internal;
+    private getAccessingFabricIndex;
+    private findStoredCredential;
+    private getStoredCredentialStateDebug;
+    private logStoredCredentialState;
+    private hasMatchingPinCredential;
+    private validateRemotePinCode;
+    private getNextOccupiedCredentialIndex;
+    private upsertStoredCredential;
+    private clearStoredCredential;
+    lockDoor(request: DoorLock.LockDoorRequest): Promise<void>;
+    unlockDoor(request: DoorLock.UnlockDoorRequest): Promise<void>;
+    unlockWithTimeout(request: DoorLock.UnlockWithTimeoutRequest): Promise<void>;
+    setUser(request: DoorLock.SetUserRequest): Promise<void>;
+    getUser(request: DoorLock.GetUserRequest): Promise<DoorLock.GetUserResponse>;
+    clearUser(request: DoorLock.ClearUserRequest): Promise<void>;
+    setCredential(request: DoorLock.SetCredentialRequest): Promise<DoorLock.SetCredentialResponse>;
+    getCredentialStatus(request: DoorLock.GetCredentialStatusRequest): Promise<DoorLock.GetCredentialStatusResponse>;
+    clearCredential(request: DoorLock.ClearCredentialRequest): Promise<void>;
+}
+export declare namespace MatterbridgeUserPinDoorLockServer {
+    type StoredCredential = DoorLock.Credential & {
+        credentialData: Uint8Array;
+    };
+    type StoredUser = {
+        userIndex: number;
+        userName: string | null;
+        userUniqueId: number | null;
+        userStatus: DoorLock.UserStatus | null;
+        userType: DoorLock.UserType | null;
+        credentialRule: DoorLock.CredentialRule | null;
+        credentials: StoredCredential[] | null;
+        creatorFabricIndex: FabricIndex | null;
+        lastModifiedFabricIndex: FabricIndex | null;
+        nextUserIndex: number | null;
+    };
+    class Internal {
+        users: StoredUser[];
+    }
 }
 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 {

package/dist/matterbridgeBehaviorsServer.js

@@ -32,7 +32,11 @@ 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() {
@@ -343,7 +347,54 @@ 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.with(DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess) {
+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})`);
@@ -370,6 +421,19 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         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})`);
@@ -423,7 +487,394 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
         });
         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);

package/dist/matterbridgeEndpoint.d.ts

@@ -173,6 +173,7 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     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;
+    createUserPinDoorLockClusterServer(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, MatterbridgeFanControlServer, MatterbridgeHepaFilterMonitoringServer, MatterbridgeIdentifyServer, MatterbridgeLevelControlServer, MatterbridgeModeSelectServer, MatterbridgeOnOffServer, MatterbridgeOperationalStateServer, MatterbridgePowerSourceServer, MatterbridgeServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeSwitchServer, MatterbridgeThermostatServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeWindowCoveringServer, } from './matterbridgeBehaviorsServer.js';
+import { MatterbridgeActivatedCarbonFilterMonitoringServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeColorControlServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeDoorLockServer, MatterbridgeFanControlServer, MatterbridgeHepaFilterMonitoringServer, MatterbridgeIdentifyServer, MatterbridgeLevelControlServer, MatterbridgeModeSelectServer, MatterbridgeOnOffServer, MatterbridgeOperationalStateServer, MatterbridgePinDoorLockServer, MatterbridgePowerSourceServer, MatterbridgeServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeSwitchServer, MatterbridgeThermostatServer, MatterbridgeUserPinDoorLockServer, 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');
@@ -1048,7 +1048,10 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
     createDefaultDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt) {
-        this.behaviors.require(MatterbridgeDoorLockServer.with().enable({ events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true } }), {
+        this.behaviors.require(MatterbridgeDoorLockServer.enable({
+            events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
+            commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true },
+        }), {
             lockState,
             lockType,
             actuatorEnabled: true,
@@ -1059,8 +1062,9 @@ 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({
+        this.behaviors.require(MatterbridgePinDoorLockServer.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 },
         }), {
             lockState,
             lockType,
@@ -1069,12 +1073,35 @@ export class MatterbridgeEndpoint extends Endpoint {
             supportedOperatingModes: { normal: false, vacation: true, privacy: true, noRemoteLockUnlock: false, passage: true, alwaysSet: 2047 },
             autoRelockTime: 0,
             numberOfPinUsersSupported: 10,
-            minPinCodeLength: 4,
             maxPinCodeLength: 10,
+            minPinCodeLength: 4,
+            wrongCodeEntryLimit: 5,
+            userCodeTemporaryDisableTime: 60,
             sendPinOverTheAir: true,
             requirePinForRemoteOperation: true,
+        });
+        return this;
+    }
+    createUserPinDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt) {
+        this.behaviors.require(MatterbridgeUserPinDoorLockServer.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 },
+        }), {
+            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,
+            maxPinCodeLength: 10,
+            minPinCodeLength: 4,
             wrongCodeEntryLimit: 5,
             userCodeTemporaryDisableTime: 60,
+            requirePinForRemoteOperation: true,
+            numberOfTotalUsersSupported: 10,
+            credentialRulesSupport: { single: true },
+            numberOfCredentialsSupportedPerUser: 10,
         });
         return this;
     }

package/dist/matterbridgeEndpointCommandHandler.d.ts

@@ -71,16 +71,6 @@ 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;
@@ -393,16 +383,6 @@ 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;
@@ -417,6 +397,13 @@ export type CommandHandlerDataMap = {
         attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
         endpoint: MatterbridgeEndpoint;
     };
+    'DoorLock.unlockWithTimeout': {
+        command: 'unlockWithTimeout';
+        request: DoorLock.UnlockWithTimeoutRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'DoorLock.setPinCode': {
         command: 'setPinCode';
         request: DoorLock.SetPinCodeRequest;
@@ -445,6 +432,34 @@ export type CommandHandlerDataMap = {
         attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
         endpoint: MatterbridgeEndpoint;
     };
+    'DoorLock.setUserStatus': {
+        command: 'setUserStatus';
+        request: DoorLock.SetUserStatusRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DoorLock.getUserStatus': {
+        command: 'getUserStatus';
+        request: DoorLock.GetUserStatusRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DoorLock.setUserType': {
+        command: 'setUserType';
+        request: DoorLock.SetUserTypeRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'DoorLock.getUserType': {
+        command: 'getUserType';
+        request: DoorLock.GetUserTypeRequest;
+        cluster: 'doorLock';
+        attributes: ClusterAttributeValues<(typeof DoorLock.Complete)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'DoorLock.setUser': {
         command: 'setUser';
         request: DoorLock.SetUserRequest;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.7.1-dev-20260326-7d15a50",
+  "version": "3.7.1",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -122,10 +122,10 @@
   ],
   "dependencies": {
     "@matter/main": "0.16.10",
-    "@matterbridge/dgram": "3.7.1-dev-20260326-7d15a50",
-    "@matterbridge/thread": "3.7.1-dev-20260326-7d15a50",
-    "@matterbridge/types": "3.7.1-dev-20260326-7d15a50",
-    "@matterbridge/utils": "3.7.1-dev-20260326-7d15a50",
+    "@matterbridge/dgram": "3.7.1",
+    "@matterbridge/thread": "3.7.1",
+    "@matterbridge/types": "3.7.1",
+    "@matterbridge/utils": "3.7.1",
     "express": "5.2.1",
     "multer": "2.1.1",
     "node-ansi-logger": "3.2.0",