@matterbridge/core 3.7.2-dev-20260330-bb55c39 → 3.7.2-dev-20260402-c12a10e

package/dist/behaviors/doorLockServer.js

@@ -1,7 +1,13 @@
 import { DoorLockServer } from '@matter/node/behaviors/door-lock';
+import { hasRemoteActor } from '@matter/protocol';
 import { DoorLock } from '@matter/types/clusters/door-lock';
+import { StatusResponse } from '@matter/types/common';
+import { FabricIndex } from '@matter/types/datatype';
+import { Status } from '@matter/types/globals';
+import { getEnumDescription } from '@matterbridge/utils/enum';
+import { debugStringify } from 'node-ansi-logger';
 import { MatterbridgeServer } from './matterbridgeServer.js';
-export class MatterbridgeDoorLockServer extends DoorLockServer.enable({
+export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Feature.User, DoorLock.Feature.PinCredential).enable({
     events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
     commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true },
 }) {
@@ -43,7 +49,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.enable({
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called`);
+        device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called ${this.state.autoRelockTime ? 'with ' + this.state.autoRelockTime + ' seconds' : 'without'} autoRelockTime ${this.internal.enableTimeout ? 'with' : 'without'} enableTimeout`);
         await super.unlockDoor(request);
         if (!this.internal.enableTimeout)
             return;
@@ -52,9 +58,9 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.enable({
             this.internal.unlockTimeout = setTimeout(async () => {
                 this.internal.unlockTimeout = undefined;
                 const device = this.endpoint.stateOf(MatterbridgeServer);
-                const state = this.endpoint.stateOf(MatterbridgeDoorLockServer);
+                const state = this.endpoint.stateOf(MatterbridgeDoorLockServer.with());
                 device.log.info(`Auto-relocking door after ${state.autoRelockTime} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-                await this.endpoint.act((agent) => agent.get(MatterbridgeDoorLockServer).lockDoor({ pinCode: request.pinCode }));
+                await this.endpoint.act((agent) => agent.get(MatterbridgeDoorLockServer.with()).lockDoor({ pinCode: request.pinCode }));
             }, this.state.autoRelockTime * 1000).unref();
         }
     }
@@ -73,7 +79,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.enable({
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeDoorLockServer: unlockWithTimeout called`);
+        device.log.debug(`MatterbridgeDoorLockServer: unlockWithTimeout called ${this.internal.enableTimeout ? 'with' : 'without'} enableTimeout`);
         this.state.lockState = DoorLock.LockState.Unlocked;
         if (!this.internal.enableTimeout)
             return;
@@ -83,15 +89,355 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.enable({
                 this.internal.unlockTimeout = undefined;
                 const device = this.endpoint.stateOf(MatterbridgeServer);
                 device.log.info(`Locking door after ${request.timeout} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-                await this.endpoint.act((agent) => agent.get(MatterbridgeDoorLockServer).lockDoor({ pinCode: request.pinCode }));
+                await this.endpoint.act((agent) => agent.get(MatterbridgeDoorLockServer.with()).lockDoor({ pinCode: request.pinCode }));
             }, request.timeout * 1000).unref();
         }
     }
+    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,
+            context: this.context,
+        });
+        const user = this.internal.users.find((storedUser) => storedUser.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 ?? 0xffffffff,
+                userStatus: request.userStatus ?? DoorLock.UserStatus.OccupiedEnabled,
+                userType: request.userType ?? DoorLock.UserType.UnrestrictedUser,
+                credentialRule: request.credentialRule ?? DoorLock.CredentialRule.Single,
+                credentials: [],
+                creatorFabricIndex: accessingFabricIndex,
+                lastModifiedFabricIndex: accessingFabricIndex,
+            });
+            this.events.lockUserChange.emit({
+                lockDataType: DoorLock.LockDataType.UserIndex,
+                dataOperationType: DoorLock.DataOperationType.Add,
+                operationSource: this.getOperationSource(),
+                userIndex: request.userIndex,
+                fabricIndex: accessingFabricIndex,
+                sourceNode: this.getAccessingNodeId(),
+                dataIndex: request.userIndex,
+            }, this.context);
+            device.log.debug(`MatterbridgeDoorLockServer: added userIndex ${request.userIndex} (total users: ${this.internal.users.length}) to internal state: ${debugStringify(this.internal.users.find((storedUser) => storedUser.userIndex === request.userIndex))}`);
+        }
+        else if (user && request.operationType === DoorLock.DataOperationType.Modify) {
+            user.userName = request.userName ?? user.userName;
+            user.userUniqueId = request.userUniqueId ?? user.userUniqueId;
+            user.userStatus = request.userStatus ?? user.userStatus;
+            user.userType = request.userType ?? user.userType;
+            user.credentialRule = request.credentialRule ?? user.credentialRule;
+            user.lastModifiedFabricIndex = accessingFabricIndex;
+            this.events.lockUserChange.emit({
+                lockDataType: DoorLock.LockDataType.UserIndex,
+                dataOperationType: DoorLock.DataOperationType.Modify,
+                operationSource: this.getOperationSource(),
+                userIndex: request.userIndex,
+                fabricIndex: accessingFabricIndex,
+                sourceNode: this.getAccessingNodeId(),
+                dataIndex: request.userIndex,
+            }, this.context);
+            device.log.debug(`MatterbridgeDoorLockServer: modified userIndex ${request.userIndex} (total users: ${this.internal.users.length}) in internal state: ${debugStringify(user)}`);
+        }
+    }
+    async getUser(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Getting userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        const response = await device.commandHandler.executeHandler('DoorLock.getUser', {
+            command: 'getUser',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        if (response !== undefined) {
+            return response;
+        }
+        device.log.debug(`MatterbridgeDoorLockServer: getUser called for userIndex ${request.userIndex}`);
+        if (!this.validateUserIndex(request.userIndex))
+            throw new StatusResponse.InvalidCommandError('Invalid userIndex in GetUser request');
+        const user = this.internal.users.find((storedUser) => storedUser.userIndex === request.userIndex);
+        if (!user) {
+            return {
+                userIndex: request.userIndex,
+                userName: null,
+                userUniqueId: null,
+                userStatus: null,
+                userType: null,
+                credentialRule: null,
+                credentials: null,
+                creatorFabricIndex: null,
+                lastModifiedFabricIndex: null,
+                nextUserIndex: null,
+            };
+        }
+        return {
+            ...user,
+            credentials: user.credentials?.map(({ credentialType, credentialIndex }) => ({ credentialType, credentialIndex })) ?? null,
+            nextUserIndex: this.getNextUserIndex(request.userIndex),
+        };
+    }
+    async clearUser(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const accessingFabricIndex = this.getAccessingFabricIndex();
+        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,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: clearUser called for userIndex ${request.userIndex}`);
+        if (request.userIndex != 0xfffe && !this.validateUserIndex(request.userIndex))
+            throw new StatusResponse.InvalidCommandError('Invalid userIndex in ClearUser request');
+        if (request.userIndex === 0xfffe) {
+            this.internal.users = [];
+        }
+        else {
+            this.internal.users = this.internal.users.filter((storedUser) => storedUser.userIndex !== request.userIndex);
+        }
+        this.events.lockUserChange.emit({
+            lockDataType: DoorLock.LockDataType.UserIndex,
+            dataOperationType: DoorLock.DataOperationType.Clear,
+            operationSource: this.getOperationSource(),
+            userIndex: request.userIndex,
+            fabricIndex: accessingFabricIndex,
+            sourceNode: this.getAccessingNodeId(),
+            dataIndex: request.userIndex,
+        }, this.context);
+    }
+    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,
+            context: this.context,
+        });
+        const user = this.internal.users.find((storedUser) => storedUser.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'})`);
+        if (user && (request.operationType === DoorLock.DataOperationType.Add || request.operationType === DoorLock.DataOperationType.Modify)) {
+            const credential = user.credentials?.find((storedCredential) => storedCredential.credentialType === request.credential.credentialType && storedCredential.credentialIndex === request.credential.credentialIndex);
+            if (credential) {
+                credential.credentialData = request.credentialData;
+                credential.creatorFabricIndex = credential.creatorFabricIndex ?? accessingFabricIndex;
+                credential.lastModifiedFabricIndex = accessingFabricIndex;
+                device.log.debug(`MatterbridgeDoorLockServer: modified credentialIndex ${request.credential.credentialIndex} for userIndex ${request.userIndex} in internal state: ${debugStringify(user)}`);
+            }
+            else {
+                user.credentials = user.credentials ?? [];
+                user.credentials.push({
+                    credentialType: request.credential.credentialType,
+                    credentialIndex: request.credential.credentialIndex,
+                    credentialData: request.credentialData,
+                    creatorFabricIndex: accessingFabricIndex,
+                    lastModifiedFabricIndex: accessingFabricIndex,
+                });
+                device.log.debug(`MatterbridgeDoorLockServer: added credentialIndex ${request.credential.credentialIndex} for userIndex ${request.userIndex} to internal state: ${debugStringify(user)}`);
+            }
+            this.events.lockUserChange.emit({
+                lockDataType: this.getLockDataTypeForCredentialType(request.credential.credentialType),
+                dataOperationType: request.operationType,
+                operationSource: this.getOperationSource(),
+                userIndex: request.userIndex,
+                fabricIndex: accessingFabricIndex,
+                sourceNode: this.getAccessingNodeId(),
+                dataIndex: this.getCredentialDataIndex(request.credential),
+            }, this.context);
+        }
+        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,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: getCredentialStatus called`);
+        const credentialRecord = this.findStoredCredential(request.credential);
+        const nextCredentialIndex = this.getNextOccupiedCredentialIndex(request.credential);
+        const response = {
+            credentialExists: credentialRecord !== null,
+            userIndex: credentialRecord?.user.userIndex ?? null,
+            creatorFabricIndex: credentialRecord?.storedCredential.creatorFabricIndex ?? null,
+            lastModifiedFabricIndex: credentialRecord?.storedCredential.lastModifiedFabricIndex ?? null,
+            nextCredentialIndex,
+        };
+        device.log.debug(`MatterbridgeDoorLockServer: getCredentialStatus result ${debugStringify(response)}`);
+        return response;
+    }
+    async clearCredential(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const accessingFabricIndex = this.getAccessingFabricIndex();
+        const clearedCredentialUserIndex = request.credential !== null && request.credential.credentialIndex !== 0xfffe ? (this.findStoredCredential(request.credential)?.user.userIndex ?? null) : null;
+        const credentialTypesToClear = request.credential !== null ? [request.credential.credentialType] : this.getStoredCredentialTypes();
+        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,
+            context: this.context,
+        });
+        device.log.debug('MatterbridgeDoorLockServer: clearCredential called');
+        for (const user of this.internal.users) {
+            user.credentials =
+                user.credentials?.filter((storedCredential) => {
+                    if (request.credential === null) {
+                        return false;
+                    }
+                    if (storedCredential.credentialType !== request.credential.credentialType) {
+                        return true;
+                    }
+                    if (request.credential.credentialIndex === 0xfffe) {
+                        return false;
+                    }
+                    return storedCredential.credentialIndex !== request.credential.credentialIndex;
+                }) ?? user.credentials;
+        }
+        for (const credentialType of credentialTypesToClear) {
+            this.events.lockUserChange.emit({
+                lockDataType: this.getLockDataTypeForCredentialType(credentialType),
+                dataOperationType: DoorLock.DataOperationType.Clear,
+                operationSource: this.getOperationSource(),
+                userIndex: request.credential === null || request.credential.credentialIndex === 0xfffe ? null : clearedCredentialUserIndex,
+                fabricIndex: accessingFabricIndex,
+                sourceNode: this.getAccessingNodeId(),
+                dataIndex: request.credential === null ? 0xfffe : this.getCredentialDataIndex(request.credential),
+            }, this.context);
+        }
+    }
+    validateUserIndex(userIndex) {
+        if (userIndex < 1 || userIndex > this.state.numberOfTotalUsersSupported) {
+            return false;
+        }
+        return true;
+    }
+    getNextUserIndex(userIndex) {
+        const nextUser = this.internal.users.find((storedUser) => storedUser.userIndex === userIndex + 1);
+        if (nextUser && nextUser.userStatus !== DoorLock.UserStatus.Available) {
+            return nextUser.userIndex;
+        }
+        return null;
+    }
+    getAccessingFabricIndex() {
+        let fabricIndex;
+        try {
+            fabricIndex = this.context.fabric;
+        }
+        catch {
+            return null;
+        }
+        if (fabricIndex === undefined || fabricIndex === FabricIndex.NO_FABRIC) {
+            return null;
+        }
+        return fabricIndex;
+    }
+    getAccessingNodeId() {
+        if (!hasRemoteActor(this.context)) {
+            return null;
+        }
+        return this.context.session.peerNodeId ?? null;
+    }
+    getOperationSource() {
+        return this.getAccessingNodeId() !== null ? DoorLock.OperationSource.Remote : DoorLock.OperationSource.Unspecified;
+    }
+    getLockDataTypeForCredentialType(credentialType) {
+        switch (credentialType) {
+            case DoorLock.CredentialType.ProgrammingPin:
+                return DoorLock.LockDataType.ProgrammingCode;
+            case DoorLock.CredentialType.Pin:
+                return DoorLock.LockDataType.Pin;
+            case DoorLock.CredentialType.Rfid:
+                return DoorLock.LockDataType.Rfid;
+            case DoorLock.CredentialType.Fingerprint:
+                return DoorLock.LockDataType.Fingerprint;
+            case DoorLock.CredentialType.FingerVein:
+                return DoorLock.LockDataType.FingerVein;
+            case DoorLock.CredentialType.Face:
+                return DoorLock.LockDataType.Face;
+            case DoorLock.CredentialType.AliroCredentialIssuerKey:
+                return DoorLock.LockDataType.AliroCredentialIssuerKey;
+            case DoorLock.CredentialType.AliroEvictableEndpointKey:
+                return DoorLock.LockDataType.AliroEvictableEndpointKey;
+            case DoorLock.CredentialType.AliroNonEvictableEndpointKey:
+                return DoorLock.LockDataType.AliroNonEvictableEndpointKey;
+            default:
+                return DoorLock.LockDataType.Unspecified;
+        }
+    }
+    getCredentialDataIndex(credential) {
+        if (credential.credentialType === DoorLock.CredentialType.ProgrammingPin) {
+            return null;
+        }
+        return credential.credentialIndex;
+    }
+    getStoredCredentialTypes() {
+        const credentialTypes = new Set();
+        for (const user of this.internal.users) {
+            for (const credential of user.credentials ?? []) {
+                credentialTypes.add(credential.credentialType);
+            }
+        }
+        return [...credentialTypes];
+    }
+    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;
+    }
+    getNextOccupiedCredentialIndex(credential) {
+        for (const user of this.internal.users) {
+            for (const storedCredential of user.credentials ?? []) {
+                if (storedCredential.credentialType !== credential.credentialType || storedCredential.credentialIndex <= credential.credentialIndex) {
+                    continue;
+                }
+                return storedCredential.credentialIndex;
+            }
+        }
+        return null;
+    }
 }
 (function (MatterbridgeDoorLockServer) {
     class Internal {
         enableTimeout = true;
         unlockTimeout;
+        users = [];
     }
     MatterbridgeDoorLockServer.Internal = Internal;
 })(MatterbridgeDoorLockServer || (MatterbridgeDoorLockServer = {}));

package/dist/behaviors/export.d.ts

@@ -13,12 +13,10 @@ export * from './matterbridgeServer.js';
 export * from './modeSelectServer.js';
 export * from './onOffServer.js';
 export * from './operationalStateServer.js';
-export * from './pinDoorLockServer.js';
 export * from './powerSourceServer.js';
 export * from './serviceAreaServer.js';
 export * from './smokeCoAlarmServer.js';
 export * from './switchServer.js';
 export * from './thermostatServer.js';
-export * from './userPinDoorLockServer.js';
 export * from './valveConfigurationAndControlServer.js';
 export * from './windowCoveringServer.js';

package/dist/behaviors/export.js

@@ -13,12 +13,10 @@ export * from './matterbridgeServer.js';
 export * from './modeSelectServer.js';
 export * from './onOffServer.js';
 export * from './operationalStateServer.js';
-export * from './pinDoorLockServer.js';
 export * from './powerSourceServer.js';
 export * from './serviceAreaServer.js';
 export * from './smokeCoAlarmServer.js';
 export * from './switchServer.js';
 export * from './thermostatServer.js';
-export * from './userPinDoorLockServer.js';
 export * from './valveConfigurationAndControlServer.js';
 export * from './windowCoveringServer.js';

package/dist/cli.js

@@ -12,7 +12,8 @@ export let instance;
 export const tracker = new Tracker('Cli', false, false);
 export const inspector = new Inspector('Cli', false, false);
 const manager = new ThreadsManager();
-if (process.argv.includes('--no-ansi') || process.argv.includes('-no-ansi'))
+const colorEnabled = Boolean(process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== 'dumb' && process.env.FORCE_COLOR !== '0' && !hasParameter('no-ansi'));
+if (!colorEnabled)
     process.env.NO_COLOR = '1';
 const log = new AnsiLogger({ logName: 'Cli', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
 function startCpuMemoryCheck() {

package/dist/export.d.ts

@@ -13,13 +13,11 @@ export * from './behaviors/matterbridgeServer.js';
 export * from './behaviors/modeSelectServer.js';
 export * from './behaviors/onOffServer.js';
 export * from './behaviors/operationalStateServer.js';
-export * from './behaviors/pinDoorLockServer.js';
 export * from './behaviors/powerSourceServer.js';
 export * from './behaviors/serviceAreaServer.js';
 export * from './behaviors/smokeCoAlarmServer.js';
 export * from './behaviors/switchServer.js';
 export * from './behaviors/thermostatServer.js';
-export * from './behaviors/userPinDoorLockServer.js';
 export * from './behaviors/valveConfigurationAndControlServer.js';
 export * from './behaviors/windowCoveringServer.js';
 export { addVirtualDevice } from './helpers.js';

package/dist/export.js

@@ -15,13 +15,11 @@ export * from './behaviors/matterbridgeServer.js';
 export * from './behaviors/modeSelectServer.js';
 export * from './behaviors/onOffServer.js';
 export * from './behaviors/operationalStateServer.js';
-export * from './behaviors/pinDoorLockServer.js';
 export * from './behaviors/powerSourceServer.js';
 export * from './behaviors/serviceAreaServer.js';
 export * from './behaviors/smokeCoAlarmServer.js';
 export * from './behaviors/switchServer.js';
 export * from './behaviors/thermostatServer.js';
-export * from './behaviors/userPinDoorLockServer.js';
 export * from './behaviors/valveConfigurationAndControlServer.js';
 export * from './behaviors/windowCoveringServer.js';
 export { addVirtualDevice } from './helpers.js';

package/dist/frontend.d.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'node:events';
 import { EndpointNumber } from '@matter/types/datatype';
-import type { ApiMatter, RefreshRequiredChanged, WsMessageBroadcast } from '@matterbridge/types';
+import type { ApiClusters, ApiDevice, ApiMatter, ApiPlugin, ApiSettings, RefreshRequiredChanged, WsMessageBroadcast } from '@matterbridge/types';
 import { LogLevel } from 'node-ansi-logger';
 import type { Matterbridge } from './matterbridge.js';
 interface FrontendEvents {
@@ -15,8 +15,8 @@ export declare class Frontend extends EventEmitter<FrontendEvents> {
     private log;
     private port;
     private listening;
-    private storedPassword;
-    private authClients;
+    storedPassword: string | undefined;
+    authClients: Set<string>;
     private expressApp;
     private httpServer;
     private httpsServer;
@@ -25,22 +25,29 @@ export declare class Frontend extends EventEmitter<FrontendEvents> {
     private serverFetchTimeout;
     private readonly debug;
     private readonly verbose;
+    readonly readOnly: boolean;
+    readonly shellyBoard: boolean;
+    shellySysUpdate: boolean;
+    shellyMainUpdate: boolean;
+    restartRequired: boolean;
+    fixedRestartRequired: boolean;
+    updateRequired: boolean;
     constructor(matterbridge: Matterbridge);
     destroy(): void;
-    private msgHandler;
+    private broadcastMsgHandler;
     set logLevel(logLevel: LogLevel);
     private validateReq;
     start(port?: number): Promise<void>;
     stop(): Promise<void>;
-    private getApiSettings;
+    getApiSettings(): ApiSettings;
     private getReachability;
     private getPowerSource;
     private getBatteryLevel;
     private getClusterTextFromDevice;
-    private getPlugins;
-    private getDevices;
-    private getClusters;
-    private generateDiagnostic;
+    getApiPlugins(): ApiPlugin[];
+    getApiDevices(pluginName?: string): ApiDevice[];
+    getClusters(pluginName: string, endpointNumber: number, serialNumber?: string, uniqueId?: string): ApiClusters | undefined;
+    generateDiagnostic(): Promise<void>;
     private wsMessageHandler;
     wssSendLogMessage(level: string, time: string, name: string, message: string): void;
     wssSendRefreshRequired(changed: RefreshRequiredChanged, params?: {