@matterbridge/core 3.7.10 → 3.8.0-dev-20260524-92c5fdd

package/dist/behaviors/doorLockServer.js

@@ -1,11 +1,6 @@
 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.with(DoorLock.Feature.User, DoorLock.Feature.PinCredential).enable({
     events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
@@ -49,20 +44,8 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called ${this.state.autoRelockTime ? 'with ' + this.state.autoRelockTime + ' seconds' : 'without'} autoRelockTime ${this.internal.enableTimeout ? 'with' : 'without'} enableTimeout`);
+        device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called ${this.state.autoRelockTime ? 'with ' + this.state.autoRelockTime + ' seconds' : 'without'} autoRelockTime`);
         await super.unlockDoor(request);
-        if (!this.internal.enableTimeout)
-            return;
-        if (this.state.autoRelockTime) {
-            clearTimeout(this.internal.unlockTimeout);
-            this.internal.unlockTimeout = setTimeout(async () => {
-                this.internal.unlockTimeout = undefined;
-                const device = this.endpoint.stateOf(MatterbridgeServer);
-                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.with()).lockDoor({ pinCode: request.pinCode }));
-            }, this.state.autoRelockTime * 1000).unref();
-        }
     }
     async unlockWithTimeout(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -79,25 +62,12 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeDoorLockServer: unlockWithTimeout called ${this.internal.enableTimeout ? 'with' : 'without'} enableTimeout`);
-        this.state.lockState = DoorLock.LockState.Unlocked;
-        if (!this.internal.enableTimeout)
-            return;
-        if (request.timeout) {
-            clearTimeout(this.internal.unlockTimeout);
-            this.internal.unlockTimeout = setTimeout(async () => {
-                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.with()).lockDoor({ pinCode: request.pinCode }));
-            }, request.timeout * 1000).unref();
-        }
+        device.log.debug(`MatterbridgeDoorLockServer: unlockWithTimeout called`);
+        await super.unlockWithTimeout(request);
     }
     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,
@@ -106,49 +76,8 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             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)}`);
-        }
+        device.log.debug(`MatterbridgeDoorLockServer: setUser called for userIndex ${request.userIndex}`);
+        await super.setUser(request);
     }
     async getUser(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -165,32 +94,10 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             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),
-        };
+        return await super.getUser(request);
     }
     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',
@@ -201,27 +108,10 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             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);
+        await super.clearUser(request);
     }
     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',
@@ -231,45 +121,8 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             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,
-        };
+        device.log.debug(`MatterbridgeDoorLockServer: setCredential called for userIndex ${request.userIndex}`);
+        return await super.setCredential(request);
     }
     async getCredentialStatus(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -283,23 +136,10 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             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;
+        return await super.getCredentialStatus(request);
     }
     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',
@@ -310,134 +150,6 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             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;
+        await super.clearCredential(request);
     }
 }
-(function (MatterbridgeDoorLockServer) {
-    class Internal {
-        enableTimeout = true;
-        unlockTimeout;
-        users = [];
-    }
-    MatterbridgeDoorLockServer.Internal = Internal;
-})(MatterbridgeDoorLockServer || (MatterbridgeDoorLockServer = {}));

package/dist/behaviors/fanControlServer.d.ts

@@ -1,6 +1,13 @@
 import { FanControlServer } from '@matter/node/behaviors/fan-control';
 import { FanControl } from '@matter/types/clusters/fan-control';
-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>;
+declare const MatterbridgeFanControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof FanControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<FanControl, {
+    step: true;
+    airflowDirection: false;
+    multiSpeed: false;
+    auto: true;
+    rocking: false;
+    wind: false;
+}>, import("@matter/types").ClusterType.Concrete, new () => {}, "fanControl">;
 export declare class MatterbridgeFanControlServer extends MatterbridgeFanControlServer_base {
     step(request: FanControl.StepRequest): Promise<void>;
 }

package/dist/behaviors/hepaFilterMonitoringServer.d.ts

@@ -1,7 +1,10 @@
 import { HepaFilterMonitoringServer } from '@matter/node/behaviors/hepa-filter-monitoring';
 import { HepaFilterMonitoring } from '@matter/types/clusters/hepa-filter-monitoring';
-import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
-declare const MatterbridgeHepaFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<HepaFilterMonitoring.Cluster, readonly [ResourceMonitoring.Feature.Condition]>, typeof HepaFilterMonitoringServer, import("@matter/node/behaviors").ResourceMonitoringInterface>;
+declare const MatterbridgeHepaFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<typeof HepaFilterMonitoringServer, import("@matter/types").ClusterType.WithSupportedFeatures<HepaFilterMonitoring, {
+    condition: true;
+    replacementProductList: false;
+    warning: false;
+}>, import("@matter/types").ClusterType.Concrete, new () => {}, "hepaFilterMonitoring">;
 export declare class MatterbridgeHepaFilterMonitoringServer extends MatterbridgeHepaFilterMonitoringServer_base {
     resetCondition(): Promise<void>;
 }

package/dist/behaviors/smokeCoAlarmServer.d.ts

@@ -1,82 +1,9 @@
 import { SmokeCoAlarmServer } from '@matter/node/behaviors/smoke-co-alarm';
 import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
-declare const MatterbridgeSmokeCoAlarmServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
-    readonly id: 92;
-    readonly name: "SmokeCoAlarm";
-    readonly revision: 1;
-    readonly features: {
-        readonly smokeAlarm: import("@matter/types").BitFlag;
-        readonly coAlarm: import("@matter/types").BitFlag;
-    };
-    readonly attributes: {
-        readonly expressedState: import("@matter/types").Attribute<SmokeCoAlarm.ExpressedState, any>;
-        readonly batteryAlert: import("@matter/types").Attribute<SmokeCoAlarm.AlarmState, any>;
-        readonly deviceMuted: import("@matter/types").OptionalAttribute<SmokeCoAlarm.MuteState, any>;
-        readonly testInProgress: import("@matter/types").Attribute<boolean, any>;
-        readonly hardwareFaultAlert: import("@matter/types").Attribute<boolean, any>;
-        readonly endOfServiceAlert: import("@matter/types").Attribute<SmokeCoAlarm.EndOfService, any>;
-        readonly interconnectSmokeAlarm: import("@matter/types").OptionalAttribute<SmokeCoAlarm.AlarmState, any>;
-        readonly interconnectCoAlarm: import("@matter/types").OptionalAttribute<SmokeCoAlarm.AlarmState, any>;
-        readonly expiryDate: import("@matter/types").OptionalFixedAttribute<number, any>;
-    };
-    readonly commands: {
-        readonly selfTestRequest: import("@matter/types").OptionalCommand<void, void, any>;
-    };
-    readonly events: {
-        readonly lowBattery: import("@matter/types").Event<import("@matter/types").TypeFromFields<{
-            alarmSeverityLevel: import("@matter/types").FieldType<SmokeCoAlarm.AlarmState>;
-        }>, any>;
-        readonly hardwareFault: import("@matter/types").Event<void, any>;
-        readonly endOfService: import("@matter/types").Event<void, any>;
-        readonly selfTestComplete: import("@matter/types").Event<void, any>;
-        readonly alarmMuted: import("@matter/types").OptionalEvent<void, any>;
-        readonly muteEnded: import("@matter/types").OptionalEvent<void, any>;
-        readonly allClear: import("@matter/types").Event<void, any>;
-    };
-    readonly extensions: readonly [{
-        readonly flags: {
-            readonly smokeAlarm: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly smokeState: import("@matter/types").Attribute<SmokeCoAlarm.AlarmState, any>;
-                readonly contaminationState: import("@matter/types").OptionalAttribute<SmokeCoAlarm.ContaminationState, any>;
-                readonly smokeSensitivityLevel: import("@matter/types").OptionalWritableAttribute<SmokeCoAlarm.Sensitivity, any>;
-            };
-            readonly events: {
-                readonly smokeAlarm: import("@matter/types").Event<import("@matter/types").TypeFromFields<{
-                    alarmSeverityLevel: import("@matter/types").FieldType<SmokeCoAlarm.AlarmState>;
-                }>, any>;
-                readonly interconnectSmokeAlarm: import("@matter/types").OptionalEvent<import("@matter/types").TypeFromFields<{
-                    alarmSeverityLevel: import("@matter/types").FieldType<SmokeCoAlarm.AlarmState>;
-                }>, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly coAlarm: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly coState: import("@matter/types").Attribute<SmokeCoAlarm.AlarmState, any>;
-            };
-            readonly events: {
-                readonly coAlarm: import("@matter/types").Event<import("@matter/types").TypeFromFields<{
-                    alarmSeverityLevel: import("@matter/types").FieldType<SmokeCoAlarm.AlarmState>;
-                }>, any>;
-                readonly interconnectCoAlarm: import("@matter/types").OptionalEvent<import("@matter/types").TypeFromFields<{
-                    alarmSeverityLevel: import("@matter/types").FieldType<SmokeCoAlarm.AlarmState>;
-                }>, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly smokeAlarm: false;
-            readonly coAlarm: false;
-        };
-        readonly component: false;
-    }];
-}>, readonly [SmokeCoAlarm.Feature.SmokeAlarm, SmokeCoAlarm.Feature.CoAlarm]>, typeof SmokeCoAlarmServer, import("@matter/node/behaviors/smoke-co-alarm").SmokeCoAlarmInterface>;
+declare const MatterbridgeSmokeCoAlarmServer_base: import("@matter/node").ClusterBehavior.Type<typeof SmokeCoAlarmServer, import("@matter/types").ClusterType.WithSupportedFeatures<SmokeCoAlarm, {
+    smokeAlarm: true;
+    coAlarm: true;
+}>, import("@matter/types").ClusterType.Concrete, new () => {}, "smokeCoAlarm">;
 export declare class MatterbridgeSmokeCoAlarmServer extends MatterbridgeSmokeCoAlarmServer_base {
     selfTestRequest(): Promise<void>;
 }