@matterbridge/core 3.9.1-dev-20260614-89d7aeb → 3.9.1-dev-20260617-b1e1b99

package/README.md

@@ -6,10 +6,12 @@
 [![Docker Pulls](https://img.shields.io/docker/pulls/luligu/matterbridge?label=docker%20pulls)](https://hub.docker.com/r/luligu/matterbridge)
 ![Node.js CI](https://github.com/Luligu/matterbridge/actions/workflows/build.yml/badge.svg)
 ![CodeQL](https://github.com/Luligu/matterbridge/actions/workflows/codeql.yml/badge.svg)
-[![codecov](https://codecov.io/gh/Luligu/matterbridge/branch/main/graph/badge.svg)](https://codecov.io/gh/Luligu/matterbridge)
-[![styled with prettier](https://img.shields.io/badge/styled_with-Prettier-f8bc45.svg?logo=prettier)](https://prettier.io/)
-[![linted with eslint](https://img.shields.io/badge/linted_with-ES_Lint-4B32C3.svg?logo=eslint)](https://eslint.org/)
+[![Codecov](https://codecov.io/gh/Luligu/matterbridge/branch/main/graph/badge.svg)](https://codecov.io/gh/Luligu/matterbridge)
+[![tested with Vitest](https://img.shields.io/badge/tested_with-Vitest-6E9F18.svg?logo=vitest&logoColor=white)](https://vitest.dev)
+[![styled with Oxc](https://img.shields.io/badge/styled_with-Oxc-9BE4E0.svg?logo=oxc&logoColor=white)](https://oxc.rs/docs/guide/usage/formatter.html)
+[![linted with Oxc](https://img.shields.io/badge/linted_with-Oxc-9BE4E0.svg?logo=oxc&logoColor=white)](https://oxc.rs/docs/guide/usage/linter.html)
 [![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![TypeScript Native](https://img.shields.io/badge/TypeScript_Native-3178C6?logo=typescript&logoColor=white)](https://github.com/microsoft/typescript-go)
 [![ESM](https://img.shields.io/badge/ESM-Node.js-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
 [![matterbridge.io](https://img.shields.io/badge/matterbridge.io-online-brightgreen)](https://matterbridge.io)
 

package/dist/backend.js

@@ -3,9 +3,9 @@ import path from 'node:path';
 import { BroadcastServer } from '@matterbridge/thread';
 import { getParameter, hasParameter } from '@matterbridge/utils/cli';
 import { getErrorMessage, inspectError, logError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { AnsiLogger, rs, UNDERLINE, UNDERLINEOFF } from 'node-ansi-logger';
-if (hasParameter('loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] Backend loaded.\u001B[40;0m');
+logModuleLoaded('Backend');
 export class Backend extends EventEmitter {
     debug;
     verbose;
@@ -36,7 +36,6 @@ export class Backend extends EventEmitter {
         this.server.on('broadcast_message', this.broadcastMsgHandler.bind(this));
     }
     destroy() {
-        this.server.off('broadcast_message', this.broadcastMsgHandler.bind(this));
         this.server.close();
     }
     async broadcastMsgHandler(msg) {
@@ -61,6 +60,7 @@ export class Backend extends EventEmitter {
         this.backendWsServer = new BackendWsServer(this.matterbridge, this);
         if (!hasParameter('ssl')) {
             const http = await import('node:http');
+            await this.backendExpress.start();
             try {
                 this.log.debug(`Creating HTTP server...`);
                 this.httpServer = http.createServer(this.backendExpress.expressApp);
@@ -68,8 +68,10 @@ export class Backend extends EventEmitter {
             catch (error) {
                 logError(this.log, `Failed to create HTTP server`, error);
                 this.emit('server_error', error);
+                await this.backendExpress.stop();
                 return;
             }
+            await this.backendWsServer.start();
             this.httpServer.listen(this.port, getParameter('bind'), () => {
                 const addr = this.httpServer?.address();
                 if (addr && typeof addr !== 'string') {
@@ -110,7 +112,7 @@ export class Backend extends EventEmitter {
                         socket.destroy();
                     }
                 }
-                return;
+                return undefined;
             });
             this.httpServer.on('error', (error) => {
                 this.log.error(`Frontend http server error listening on ${this.port}`);
@@ -123,7 +125,7 @@ export class Backend extends EventEmitter {
                         break;
                 }
                 this.emit('server_error', error);
-                return;
+                return undefined;
             });
         }
         else {
@@ -191,6 +193,7 @@ export class Backend extends EventEmitter {
                 httpsServerOptions.rejectUnauthorized = true;
             }
             const https = await import('node:https');
+            await this.backendExpress.start();
             try {
                 this.log.debug(`Creating HTTPS server...`);
                 this.httpsServer = https.createServer(httpsServerOptions, this.backendExpress.expressApp);
@@ -198,8 +201,10 @@ export class Backend extends EventEmitter {
             catch (error) {
                 logError(this.log, `Failed to create HTTPS server`, error);
                 this.emit('server_error', error);
+                await this.backendExpress.stop();
                 return;
             }
+            await this.backendWsServer.start();
             this.httpsServer.listen(this.port, getParameter('bind'), () => {
                 const addr = this.httpsServer?.address();
                 if (addr && typeof addr !== 'string') {
@@ -239,7 +244,7 @@ export class Backend extends EventEmitter {
                         socket.destroy();
                     }
                 }
-                return;
+                return undefined;
             });
             this.httpsServer.on('error', (error) => {
                 this.log.error(`Frontend https server error listening on ${this.port}`);
@@ -259,6 +264,7 @@ export class Backend extends EventEmitter {
     }
     async stop() {
         this.log.debug('Stopping backend...');
+        await this.backendWsServer?.stop();
         if (this.httpServer) {
             this.log.debug('Closing http server...');
             this.httpServer.close();
@@ -279,6 +285,11 @@ export class Backend extends EventEmitter {
             this.httpsServer = undefined;
             this.log.debug('Backend https server closed successfully');
         }
+        await this.backendExpress?.stop();
+        this.backendWsServer?.destroy();
+        this.backendExpress?.destroy();
+        this.backendWsServer = undefined;
+        this.backendExpress = undefined;
         this.log.debug('Backend stopped');
     }
     getApiSettings() {

package/dist/backendExpress.d.ts

@@ -1,6 +1,6 @@
 import { type SharedMatterbridge } from '@matterbridge/types';
 import express from 'express';
-import { type Backend } from './backend.js';
+import type { Backend } from './backend.js';
 export declare class BackendExpress {
     private debug;
     private verbose;

package/dist/backendExpress.js

@@ -5,13 +5,13 @@ import { MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_BACKUP_FILE, MATTE
 import { hasParameter } from '@matterbridge/utils/cli';
 import { getErrorMessage } from '@matterbridge/utils/error';
 import { formatBytes } from '@matterbridge/utils/format';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import escapeHtml from 'escape-html';
 import express from 'express';
 import { rateLimit } from 'express-rate-limit';
 import multer from 'multer';
 import { AnsiLogger, er, nf } from 'node-ansi-logger';
-if (hasParameter('loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] BackendExpress loaded.\u001B[40;0m');
+logModuleLoaded('BackendExpress');
 export class BackendExpress {
     debug;
     verbose;
@@ -40,7 +40,6 @@ export class BackendExpress {
         this.server.on('broadcast_message', this.broadcastMsgHandler.bind(this));
     }
     destroy() {
-        this.server.off('broadcast_message', this.broadcastMsgHandler.bind(this));
         this.server.close();
     }
     async broadcastMsgHandler(msg) {
@@ -53,6 +52,7 @@ export class BackendExpress {
                     this.log.logLevel = msg.params.logLevel;
                     this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
+                default:
             }
         }
     }
@@ -76,7 +76,7 @@ export class BackendExpress {
             });
         }
         this.expressApp.use(express.static(path.join(this.matterbridge.rootDirectory, 'apps', 'frontend', 'build')));
-        this.expressApp.post('/api/login', express.json(), async (req, res) => {
+        this.expressApp.post('/api/login', express.json(), (req, res) => {
             const { password } = req.body;
             this.log.debug(`The frontend sent /api/login with password ${password ? '[redacted]' : '(empty)'}`);
             if (this.backend.storedPassword === '' || password === this.backend.storedPassword) {
@@ -131,19 +131,19 @@ export class BackendExpress {
             };
             res.status(200).json(memoryReport);
         });
-        this.expressApp.get('/api/settings', async (req, res) => {
+        this.expressApp.get('/api/settings', (req, res) => {
             this.log.debug('The frontend sent /api/settings');
             if (!this.validateReq(req, res))
                 return;
             res.json(this.backend.getApiSettings());
         });
-        this.expressApp.get('/api/plugins', async (req, res) => {
+        this.expressApp.get('/api/plugins', (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
             if (!this.validateReq(req, res))
                 return;
             res.json(this.backend.getApiPlugins());
         });
-        this.expressApp.get('/api/devices', async (req, res) => {
+        this.expressApp.get('/api/devices', (req, res) => {
             this.log.debug('The frontend sent /api/devices');
             if (!this.validateReq(req, res))
                 return;
@@ -310,7 +310,7 @@ export class BackendExpress {
                 res.status(500).send('Error reading history file.');
             }
         });
-        this.expressApp.get('/api/download-backup', this.fileLimiter, async (req, res) => {
+        this.expressApp.get('/api/download-backup', this.fileLimiter, (req, res) => {
             this.log.debug('The frontend sent /api/download-backup');
             if (!this.validateReq(req, res))
                 return;
@@ -325,7 +325,7 @@ export class BackendExpress {
                 }
             });
         });
-        this.expressApp.get('/api/download-mbstorage', this.fileLimiter, async (req, res) => {
+        this.expressApp.get('/api/download-mbstorage', this.fileLimiter, (req, res) => {
             this.log.debug('The frontend sent /api/download-mbstorage');
             if (!this.validateReq(req, res))
                 return;
@@ -340,7 +340,7 @@ export class BackendExpress {
                 }
             });
         });
-        this.expressApp.get('/api/download-mjstorage', this.fileLimiter, async (req, res) => {
+        this.expressApp.get('/api/download-mjstorage', this.fileLimiter, (req, res) => {
             this.log.debug('The frontend sent /api/download-mjstorage');
             if (!this.validateReq(req, res))
                 return;
@@ -355,7 +355,7 @@ export class BackendExpress {
                 }
             });
         });
-        this.expressApp.get('/api/download-pluginstorage', this.fileLimiter, async (req, res) => {
+        this.expressApp.get('/api/download-pluginstorage', this.fileLimiter, (req, res) => {
             this.log.debug('The frontend sent /api/download-pluginstorage');
             if (!this.validateReq(req, res))
                 return;
@@ -370,7 +370,7 @@ export class BackendExpress {
                 }
             });
         });
-        this.expressApp.get('/api/download-pluginconfig', this.fileLimiter, async (req, res) => {
+        this.expressApp.get('/api/download-pluginconfig', this.fileLimiter, (req, res) => {
             this.log.debug('The frontend sent /api/download-pluginconfig');
             if (!this.validateReq(req, res))
                 return;

package/dist/backendWsServer.d.ts

@@ -1,7 +1,7 @@
 import type { EndpointNumber } from '@matter/types/datatype';
 import type { ApiMatter, RefreshRequiredChanged, SharedMatterbridge, WsMessageBroadcast } from '@matterbridge/types';
 import { WebSocketServer } from 'ws';
-import { type Backend } from './backend.js';
+import type { Backend } from './backend.js';
 export declare class BackendWsServer {
     private debug;
     private verbose;

package/dist/backendWsServer.js

@@ -2,12 +2,12 @@ import { Logger, LogLevel as MatterLogLevel } from '@matter/general';
 import { BroadcastServer } from '@matterbridge/thread';
 import { hasParameter } from '@matterbridge/utils/cli';
 import { inspectError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { isValidNumber, isValidString } from '@matterbridge/utils/validate';
 import { fireAndForget, withTimeout } from '@matterbridge/utils/wait';
 import { AnsiLogger, CYAN, debugStringify, nf } from 'node-ansi-logger';
 import { WebSocket, WebSocketServer } from 'ws';
-if (hasParameter('loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] BackendWsServer loaded.\u001B[40;0m');
+logModuleLoaded('BackendWsServer');
 export class BackendWsServer {
     debug;
     verbose;
@@ -31,7 +31,6 @@ export class BackendWsServer {
         this.server.on('broadcast_message', this.broadcastMsgHandler.bind(this));
     }
     destroy() {
-        this.server.off('broadcast_message', this.broadcastMsgHandler.bind(this));
         this.server.close();
     }
     broadcastMsgHandler(msg) {
@@ -44,6 +43,7 @@ export class BackendWsServer {
                     this.log.logLevel = msg.params.logLevel;
                     this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
+                default:
             }
         }
     }

package/dist/behaviors/activatedCarbonFilterMonitoringServer.d.ts

@@ -1,9 +1,9 @@
 import { ActivatedCarbonFilterMonitoringServer } from '@matter/node/behaviors/activated-carbon-filter-monitoring';
-import { type ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
+import type { ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
 declare const MatterbridgeActivatedCarbonFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<typeof ActivatedCarbonFilterMonitoringServer, import("@matter/types").ClusterType.WithSupportedFeatures<ActivatedCarbonFilterMonitoring, {
+    warning: false;
     condition: true;
     replacementProductList: false;
-    warning: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "activatedCarbonFilterMonitoring">;
 export declare class MatterbridgeActivatedCarbonFilterMonitoringServer extends MatterbridgeActivatedCarbonFilterMonitoringServer_base {
     resetCondition(): Promise<void>;

package/dist/behaviors/bindingServer.d.ts

@@ -1,11 +1,11 @@
-import { type Endpoint } from '@matter/main/node';
+import type { Endpoint } from '@matter/main/node';
 import { BindingBehavior, BindingServer } from '@matter/node/behaviors/binding';
-import { type ClusterId } from '@matter/types';
-import { type Binding } from '@matter/types/clusters/binding';
+import type { ClusterId } from '@matter/types';
+import type { Binding } from '@matter/types/clusters/binding';
 export declare class MatterbridgeBindingServer extends BindingServer {
     protected internal: MatterbridgeBindingServer.Internal;
     state: MatterbridgeBindingServer.State;
-    initialize(): Promise<void>;
+    initialize(): void;
     [Symbol.asyncDispose](): Promise<void>;
     getEndpoint(clusterId: ClusterId): Endpoint | undefined;
 }

package/dist/behaviors/bindingServer.js

@@ -3,7 +3,7 @@ import { DescriptorServer } from '@matter/node/behaviors/descriptor';
 import { debugStringify, nt } from 'node-ansi-logger';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeBindingServer extends BindingServer {
-    async initialize() {
+    initialize() {
         super.initialize();
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Initializing MatterbridgeBindingServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) with clientList: ${this.state.clientList.join(', ')}`);
@@ -31,7 +31,7 @@ export class MatterbridgeBindingServer extends BindingServer {
                 return;
             await resolution.node.set({ network: { autoSubscribe: true } });
         });
-        this.reactTo(this.events.removed, async (resolution) => {
+        this.reactTo(this.events.removed, (resolution) => {
             device.log.notice(`MatterbridgeBindingServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) binding removed: kind ${resolution.kind} entry ${debugStringify(resolution.entry)}${nt}`);
             this.internal.boundEndpoints.delete(resolution.entry);
         });

package/dist/behaviors/booleanStateConfigurationServer.d.ts

@@ -1,10 +1,10 @@
 import { BooleanStateConfigurationServer } from '@matter/node/behaviors/boolean-state-configuration';
 import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
 declare const MatterbridgeBooleanStateConfigurationServer_base: import("@matter/node").ClusterBehavior.Type<typeof BooleanStateConfigurationServer, import("@matter/types").ClusterType.WithSupportedFeatures<BooleanStateConfiguration, {
-    alarmSuppress: false;
+    visual: true;
     audible: true;
+    alarmSuppress: false;
     sensitivityLevel: true;
-    visual: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "booleanStateConfiguration">;
 export declare class MatterbridgeBooleanStateConfigurationServer extends MatterbridgeBooleanStateConfigurationServer_base {
     enableDisableAlarm(request: BooleanStateConfiguration.EnableDisableAlarmRequest): Promise<void>;

package/dist/behaviors/booleanStateConfigurationServer.js

@@ -1,10 +1,11 @@
 import { BooleanStateConfigurationServer } from '@matter/node/behaviors/boolean-state-configuration';
 import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
+import { debugStringify } from 'node-ansi-logger';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.SensitivityLevel) {
     async enableDisableAlarm(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Enabling/disabling alarm ${request.alarmsToEnableDisable} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`Enabling/disabling alarm ${debugStringify(request.alarmsToEnableDisable)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('BooleanStateConfiguration.enableDisableAlarm', {
             command: 'enableDisableAlarm',
             request,

package/dist/behaviors/colorControlServer.d.ts

@@ -1,11 +1,11 @@
 import { ColorControlServer } from '@matter/node/behaviors/color-control';
 import { ColorControl } from '@matter/types/clusters/color-control';
 declare const MatterbridgeColorControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof ColorControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<ColorControl, {
-    colorLoop: false;
-    colorTemperature: true;
-    enhancedHue: true;
     hueSaturation: true;
+    enhancedHue: true;
+    colorLoop: false;
     xy: true;
+    colorTemperature: true;
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/color-control").ColorControlBaseServer.Internal, "colorControl">;
 export declare class MatterbridgeColorControlServer extends MatterbridgeColorControlServer_base {
     moveToHue(request: ColorControl.MoveToHueRequest): Promise<void>;
@@ -17,17 +17,17 @@ export declare class MatterbridgeColorControlServer extends MatterbridgeColorCon
     moveToColorTemperature(request: ColorControl.MoveToColorTemperatureRequest): Promise<void>;
 }
 declare const MatterbridgeEnhancedColorControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof MatterbridgeColorControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<ColorControl, {
-    colorLoop: false;
-    colorTemperature: true;
-    enhancedHue: true;
     hueSaturation: true;
-    xy: true;
-}>, {
+    enhancedHue: true;
     colorLoop: false;
+    xy: true;
     colorTemperature: true;
-    enhancedHue: true;
+}>, {
     hueSaturation: true;
+    enhancedHue: true;
+    colorLoop: false;
     xy: true;
+    colorTemperature: true;
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/color-control").ColorControlBaseServer.Internal, "colorControl">;
 export declare class MatterbridgeEnhancedColorControlServer extends MatterbridgeEnhancedColorControlServer_base {
 }

package/dist/behaviors/deviceEnergyManagementServer.d.ts

@@ -1,13 +1,13 @@
 import { DeviceEnergyManagementServer } from '@matter/node/behaviors/device-energy-management';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
 declare const MatterbridgeDeviceEnergyManagementServer_base: import("@matter/node").ClusterBehavior.Type<typeof DeviceEnergyManagementServer, import("@matter/types").ClusterType.WithSupportedFeatures<DeviceEnergyManagement, {
-    constraintBasedAdjustment: false;
-    forecastAdjustment: false;
-    pausable: false;
     powerAdjustment: true;
     powerForecastReporting: true;
-    startTimeAdjustment: false;
     stateForecastReporting: false;
+    startTimeAdjustment: false;
+    pausable: false;
+    forecastAdjustment: false;
+    constraintBasedAdjustment: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "deviceEnergyManagement">;
 export declare class MatterbridgeDeviceEnergyManagementServer extends MatterbridgeDeviceEnergyManagementServer_base {
     powerAdjustRequest(request: DeviceEnergyManagement.PowerAdjustRequest): Promise<void>;

package/dist/behaviors/doorLockServer.d.ts

@@ -1,36 +1,36 @@
 import { DoorLockServer } from '@matter/node/behaviors/door-lock';
 import { DoorLock } from '@matter/types/clusters/door-lock';
 declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/node").ClusterBehavior.Type<typeof DoorLockServer, import("@matter/types").ClusterType.WithSupportedFeatures<DoorLock, {
-    aliroBleuwb: false;
-    aliroProvisioning: false;
-    credentialOverTheAirAccess: false;
-    doorPositionSensor: false;
-    faceCredentials: false;
-    fingerCredentials: false;
-    holidaySchedules: false;
     pinCredential: true;
     rfidCredential: false;
-    unbolting: false;
-    user: true;
+    fingerCredentials: false;
     weekDayAccessSchedules: false;
-    yearDayAccessSchedules: false;
-}>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/door-lock").DoorLockBaseServer.Internal, "doorLock">, import("@matter/types").ClusterType.WithEnabledAttributes<import("@matter/types").ClusterType.WithEnabledEvents<import("@matter/types").ClusterType.WithSupportedFeatures<DoorLock, {
-    aliroBleuwb: false;
-    aliroProvisioning: false;
-    credentialOverTheAirAccess: false;
     doorPositionSensor: false;
     faceCredentials: false;
-    fingerCredentials: false;
+    credentialOverTheAirAccess: false;
+    user: true;
+    yearDayAccessSchedules: false;
     holidaySchedules: false;
+    unbolting: false;
+    aliroProvisioning: false;
+    aliroBleuwb: false;
+}>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/door-lock").DoorLockBaseServer.Internal, "doorLock">, import("@matter/types").ClusterType.WithEnabledAttributes<import("@matter/types").ClusterType.WithEnabledEvents<import("@matter/types").ClusterType.WithSupportedFeatures<DoorLock, {
     pinCredential: true;
     rfidCredential: false;
-    unbolting: false;
-    user: true;
+    fingerCredentials: false;
     weekDayAccessSchedules: false;
+    doorPositionSensor: false;
+    faceCredentials: false;
+    credentialOverTheAirAccess: false;
+    user: true;
     yearDayAccessSchedules: false;
+    holidaySchedules: false;
+    unbolting: false;
+    aliroProvisioning: false;
+    aliroBleuwb: false;
 }>, "doorLockAlarm" | "lockOperation" | "lockOperationError">, never>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/door-lock").DoorLockBaseServer.Internal, "doorLock">;
 export declare class MatterbridgeDoorLockServer extends MatterbridgeDoorLockServer_base {
-    initialize(): Promise<void>;
+    initialize(): void;
     lockDoor(request: DoorLock.LockDoorRequest): Promise<void>;
     unlockDoor(request: DoorLock.UnlockDoorRequest): Promise<void>;
     unlockWithTimeout(request: DoorLock.UnlockWithTimeoutRequest): Promise<void>;

package/dist/behaviors/doorLockServer.js

@@ -6,10 +6,10 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
     events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
     commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true },
 }) {
-    async initialize() {
+    initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Initializing MatterbridgeDoorLockServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await super.initialize();
+        super.initialize();
     }
     async lockDoor(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);

package/dist/behaviors/fanControlServer.d.ts

@@ -1,11 +1,11 @@
 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<typeof FanControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<FanControl, {
+    step: true;
     airflowDirection: false;
-    auto: true;
     multiSpeed: false;
+    auto: true;
     rocking: false;
-    step: true;
     wind: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "fanControl">;
 export declare class MatterbridgeFanControlServer extends MatterbridgeFanControlServer_base {

package/dist/behaviors/hepaFilterMonitoringServer.d.ts

@@ -1,9 +1,9 @@
 import { HepaFilterMonitoringServer } from '@matter/node/behaviors/hepa-filter-monitoring';
-import { type HepaFilterMonitoring } from '@matter/types/clusters/hepa-filter-monitoring';
+import type { HepaFilterMonitoring } from '@matter/types/clusters/hepa-filter-monitoring';
 declare const MatterbridgeHepaFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<typeof HepaFilterMonitoringServer, import("@matter/types").ClusterType.WithSupportedFeatures<HepaFilterMonitoring, {
+    warning: false;
     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/identifyServer.d.ts

@@ -1,5 +1,5 @@
 import { IdentifyServer } from '@matter/node/behaviors/identify';
-import { type Identify } from '@matter/types/clusters/identify';
+import type { Identify } from '@matter/types/clusters/identify';
 export declare class MatterbridgeIdentifyServer extends IdentifyServer {
     identify(request: Identify.IdentifyRequest): Promise<void>;
     triggerEffect(request: Identify.TriggerEffectRequest): Promise<void>;

package/dist/behaviors/levelControlServer.d.ts

@@ -1,5 +1,5 @@
 import { LevelControlServer } from '@matter/node/behaviors/level-control';
-import { type LevelControl } from '@matter/types/clusters/level-control';
+import type { LevelControl } from '@matter/types/clusters/level-control';
 export declare class MatterbridgeLevelControlServer extends LevelControlServer {
     moveToLevel(request: LevelControl.MoveToLevelRequest): Promise<void>;
     moveToLevelWithOnOff(request: LevelControl.MoveToLevelRequest): Promise<void>;

package/dist/behaviors/matterbridgeServer.d.ts

@@ -1,6 +1,6 @@
 import { Behavior } from '@matter/node';
-import { type AnsiLogger } from 'node-ansi-logger';
-import { type CommandHandler } from '../matterbridgeEndpointCommandHandler.js';
+import type { AnsiLogger } from 'node-ansi-logger';
+import type { CommandHandler } from '../matterbridgeEndpointCommandHandler.js';
 export declare class MatterbridgeServer extends Behavior {
     static readonly id = "matterbridge";
     state: MatterbridgeServer.State;

package/dist/behaviors/modeSelectServer.d.ts

@@ -1,5 +1,5 @@
 import { ModeSelectServer } from '@matter/node/behaviors/mode-select';
-import { type ModeSelect } from '@matter/types/clusters/mode-select';
+import type { ModeSelect } from '@matter/types/clusters/mode-select';
 export declare class MatterbridgeModeSelectServer extends ModeSelectServer {
     changeToMode(request: ModeSelect.ChangeToModeRequest): Promise<void>;
 }

package/dist/behaviors/operationalStateServer.d.ts

@@ -1,4 +1,4 @@
-import { type MaybePromise } from '@matter/general';
+import type { MaybePromise } from '@matter/general';
 import { OperationalStateServer } from '@matter/node/behaviors/operational-state';
 import { OperationalState } from '@matter/types/clusters/operational-state';
 export declare class MatterbridgeOperationalStateServer extends OperationalStateServer {

package/dist/behaviors/serviceAreaServer.d.ts

@@ -1,5 +1,5 @@
 import { ServiceAreaServer } from '@matter/node/behaviors/service-area';
-import { type ServiceArea } from '@matter/types/clusters/service-area';
+import type { ServiceArea } from '@matter/types/clusters/service-area';
 export declare class MatterbridgeServiceAreaServer extends ServiceAreaServer {
     selectAreas(request: ServiceArea.SelectAreasRequest): Promise<ServiceArea.SelectAreasResponse>;
 }

package/dist/behaviors/smokeCoAlarmServer.d.ts

@@ -1,8 +1,8 @@
 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<typeof SmokeCoAlarmServer, import("@matter/types").ClusterType.WithSupportedFeatures<SmokeCoAlarm, {
-    coAlarm: true;
     smokeAlarm: true;
+    coAlarm: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "smokeCoAlarm">;
 export declare class MatterbridgeSmokeCoAlarmServer extends MatterbridgeSmokeCoAlarmServer_base {
     selfTestRequest(): Promise<void>;

package/dist/behaviors/thermostatServer.d.ts

@@ -1,14 +1,14 @@
 import { ThermostatServer } from '@matter/node/behaviors/thermostat';
 import { Thermostat } from '@matter/types/clusters/thermostat';
 declare const MatterbridgeThermostatServer_base: import("@matter/node").ClusterBehavior.Type<typeof ThermostatServer, import("@matter/types").ClusterType.WithSupportedFeatures<Thermostat, {
-    autoMode: true;
-    cooling: true;
-    heating: true;
-    localTemperatureNotExposed: false;
-    matterScheduleConfiguration: false;
     occupancy: false;
     presets: true;
+    heating: true;
+    cooling: true;
     setback: false;
+    autoMode: true;
+    localTemperatureNotExposed: false;
+    matterScheduleConfiguration: false;
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/thermostat").ThermostatBaseServer.Internal, "thermostat">;
 export declare class MatterbridgeThermostatServer extends MatterbridgeThermostatServer_base {
     initialize(): Promise<void>;
@@ -16,14 +16,14 @@ export declare class MatterbridgeThermostatServer extends MatterbridgeThermostat
     setActivePresetRequest(request: Thermostat.SetActivePresetRequest): Promise<void>;
 }
 declare const MatterbridgePresetThermostatServer_base: import("@matter/node").ClusterBehavior.Type<typeof ThermostatServer, import("@matter/types").ClusterType.WithSupportedFeatures<Thermostat, {
-    autoMode: true;
-    cooling: true;
-    heating: true;
-    localTemperatureNotExposed: false;
-    matterScheduleConfiguration: false;
     occupancy: false;
     presets: true;
+    heating: true;
+    cooling: true;
     setback: false;
+    autoMode: true;
+    localTemperatureNotExposed: false;
+    matterScheduleConfiguration: false;
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/thermostat").ThermostatBaseServer.Internal, "thermostat">;
 export declare class MatterbridgePresetThermostatServer extends MatterbridgePresetThermostatServer_base {
 }

package/dist/behaviors/valveConfigurationAndControlServer.d.ts

@@ -1,8 +1,8 @@
 import { ValveConfigurationAndControlServer } from '@matter/node/behaviors/valve-configuration-and-control';
 import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
 declare const MatterbridgeValveConfigurationAndControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof ValveConfigurationAndControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<ValveConfigurationAndControl, {
-    level: true;
     timeSync: false;
+    level: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "valveConfigurationAndControl">;
 export declare class MatterbridgeValveConfigurationAndControlServer extends MatterbridgeValveConfigurationAndControlServer_base {
     open(request: ValveConfigurationAndControl.OpenRequest): Promise<void>;