@matterbridge/core 3.10.6-dev-20260817-a8ee796 → 3.10.6-dev-20260818-c2c6349

package/dist/behaviors/deviceEnergyManagementServer.d.ts

@@ -1,3 +1,4 @@
+import { type Timer } from '@matter/general';
 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, {
@@ -10,7 +11,18 @@ declare const MatterbridgeDeviceEnergyManagementServer_base: import("@matter/nod
     stateForecastReporting: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "deviceEnergyManagement">;
 export declare class MatterbridgeDeviceEnergyManagementServer extends MatterbridgeDeviceEnergyManagementServer_base {
+    #private;
+    protected internal: MatterbridgeDeviceEnergyManagementServer.Internal;
+    initialize(): Promise<void>;
     powerAdjustRequest(request: DeviceEnergyManagement.PowerAdjustRequest): Promise<void>;
     cancelPowerAdjustRequest(): Promise<void>;
 }
+export declare namespace MatterbridgeDeviceEnergyManagementServer {
+    class Internal {
+        powerAdjustActivationTimeMs: number | undefined;
+        powerAdjustPowerMw: number | undefined;
+        powerAdjustCompletionTimer: Timer | undefined;
+        powerAdjustCompletionCallback: (() => void) | undefined;
+    }
+}
 export {};

package/dist/behaviors/deviceEnergyManagementServer.js

@@ -1,10 +1,18 @@
+import { Seconds, Time } from '@matter/general';
 import { DeviceEnergyManagementServer } from '@matter/node/behaviors/device-energy-management';
+import { Status, StatusResponseError } from '@matter/types';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeDeviceEnergyManagementServer extends DeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment) {
+    async initialize() {
+        await super.initialize();
+        this.internal.powerAdjustCompletionCallback = this.callback(this.#completePowerAdjustmentOnTimeout, { lock: true });
+        this.reactTo(this.events.optOutState$Changed, this.#handleOptOutStateChanged);
+    }
     async powerAdjustRequest(request) {
+        const { power, duration, cause } = request;
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Adjusting power to ${request.power} duration ${request.duration} cause ${request.cause} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`Adjusting power to ${power} duration ${duration} cause ${cause} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('DeviceEnergyManagement.powerAdjustRequest', {
             command: 'powerAdjustRequest',
             request,
@@ -13,7 +21,37 @@ export class MatterbridgeDeviceEnergyManagementServer extends DeviceEnergyManage
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeDeviceEnergyManagementServer powerAdjustRequest called with power ${request.power} duration ${request.duration} cause ${request.cause}`);
+        device.log.debug(`MatterbridgeDeviceEnergyManagementServer powerAdjustRequest called with power ${power} duration ${duration} cause ${cause}`);
+        const entries = (this.state.powerAdjustmentCapability?.powerAdjustCapability ?? []);
+        if (entries.length === 0) {
+            throw new StatusResponseError('No power adjustment capability available', Status.ConstraintError);
+        }
+        const minPower = Math.min(...entries.map((entry) => entry.minPower));
+        const maxPower = Math.max(...entries.map((entry) => entry.maxPower));
+        const minDuration = Math.min(...entries.map((entry) => entry.minDuration));
+        const maxDuration = Math.max(...entries.map((entry) => entry.maxDuration));
+        if (power < minPower || power > maxPower || duration < minDuration || duration > maxDuration) {
+            throw new StatusResponseError('Power or duration out of range', Status.ConstraintError);
+        }
+        const optOutBit = cause === DeviceEnergyManagement.AdjustmentCause.LocalOptimization ? DeviceEnergyManagement.OptOutState.LocalOptOut : DeviceEnergyManagement.OptOutState.GridOptOut;
+        if ((this.state.optOutState & optOutBit) !== 0) {
+            throw new StatusResponseError('User has opted out of this adjustment cause', Status.ConstraintError);
+        }
+        const wasActive = this.state.esaState === DeviceEnergyManagement.EsaState.PowerAdjustActive;
+        const adjustReason = cause === DeviceEnergyManagement.AdjustmentCause.LocalOptimization
+            ? DeviceEnergyManagement.PowerAdjustReason.LocalOptimizationAdjustment
+            : DeviceEnergyManagement.PowerAdjustReason.GridOptimizationAdjustment;
+        this.internal.powerAdjustCompletionTimer?.stop();
+        this.internal.powerAdjustPowerMw = Number(power);
+        this.state.esaState = DeviceEnergyManagement.EsaState.PowerAdjustActive;
+        this.state.powerAdjustmentCapability = { powerAdjustCapability: entries, cause: adjustReason };
+        if (!wasActive) {
+            this.internal.powerAdjustActivationTimeMs = Time.nowMs;
+            this.events.powerAdjustStart.emit(undefined, this.context);
+        }
+        if (this.internal.powerAdjustCompletionCallback) {
+            this.internal.powerAdjustCompletionTimer = Time.getTimer('DeviceEnergyManagement power adjust completion', Seconds(duration), this.internal.powerAdjustCompletionCallback).start();
+        }
     }
     async cancelPowerAdjustRequest() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -27,5 +65,46 @@ export class MatterbridgeDeviceEnergyManagementServer extends DeviceEnergyManage
             context: this.context,
         });
         device.log.debug(`MatterbridgeDeviceEnergyManagementServer cancelPowerAdjustRequest called`);
+        if (this.state.esaState !== DeviceEnergyManagement.EsaState.PowerAdjustActive) {
+            throw new StatusResponseError('No power adjustment is currently active', Status.InvalidInState);
+        }
+        this.#endPowerAdjustment(DeviceEnergyManagement.Cause.Cancelled);
+    }
+    #handleOptOutStateChanged(optOutState) {
+        if (this.state.esaState !== DeviceEnergyManagement.EsaState.PowerAdjustActive)
+            return;
+        const activeCause = this.state.powerAdjustmentCapability?.cause;
+        const optedOutOfActiveCause = (activeCause === DeviceEnergyManagement.PowerAdjustReason.LocalOptimizationAdjustment && (optOutState & DeviceEnergyManagement.OptOutState.LocalOptOut) !== 0) ||
+            (activeCause === DeviceEnergyManagement.PowerAdjustReason.GridOptimizationAdjustment && (optOutState & DeviceEnergyManagement.OptOutState.GridOptOut) !== 0);
+        if (!optedOutOfActiveCause)
+            return;
+        this.#endPowerAdjustment(DeviceEnergyManagement.Cause.UserOptOut);
+    }
+    #completePowerAdjustmentOnTimeout() {
+        this.internal.powerAdjustCompletionTimer = undefined;
+        this.#endPowerAdjustment(DeviceEnergyManagement.Cause.NormalCompletion);
+    }
+    #endPowerAdjustment(cause) {
+        this.internal.powerAdjustCompletionTimer?.stop();
+        this.internal.powerAdjustCompletionTimer = undefined;
+        const activationTimeMs = this.internal.powerAdjustActivationTimeMs ?? Time.nowMs;
+        const elapsedSeconds = Math.max(1, Math.round((Time.nowMs - activationTimeMs) / 1000));
+        const powerMw = Math.abs(this.internal.powerAdjustPowerMw ?? 0);
+        const energyUse = Math.max(1, Math.round((powerMw * elapsedSeconds) / 3600));
+        this.internal.powerAdjustActivationTimeMs = undefined;
+        this.internal.powerAdjustPowerMw = undefined;
+        const entries = (this.state.powerAdjustmentCapability?.powerAdjustCapability ?? []);
+        this.state.esaState = DeviceEnergyManagement.EsaState.Online;
+        this.state.powerAdjustmentCapability = { powerAdjustCapability: entries, cause: DeviceEnergyManagement.PowerAdjustReason.NoAdjustment };
+        this.events.powerAdjustEnd.emit({ cause, duration: elapsedSeconds, energyUse }, this.context);
     }
 }
+(function (MatterbridgeDeviceEnergyManagementServer) {
+    class Internal {
+        powerAdjustActivationTimeMs;
+        powerAdjustPowerMw;
+        powerAdjustCompletionTimer;
+        powerAdjustCompletionCallback;
+    }
+    MatterbridgeDeviceEnergyManagementServer.Internal = Internal;
+})(MatterbridgeDeviceEnergyManagementServer || (MatterbridgeDeviceEnergyManagementServer = {}));

package/dist/chipTestDevices.d.ts

@@ -0,0 +1,2 @@
+import type { Matterbridge } from './matterbridge.js';
+export declare function createChipTestDevices(matterbridge: Matterbridge): Promise<void>;

package/dist/chipTestDevices.js

@@ -0,0 +1,187 @@
+import { CommonNumberTag } from '@matter/node';
+import { EndpointNumber } from '@matter/types/datatype';
+import { IrrigationSystem } from './devices/irrigationSystem.js';
+import { getSupportedDeviceType } from './matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { getSemtag } from './matterbridgeEndpointHelpers.js';
+export async function createChipTestDevices(matterbridge) {
+    if (!process.env.MATTERBRIDGE_CHIP_TEST || !process.env.MATTERBRIDGE_CHIP_TEST_DEVICES || matterbridge.bridgeMode !== 'bridge' || !matterbridge.aggregatorNode)
+        return;
+    const serverNode = matterbridge.serverNode;
+    const aggregator = matterbridge.aggregatorNode;
+    if (!serverNode || !aggregator) {
+        matterbridge.log.error('CHIP test devices can only be created when the server node and aggregator node are available');
+        return;
+    }
+    let ep;
+    matterbridge.plugins.set({
+        name: 'matterbridge-chip',
+        path: '',
+        type: 'DynamicPlatform',
+        version: '1.0.0',
+        description: 'Chip test plugin',
+        author: 'Matterbridge',
+        enabled: false,
+        private: false,
+        registeredDevices: 0,
+    });
+    const registerDevice = async (device, deviceName, serialNumber) => {
+        device.createDefaultBridgedDeviceBasicInformationClusterServer(deviceName, serialNumber);
+        device.addRequiredClusters();
+        device.plugin = 'matterbridge-chip';
+        await matterbridge.addBridgedEndpoint('matterbridge-chip', device);
+    };
+    const bridgedNode = getSupportedDeviceType('BridgedNode');
+    const powerSource = getSupportedDeviceType('PowerSource');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ElectricalSensor'), bridgedNode, powerSource], { id: 'ElectricalSensor', number: EndpointNumber(2_06) });
+    ep.createDefaultElectricalPowerMeasurementClusterServer(220_000, 1_000, 220_000_000, 50_000);
+    ep.createDefaultElectricalEnergyMeasurementClusterServer(100_000_000, 10_000_000);
+    await registerDevice(ep, 'Electrical Sensor', 'UTILITY-02-06');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ElectricalSensor'), bridgedNode, powerSource], { id: 'ElectricalSensorImported', number: EndpointNumber(2_06_1) });
+    ep.createDefaultElectricalPowerMeasurementClusterServer(220_000, 1_000, 220_000_000, 50_000);
+    ep.createImportedElectricalEnergyMeasurementClusterServer(200_000_000);
+    await registerDevice(ep, 'Electrical Sensor Imported', 'UTILITY-02-06-1');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ElectricalSensor'), bridgedNode, powerSource], { id: 'ElectricalSensorExported', number: EndpointNumber(2_06_2) });
+    ep.createDefaultElectricalPowerMeasurementClusterServer(220_000, 1_000, 220_000_000, 50_000);
+    ep.createExportedElectricalEnergyMeasurementClusterServer(50_000_000);
+    await registerDevice(ep, 'Electrical Sensor Exported', 'UTILITY-02-06-2');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('DeviceEnergyManagement'), bridgedNode, powerSource], { id: 'DeviceEnergyManagement', number: EndpointNumber(2_07) });
+    ep.createDefaultDeviceEnergyManagementClusterServer();
+    ep.createDefaultDeviceEnergyManagementModeClusterServer();
+    await registerDevice(ep, 'Device Energy Management', 'UTILITY-02-07');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('OnOffLight'), bridgedNode, powerSource], { id: 'OnOffLight', number: EndpointNumber(4_01) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await registerDevice(ep, 'On/Off Light', 'LIGHTING-04-01');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('DimmableLight'), bridgedNode, powerSource], { id: 'DimmableLight', number: EndpointNumber(4_02) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await registerDevice(ep, 'Dimmable Light', 'LIGHTING-04-02');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ColorTemperatureLight'), bridgedNode, powerSource], { id: 'ColorTemperatureLight', number: EndpointNumber(4_03) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    ep.createCtColorControlClusterServer();
+    await registerDevice(ep, 'Color Temperature Light', 'LIGHTING-04-03');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ExtendedColorLight'), bridgedNode, powerSource], { id: 'ExtendedColorLightXYCT', number: EndpointNumber(4_04) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    ep.createXyColorControlClusterServer();
+    await registerDevice(ep, 'Extended Color Light XY CT', 'LIGHTING-04-04');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ExtendedColorLight'), bridgedNode, powerSource], { id: 'ExtendedColorLightHSXYCT', number: EndpointNumber(4_04_1) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    ep.createDefaultColorControlClusterServer();
+    await registerDevice(ep, 'Extended Color Light HS XY CT', 'LIGHTING-04-04-01');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ExtendedColorLight'), bridgedNode, powerSource], {
+        id: 'ExtendedColorLightEnhancedEHSXYCT',
+        number: EndpointNumber(4_04_2),
+    });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    ep.createEnhancedColorControlClusterServer();
+    await registerDevice(ep, 'Extended Color Light EHS XY CT', 'LIGHTING-04-04-02');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('OnOffPlugInUnit'), bridgedNode, powerSource], { id: 'OnOffPlugInUnit', number: EndpointNumber(5_01) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await registerDevice(ep, 'On/Off Plug-in Unit', 'ACTUATOR-05-01');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('DimmablePlugInUnit'), bridgedNode, powerSource], { id: 'DimmablePlugInUnit', number: EndpointNumber(5_02) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await registerDevice(ep, 'Dimmable Plug-in Unit', 'ACTUATOR-05-02');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('MountedOnOffControl'), bridgedNode, powerSource], { id: 'MountedOnOffControl', number: EndpointNumber(5_03) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await registerDevice(ep, 'Mounted On/Off Control', 'ACTUATOR-05-03');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('MountedDimmableLoadControl'), bridgedNode, powerSource], {
+        id: 'MountedDimmableLoadControl',
+        number: EndpointNumber(5_04),
+    });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await registerDevice(ep, 'Mounted Dimmable Load Control', 'ACTUATOR-05-04');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Pump'), bridgedNode, powerSource], { id: 'Pump', number: EndpointNumber(5_05) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    ep.createOnOffClusterServer();
+    await registerDevice(ep, 'Pump', 'ACTUATOR-05-05');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('WaterValve'), bridgedNode, powerSource], { id: 'WaterValve', number: EndpointNumber(5_06) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await registerDevice(ep, 'Water Valve', 'ACTUATOR-05-06');
+    ep = new IrrigationSystem('Irrigation System with 2 zones', 'ACTUATOR-05-07', { id: 'IrrigationSystem', number: EndpointNumber(5_07) });
+    ep.addZone(getSemtag(CommonNumberTag.One), 'IrrigationSystemZone1', EndpointNumber(5_07_1));
+    ep.addZone(getSemtag(CommonNumberTag.Two), 'IrrigationSystemZone2', EndpointNumber(5_07_2));
+    await registerDevice(ep, 'Irrigation System with 2 zones', 'ACTUATOR-05-07');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('OnOffLightSwitch'), bridgedNode, powerSource], { id: 'OnOffLightSwitch', number: EndpointNumber(6_01) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await registerDevice(ep, 'On/Off Light Switch', 'SWITCH-06-01');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('DimmerSwitch'), bridgedNode, powerSource], { id: 'DimmerSwitch', number: EndpointNumber(6_02) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await registerDevice(ep, 'Dimmer Switch', 'SWITCH-06-02');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ColorDimmerSwitch'), bridgedNode, powerSource], { id: 'ColorDimmerSwitch', number: EndpointNumber(6_03) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await registerDevice(ep, 'Color Dimmer Switch', 'SWITCH-06-03');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ControlBridge'), bridgedNode, powerSource], { id: 'ControlBridge', number: EndpointNumber(6_04) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await registerDevice(ep, 'Control Bridge', 'SWITCH-06-04');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('PumpController'), bridgedNode, powerSource], { id: 'PumpController', number: EndpointNumber(6_05) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await registerDevice(ep, 'Pump Controller', 'SWITCH-06-05');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('GenericSwitch'), bridgedNode, powerSource], { id: 'GenericSwitch', number: EndpointNumber(6_06) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    await registerDevice(ep, 'Generic Switch', 'SWITCH-06-06');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ContactSensor'), bridgedNode, powerSource], { id: 'ContactSensor', number: EndpointNumber(7_01) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createDefaultBooleanStateClusterServer();
+    ep.createDefaultBooleanStateConfigurationClusterServer();
+    await registerDevice(ep, 'Contact Sensor', 'SENSOR-07-01');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('LightSensor'), bridgedNode, powerSource], { id: 'LightSensor', number: EndpointNumber(7_02) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createDefaultIlluminanceMeasurementClusterServer(1000, 1, 65534);
+    await registerDevice(ep, 'Light Sensor', 'SENSOR-07-02');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('OccupancySensor'), bridgedNode, powerSource], { id: 'OccupancySensor', number: EndpointNumber(7_03) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    await registerDevice(ep, 'Occupancy Sensor', 'SENSOR-07-03');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('TemperatureSensor'), bridgedNode, powerSource], { id: 'TemperatureSensor', number: EndpointNumber(7_04) });
+    ep.createDefaultPowerSourceReplaceableBatteryClusterServer();
+    ep.createDefaultTemperatureMeasurementClusterServer(2000, -27315, 32767);
+    await registerDevice(ep, 'Temperature Sensor', 'SENSOR-07-04');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('PressureSensor'), bridgedNode, powerSource], { id: 'PressureSensor', number: EndpointNumber(7_05) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createDefaultPressureMeasurementClusterServer(1013, 0, 2000);
+    await registerDevice(ep, 'Pressure Sensor', 'SENSOR-07-05');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('FlowSensor'), bridgedNode, powerSource], { id: 'FlowSensor', number: EndpointNumber(7_06) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    ep.createDefaultFlowMeasurementClusterServer(100, 0, 1000);
+    await registerDevice(ep, 'Flow Sensor', 'SENSOR-07-06');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('HumiditySensor'), bridgedNode, powerSource], { id: 'HumiditySensor', number: EndpointNumber(7_07) });
+    ep.createDefaultPowerSourceRechargeableBatteryClusterServer();
+    ep.createDefaultRelativeHumidityMeasurementClusterServer(5000, 0, 10000);
+    await registerDevice(ep, 'Humidity Sensor', 'SENSOR-07-07');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('OnOffSensor'), bridgedNode, powerSource], { id: 'OnOffSensor', number: EndpointNumber(7_08) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    await registerDevice(ep, 'On/Off Sensor', 'SENSOR-07-08');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('SmokeCOAlarm'), bridgedNode, powerSource], { id: 'SmokeCOAlarm', number: EndpointNumber(7_09) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    await registerDevice(ep, 'Smoke/CO Alarm', 'SENSOR-07-09');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('SmokeCOAlarm'), bridgedNode, powerSource], { id: 'SmokeAlarm', number: EndpointNumber(7_09_1) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createSmokeOnlySmokeCOAlarmClusterServer();
+    await registerDevice(ep, 'Smoke Alarm', 'SENSOR-07-09-1');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('SmokeCOAlarm'), bridgedNode, powerSource], { id: 'COAlarm', number: EndpointNumber(7_09_2) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createCoOnlySmokeCOAlarmClusterServer();
+    await registerDevice(ep, 'CO Alarm', 'SENSOR-07-09-2');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('AirQualitySensor'), bridgedNode, powerSource], { id: 'AirQualitySensor', number: EndpointNumber(7_10) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createDefaultTvocMeasurementClusterServer(50, undefined, undefined, undefined, 0, 1000);
+    ep.addOptionalClusterServers();
+    await registerDevice(ep, 'Air Quality Sensor', 'SENSOR-07-10');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('WaterFreezeDetector'), bridgedNode, powerSource], { id: 'WaterFreezeDetector', number: EndpointNumber(7_11) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createDefaultBooleanStateClusterServer(false);
+    ep.createDefaultBooleanStateConfigurationClusterServer();
+    await registerDevice(ep, 'Water Freeze Detector', 'SENSOR-07-11');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('WaterLeakDetector'), bridgedNode, powerSource], { id: 'WaterLeakDetector', number: EndpointNumber(7_12) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createDefaultBooleanStateClusterServer(false);
+    ep.createDefaultBooleanStateConfigurationClusterServer();
+    await registerDevice(ep, 'Water Leak Detector', 'SENSOR-07-12');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('RainSensor'), bridgedNode, powerSource], { id: 'RainSensor', number: EndpointNumber(7_13) });
+    ep.createDefaultPowerSourceRechargeableBatteryClusterServer();
+    ep.createDefaultBooleanStateClusterServer(false);
+    ep.createDefaultBooleanStateConfigurationClusterServer();
+    await registerDevice(ep, 'Rain Sensor', 'SENSOR-07-13');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('SoilSensor'), bridgedNode, powerSource], { id: 'SoilSensor', number: EndpointNumber(7_14) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    ep.createDefaultSoilMeasurementClusterServer(50);
+    await registerDevice(ep, 'Soil Sensor', 'SENSOR-07-14');
+}

package/dist/{chipTest.d.ts → chipTests.d.ts}

@@ -5,6 +5,6 @@ export declare const chipTestEnableKey: Uint8Array<ArrayBuffer>;
 export declare class MatterbridgeGeneralDiagnosticsServer extends GeneralDiagnosticsServer {
     initialize(): void;
     testEventTrigger({ eventTrigger, enableKey }: GeneralDiagnostics.TestEventTriggerRequest): Promise<void>;
+    payloadTestRequest(request: GeneralDiagnostics.PayloadTestRequest): ReturnType<GeneralDiagnosticsServer['payloadTestRequest']>;
 }
-export declare function createChipTestDevices(matterbridge: Matterbridge): Promise<void>;
 export declare function createChipTestAppPipe(matterbridge: Matterbridge): void;