@matterbridge/core 3.7.2-dev-20260329-5cac980 → 3.7.2-dev-20260331-ac050d8

package/dist/matterbridgeEndpoint.d.ts

@@ -24,7 +24,7 @@ import { ClusterId, EndpointNumber } from '@matter/types/datatype';
 import { Semtag } from '@matter/types/globals';
 import { AnsiLogger, LogLevel } from 'node-ansi-logger';
 import { DeviceTypeDefinition } from './matterbridgeDeviceTypes.js';
-import { CommandHandler, CommandHandlerData, CommandHandlerFunction, CommandHandlers } from './matterbridgeEndpointCommandHandler.js';
+import { CommandHandler, CommandHandlerData, CommandHandlerExecutionResult, CommandHandlerFunction, CommandHandlers } from './matterbridgeEndpointCommandHandler.js';
 import { MatterbridgeEndpointOptions, SerializedMatterbridgeEndpoint } from './matterbridgeEndpointTypes.js';
 type BehaviorCommandName<T extends Behavior.Type> = {
     [K in keyof CommandsOfBehavior<T>]: K;
@@ -101,7 +101,7 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     addUserLabel(label: string, value: string): Promise<this>;
     addCommandHandler<C extends CommandHandlers>(command: C, handler: CommandHandlerFunction<C>): this;
     removeCommandHandler<C extends CommandHandlers>(command: C, handler: CommandHandlerFunction<C>): this;
-    executeCommandHandler<C extends CommandHandlers>(command: C, request: CommandHandlerData<C>['request'], cluster: CommandHandlerData<C>['cluster'], attributes: CommandHandlerData<C>['attributes'], endpoint: CommandHandlerData<C>['endpoint']): Promise<void>;
+    executeCommandHandler<C extends CommandHandlers>(command: C, request: CommandHandlerData<C>['request'], cluster: CommandHandlerData<C>['cluster'], attributes: CommandHandlerData<C>['attributes'], endpoint: CommandHandlerData<C>['endpoint']): Promise<CommandHandlerExecutionResult<C>>;
     invokeBehaviorCommand<T extends Behavior.Type, C extends BehaviorCommandName<T>>(cluster: T, command: C, params?: BehaviorCommandParams<T, C>): Promise<void>;
     invokeBehaviorCommand<T extends ClusterType, C extends keyof ClusterType.CommandsOf<T>>(cluster: T, command: C, params?: ClusterType.CommandsOf<T>[C] extends {
         requestSchema: infer S extends import('@matter/types/tlv').TlvSchema<unknown>;
@@ -182,9 +182,8 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     }, airflowDirection?: FanControl.AirflowDirection): this;
     createDefaultHepaFilterMonitoringClusterServer(condition?: number, changeIndication?: ResourceMonitoring.ChangeIndication, inPlaceIndicator?: boolean | undefined, lastChangedTime?: number | null | undefined, replacementProductList?: ResourceMonitoring.ReplacementProduct[]): this;
     createDefaultActivatedCarbonFilterMonitoringClusterServer(condition?: number, changeIndication?: ResourceMonitoring.ChangeIndication, inPlaceIndicator?: boolean | undefined, lastChangedTime?: number | null | undefined, replacementProductList?: ResourceMonitoring.ReplacementProduct[]): this;
-    createDefaultDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType): this;
-    createPinDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType): this;
-    createUserPinDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType): this;
+    createDefaultDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType, autoRelockTime?: number): this;
+    createUserPinDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType, autoRelockTime?: number, minPinCodeLength?: number, maxPinCodeLength?: number): 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

@@ -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/matterbridgeEndpointHelpers.d.ts

@@ -32,6 +32,7 @@ export declare function generateUniqueId(deviceName: string): string;
 export declare function createUniqueId(param1: string, param2: string, param3: string, param4: string): string;
 export declare function getSemtag(semtag: Semtag, label?: string | null | undefined, mfgCode?: VendorId | null): Semtag;
 export declare function featuresFor(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string): Record<string, boolean | undefined>;
+export declare function internalFor<T extends object = Record<string, unknown>>(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string): Promise<T | undefined>;
 export declare function getBehaviourTypesFromClusterServerIds(clusterServerList: ClusterId[]): Behavior.Type[];
 export declare function getBehaviourTypesFromClusterClientIds(clusterClientList: ClusterId[]): Behavior.Type[];
 export declare function getBehaviourTypeFromClusterServerId(clusterId: ClusterId): Behavior.Type;

package/dist/matterbridgeEndpointHelpers.js

@@ -174,6 +174,14 @@ export function featuresFor(endpoint, cluster) {
     }
     return endpoint.behaviors.supported[lowercaseFirstLetter(behaviorId)]['cluster']['supportedFeatures'];
 }
+export async function internalFor(endpoint, cluster) {
+    const behaviorId = getBehavior(endpoint, cluster)?.id;
+    if (!behaviorId) {
+        endpoint.log?.error(`internalFor error: cluster not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
+        return undefined;
+    }
+    return endpoint.act((agent) => agent[behaviorId]?.internal);
+}
 export function getBehaviourTypesFromClusterServerIds(clusterServerList) {
     const behaviorTypes = [];
     clusterServerList.forEach((clusterId) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.7.2-dev-20260329-5cac980",
+  "version": "3.7.2-dev-20260331-ac050d8",
   "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-20260329-5cac980",
-    "@matterbridge/thread": "3.7.2-dev-20260329-5cac980",
-    "@matterbridge/types": "3.7.2-dev-20260329-5cac980",
-    "@matterbridge/utils": "3.7.2-dev-20260329-5cac980",
+    "@matterbridge/dgram": "3.7.2-dev-20260331-ac050d8",
+    "@matterbridge/thread": "3.7.2-dev-20260331-ac050d8",
+    "@matterbridge/types": "3.7.2-dev-20260331-ac050d8",
+    "@matterbridge/utils": "3.7.2-dev-20260331-ac050d8",
     "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 {};