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

package/dist/matterbridgeEndpoint.js

@@ -76,12 +76,10 @@ import { MatterbridgeServer } from './behaviors/matterbridgeServer.js';
 import { MatterbridgeModeSelectServer } from './behaviors/modeSelectServer.js';
 import { MatterbridgeOnOffServer } from './behaviors/onOffServer.js';
 import { MatterbridgeOperationalStateServer } from './behaviors/operationalStateServer.js';
-import { MatterbridgePinDoorLockServer } from './behaviors/pinDoorLockServer.js';
 import { MatterbridgePowerSourceServer } from './behaviors/powerSourceServer.js';
 import { MatterbridgeSmokeCoAlarmServer } from './behaviors/smokeCoAlarmServer.js';
 import { MatterbridgeSwitchServer } from './behaviors/switchServer.js';
 import { MatterbridgeThermostatServer } from './behaviors/thermostatServer.js';
-import { MatterbridgeUserPinDoorLockServer } from './behaviors/userPinDoorLockServer.js';
 import { MatterbridgeValveConfigurationAndControlServer } from './behaviors/valveConfigurationAndControlServer.js';
 import { MatterbridgeWindowCoveringServer } from './behaviors/windowCoveringServer.js';
 import { CommandHandler } from './matterbridgeEndpointCommandHandler.js';
@@ -264,7 +262,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
     async executeCommandHandler(command, request, cluster, attributes, endpoint) {
-        await this.commandHandler.executeHandler(command, { command, request, cluster, attributes, endpoint });
+        return this.commandHandler.executeHandler(command, { command, request, cluster, attributes, endpoint });
     }
     async invokeBehaviorCommand(cluster, command, params) {
         await invokeBehaviorCommand(this, cluster, command, params);
@@ -1068,8 +1066,8 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
-    createDefaultDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt) {
-        this.behaviors.require(MatterbridgeDoorLockServer.enable({
+    createDefaultDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt, autoRelockTime = 0) {
+        this.behaviors.require(MatterbridgeDoorLockServer.with().enable({
             events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
             commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true },
         }), {
@@ -1078,33 +1076,12 @@ export class MatterbridgeEndpoint extends Endpoint {
             actuatorEnabled: true,
             operatingMode: DoorLock.OperatingMode.Normal,
             supportedOperatingModes: { normal: false, vacation: true, privacy: true, noRemoteLockUnlock: false, passage: true, alwaysSet: 2047 },
-            autoRelockTime: 0,
+            autoRelockTime,
         });
         return this;
     }
-    createPinDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt) {
-        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,
-            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,
-            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({
+    createUserPinDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt, autoRelockTime = 0, minPinCodeLength = 4, maxPinCodeLength = 10) {
+        this.behaviors.require(MatterbridgeDoorLockServer.with(DoorLock.Feature.User, DoorLock.Feature.PinCredential).enable({
             events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
             commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true },
         }), {
@@ -1113,13 +1090,12 @@ export class MatterbridgeEndpoint extends Endpoint {
             actuatorEnabled: true,
             operatingMode: DoorLock.OperatingMode.Normal,
             supportedOperatingModes: { normal: false, vacation: true, privacy: true, noRemoteLockUnlock: false, passage: true, alwaysSet: 2047 },
-            autoRelockTime: 0,
+            autoRelockTime,
             numberOfPinUsersSupported: 10,
-            maxPinCodeLength: 10,
-            minPinCodeLength: 4,
+            minPinCodeLength,
+            maxPinCodeLength,
             wrongCodeEntryLimit: 5,
             userCodeTemporaryDisableTime: 60,
-            requirePinForRemoteOperation: true,
             numberOfTotalUsersSupported: 10,
             credentialRulesSupport: { single: true },
             numberOfCredentialsSupportedPerUser: 10,

package/dist/matterbridgeEndpointCommandHandler.d.ts

@@ -129,7 +129,10 @@ export type CommandHandlerData<T extends CommandHandlers = CommandHandlers> = Co
 export type CommandHandlerPayload<T extends CommandHandlers = CommandHandlers> = CommandHandlerData<T> & {
     context?: ActionContext;
 };
-export type CommandHandlerFunction<T extends CommandHandlers = CommandHandlers> = (data: CommandHandlerPayload<T>) => void | Promise<void>;
+type VoidReturn = ReturnType<() => void>;
+export type CommandHandlerResponse<T extends CommandHandlers = CommandHandlers> = T extends keyof CommandHandlerResponseMap ? CommandHandlerResponseMap[T] : VoidReturn;
+export type CommandHandlerExecutionResult<T extends CommandHandlers = CommandHandlers> = T extends keyof CommandHandlerResponseMap ? CommandHandlerResponseMap[T] | undefined : VoidReturn;
+export type CommandHandlerFunction<T extends CommandHandlers = CommandHandlers> = (data: CommandHandlerPayload<T>) => CommandHandlerResponse<T> | Promise<CommandHandlerResponse<T>>;
 export type CommandHandlerDataMap = {
     'identify': CommandHandlerData<'Identify.identify'>;
     'triggerEffect': CommandHandlerData<'Identify.triggerEffect'>;
@@ -918,11 +921,14 @@ export type CommandHandlerDataMap = {
         endpoint: MatterbridgeEndpoint;
     };
 };
+export type CommandHandlerResponseMap = {
+    'DoorLock.getUser': DoorLock.GetUserResponse;
+};
 export declare class CommandHandler {
     private handler;
     hasHandler<K extends CommandHandlers>(command: K): boolean;
     addHandler<K extends CommandHandlers>(command: K, handler: CommandHandlerFunction<K>): void;
-    executeHandler<K extends CommandHandlers>(command: K, ...args: Parameters<CommandHandlerFunction<K>>): Promise<void>;
+    executeHandler<K extends CommandHandlers>(command: K, ...args: Parameters<CommandHandlerFunction<K>>): Promise<CommandHandlerExecutionResult<K>>;
     removeHandler<K extends CommandHandlers>(command: K, handler: CommandHandlerFunction<K>): void;
 }
 export {};

package/dist/matterbridgeEndpointCommandHandler.js

@@ -16,12 +16,13 @@ export class CommandHandler {
         }
         const fallbackCommand = command.includes('.') ? command.split('.').pop() : undefined;
         if (fallbackCommand === undefined)
-            return;
+            return undefined;
         for (const { command: registeredCommand, handler } of this.handler) {
             if (registeredCommand === fallbackCommand) {
                 return await handler(...args);
             }
         }
+        return undefined;
     }
     removeHandler(command, handler) {
         this.handler = this.handler.filter(({ command: registeredCommand, handler: registeredHandler }) => {

package/dist/pluginManager.d.ts

@@ -74,6 +74,7 @@ export declare class PluginManager extends EventEmitter<PluginManagerEvents> {
     install(packageName: string): void;
     uninstall(packageName: string): void;
     getAuthor(packageJson: Record<string, string | number | Record<string, string | number | object>>): string;
+    getDescription(packageJson: Record<string, string | number | Record<string, string | number | object>>): string;
     getHomepage(packageJson: Record<string, string | number | Record<string, string | number | object>>): string | undefined;
     getHelp(packageJson: Record<string, string | number | Record<string, string | number | object>>): string | undefined;
     getChangelog(packageJson: Record<string, string | number | Record<string, string | number | object>>): string | undefined;

package/dist/pluginManager.js

@@ -537,6 +537,11 @@ export class PluginManager extends EventEmitter {
             return packageJson.author.name;
         return 'Unknown author';
     }
+    getDescription(packageJson) {
+        if (packageJson.description && typeof packageJson.description === 'string')
+            return packageJson.description;
+        return 'No description';
+    }
     getHomepage(packageJson) {
         if (packageJson.homepage && typeof packageJson.homepage === 'string' && packageJson.homepage.includes('http')) {
             return packageJson.homepage.replace('git+', '').replace('.git', '');
@@ -828,7 +833,7 @@ export class PluginManager extends EventEmitter {
             if (pluginInstance.default) {
                 const config = await this.loadConfig(plugin);
                 plugin.name = packageJson.name;
-                plugin.description = packageJson.description ?? 'No description';
+                plugin.description = this.getDescription(packageJson);
                 plugin.version = packageJson.version;
                 plugin.author = this.getAuthor(packageJson);
                 plugin.configJson = config;
@@ -853,7 +858,7 @@ export class PluginManager extends EventEmitter {
                 platform.isLoaded = true;
                 platform.setMatterNode?.(this.matterbridge.addBridgedEndpoint.bind(this.matterbridge), this.matterbridge.removeBridgedEndpoint.bind(this.matterbridge), this.matterbridge.removeAllBridgedEndpoints.bind(this.matterbridge), this.matterbridge.addVirtualEndpoint.bind(this.matterbridge));
                 plugin.name = packageJson.name;
-                plugin.description = packageJson.description ?? 'No description';
+                plugin.description = this.getDescription(packageJson);
                 plugin.version = packageJson.version;
                 plugin.author = this.getAuthor(packageJson);
                 plugin.homepage = this.getHomepage(packageJson);
@@ -1150,6 +1155,13 @@ export class PluginManager extends EventEmitter {
                     'readOnly': true,
                     'ui:widget': 'hidden',
                 },
+                version: {
+                    'title': 'Plugin Version',
+                    'description': 'Plugin version',
+                    'type': 'string',
+                    'readOnly': true,
+                    'ui:widget': 'hidden',
+                },
                 debug: {
                     title: 'Enable Debug',
                     description: 'Enable the debug for the plugin (development only)',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.7.2-dev-20260330-bb55c39",
+  "version": "3.7.2-dev-20260402-c12a10e",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -126,10 +126,10 @@
   ],
   "dependencies": {
     "@matter/main": "0.16.10",
-    "@matterbridge/dgram": "3.7.2-dev-20260330-bb55c39",
-    "@matterbridge/thread": "3.7.2-dev-20260330-bb55c39",
-    "@matterbridge/types": "3.7.2-dev-20260330-bb55c39",
-    "@matterbridge/utils": "3.7.2-dev-20260330-bb55c39",
+    "@matterbridge/dgram": "3.7.2-dev-20260402-c12a10e",
+    "@matterbridge/thread": "3.7.2-dev-20260402-c12a10e",
+    "@matterbridge/types": "3.7.2-dev-20260402-c12a10e",
+    "@matterbridge/utils": "3.7.2-dev-20260402-c12a10e",
     "express": "5.2.1",
     "multer": "2.1.1",
     "node-ansi-logger": "3.2.1-dev-20260327-7069fd7",

package/dist/behaviors/pinDoorLockServer.d.ts

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

package/dist/behaviors/pinDoorLockServer.js

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

package/dist/behaviors/userPinDoorLockServer.d.ts

@@ -1,57 +0,0 @@
-import { DoorLockServer } from '@matter/node/behaviors/door-lock';
-import { DoorLock } from '@matter/types/clusters/door-lock';
-import { FabricIndex } from '@matter/types/datatype';
-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[];
-    }
-}
-export {};