@matterbridge/core 3.10.7-dev-20260823-6142c00 → 3.10.7-dev-20260825-7ebac36

package/dist/behaviors/export.d.ts

@@ -15,6 +15,7 @@ export * from './onOffServer.js';
 export * from './occupancySensingServer.js';
 export * from './operationalStateServer.js';
 export * from './powerSourceServer.js';
+export * from './pumpConfigurationAndControlServer.js';
 export * from './serviceAreaServer.js';
 export * from './smokeCoAlarmServer.js';
 export * from './switchServer.js';

package/dist/behaviors/export.js

@@ -15,6 +15,7 @@ export * from './onOffServer.js';
 export * from './occupancySensingServer.js';
 export * from './operationalStateServer.js';
 export * from './powerSourceServer.js';
+export * from './pumpConfigurationAndControlServer.js';
 export * from './serviceAreaServer.js';
 export * from './smokeCoAlarmServer.js';
 export * from './switchServer.js';

package/dist/behaviors/pumpConfigurationAndControlServer.d.ts

@@ -0,0 +1,23 @@
+import type { MaybePromise } from '@matter/general';
+import { PumpConfigurationAndControlServer } from '@matter/node/behaviors/pump-configuration-and-control';
+import { PumpConfigurationAndControl } from '@matter/types/clusters/pump-configuration-and-control';
+declare const MatterbridgePumpConfigurationAndControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof PumpConfigurationAndControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<PumpConfigurationAndControl, {
+    automatic: false;
+    compensatedPressure: false;
+    constantFlow: false;
+    constantPressure: false;
+    constantSpeed: true;
+    constantTemperature: false;
+    localOperation: false;
+}>, import("@matter/types").ClusterType.Concrete, new () => {}, "pumpConfigurationAndControl">;
+export declare class MatterbridgePumpConfigurationAndControlServer extends MatterbridgePumpConfigurationAndControlServer_base {
+    #private;
+    protected internal: MatterbridgePumpConfigurationAndControlServer.Internal;
+    initialize(): MaybePromise;
+}
+export declare namespace MatterbridgePumpConfigurationAndControlServer {
+    class Internal {
+        lastLevel?: number;
+    }
+}
+export {};

package/dist/behaviors/pumpConfigurationAndControlServer.js

@@ -0,0 +1,100 @@
+import { LevelControlServer } from '@matter/node/behaviors/level-control';
+import { OnOffServer } from '@matter/node/behaviors/on-off';
+import { PumpConfigurationAndControlServer } from '@matter/node/behaviors/pump-configuration-and-control';
+import { Status, StatusResponseError } from '@matter/types';
+import { PumpConfigurationAndControl } from '@matter/types/clusters/pump-configuration-and-control';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgePumpConfigurationAndControlServer extends PumpConfigurationAndControlServer.with(PumpConfigurationAndControl.Feature.ConstantSpeed) {
+    initialize() {
+        this.state.minConstSpeed ??= 600;
+        this.state.maxConstSpeed ??= 3000;
+        this.state.maxPressure ??= 6000;
+        this.state.maxSpeed ??= 3000;
+        this.state.maxFlow ??= 100;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgePumpConfigurationAndControlServer: initialized with minConstSpeed=${this.state.minConstSpeed}, maxConstSpeed=${this.state.maxConstSpeed}, maxPressure=${this.state.maxPressure}, maxSpeed=${this.state.maxSpeed}, maxFlow=${this.state.maxFlow} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (this.endpoint.behaviors.has(OnOffServer.id)) {
+            this.reactTo(this.agent.get(OnOffServer).events.onOff$Changed, this.#handleOnOffChanged);
+        }
+        if (this.endpoint.behaviors.has(LevelControlServer.id)) {
+            const levelControlState = this.agent.get(LevelControlServer).state;
+            this.internal.lastLevel = levelControlState.currentLevel ?? levelControlState.maxLevel;
+            this.reactTo(this.agent.get(LevelControlServer).events.currentLevel$Changed, this.#handleCurrentLevelChanged);
+        }
+        this.reactTo(this.events.operationMode$Changing, this.#handleOperationModeChanging);
+        this.reactTo(this.events.operationMode$Changed, this.#handleOperationModeChanged);
+    }
+    #percentFromLevel(currentLevel) {
+        if (currentLevel <= 0)
+            return 0;
+        return currentLevel <= 200 ? currentLevel / 2 : 100;
+    }
+    #speedFromPercent(percent) {
+        const maxConstSpeed = this.state.maxConstSpeed ?? this.state.maxSpeed ?? 0;
+        return Math.round((percent / 100) * maxConstSpeed);
+    }
+    #capacityFromPercent(percent) {
+        return Math.round(percent * 200);
+    }
+    #currentSetpoint(normalLevel) {
+        const maxConstSpeed = this.state.maxConstSpeed ?? this.state.maxSpeed ?? 0;
+        if (this.state.operationMode === PumpConfigurationAndControl.OperationMode.Minimum) {
+            const speed = this.state.minConstSpeed ?? 0;
+            return { speed, percent: maxConstSpeed > 0 ? (speed / maxConstSpeed) * 100 : 0 };
+        }
+        if (this.state.operationMode === PumpConfigurationAndControl.OperationMode.Maximum) {
+            return { speed: maxConstSpeed, percent: 100 };
+        }
+        const percent = this.#percentFromLevel(normalLevel);
+        return { speed: this.#speedFromPercent(percent), percent };
+    }
+    #applySetpoint(normalLevel) {
+        const { speed, percent } = this.#currentSetpoint(normalLevel);
+        const capacity = this.#capacityFromPercent(percent);
+        this.agent.asLocalActor(() => {
+            this.state.speed = speed;
+            this.state.capacity = capacity;
+        });
+        return { speed, capacity };
+    }
+    #stopPump() {
+        this.agent.asLocalActor(() => {
+            this.state.speed = 0;
+            this.state.capacity = 0;
+        });
+        return { speed: 0, capacity: 0 };
+    }
+    #handleOperationModeChanging() {
+        if (this.state.pumpStatus?.localOverride) {
+            throw new StatusResponseError('OperationMode cannot be changed while PumpStatus.LocalOverride is set', Status.Failure);
+        }
+    }
+    #handleOperationModeChanged(operationMode, oldOperationMode) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgePumpConfigurationAndControlServer: operationMode changed to ${operationMode} from ${oldOperationMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.agent.asLocalActor(() => {
+            this.state.effectiveOperationMode = operationMode;
+        });
+        const { speed, capacity } = this.#applySetpoint(this.internal.lastLevel ?? 254);
+        device.log.info(`MatterbridgePumpConfigurationAndControlServer: pump speed changed to ${speed}, capacity changed to ${capacity} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+    }
+    #handleOnOffChanged(onOff, oldOnOff) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgePumpConfigurationAndControlServer: onOff changed to ${onOff} from ${oldOnOff} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        const { speed, capacity } = onOff ? this.#applySetpoint(this.internal.lastLevel ?? 254) : this.#stopPump();
+        device.log.info(`MatterbridgePumpConfigurationAndControlServer: pump speed changed to ${speed}, capacity changed to ${capacity} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+    }
+    #handleCurrentLevelChanged(currentLevel, oldCurrentLevel) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgePumpConfigurationAndControlServer: currentLevel changed to ${currentLevel} from ${oldCurrentLevel} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.internal.lastLevel = currentLevel ?? this.internal.lastLevel;
+        const { speed, capacity } = this.#applySetpoint(currentLevel ?? 0);
+        device.log.info(`MatterbridgePumpConfigurationAndControlServer: pump speed changed to ${speed}, capacity changed to ${capacity} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+    }
+}
+(function (MatterbridgePumpConfigurationAndControlServer) {
+    class Internal {
+        lastLevel;
+    }
+    MatterbridgePumpConfigurationAndControlServer.Internal = Internal;
+})(MatterbridgePumpConfigurationAndControlServer || (MatterbridgePumpConfigurationAndControlServer = {}));

package/dist/demoDevices.js

@@ -1,14 +1,24 @@
-import { ClosureTag, ClosureWindowTag, CommonNumberTag } from '@matter/node';
+import { ClosureTag, ClosureWindowTag, CommonNumberTag, CommonPositionTag, RefrigeratorTag } from '@matter/node';
 import { AirQuality } from '@matter/types/clusters/air-quality';
 import { FanControl } from '@matter/types/clusters/fan-control';
 import { PowerSource } from '@matter/types/clusters/power-source';
 import { EndpointNumber } from '@matter/types/datatype';
+import { AirConditioner } from './devices/airConditioner.js';
 import { BasicVideoPlayer } from './devices/basicVideoPlayer.js';
 import { CastingVideoClient } from './devices/castingVideoClient.js';
 import { CastingVideoPlayer } from './devices/castingVideoPlayer.js';
 import { Closure } from './devices/closure.js';
 import { ContentApp } from './devices/contentApp.js';
+import { Cooktop } from './devices/cooktop.js';
+import { Dishwasher } from './devices/dishwasher.js';
+import { ExtractorHood } from './devices/extractorHood.js';
 import { IrrigationSystem } from './devices/irrigationSystem.js';
+import { LaundryDryer } from './devices/laundryDryer.js';
+import { LaundryWasher } from './devices/laundryWasher.js';
+import { MicrowaveOven } from './devices/microwaveOven.js';
+import { Oven } from './devices/oven.js';
+import { Refrigerator } from './devices/refrigerator.js';
+import { RoboticVacuumCleaner } from './devices/roboticVacuumCleaner.js';
 import { Speaker } from './devices/speaker.js';
 import { VideoRemoteControl } from './devices/videoRemoteControl.js';
 import { getSupportedDeviceType } from './matterbridgeDeviceTypes.js';
@@ -101,7 +111,8 @@ export async function createDemoDevices(matterbridge) {
     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();
+    ep.createOnOffClusterServer(false);
+    ep.createLevelControlClusterServer(0);
     await registerDevice(ep, 'Pump', 'ACTUATOR-05-05');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('WaterValve'), bridgedNode, powerSource], { id: 'WaterValve', number: EndpointNumber(5_06) });
     ep.createDefaultPowerSourceWiredClusterServer();
@@ -338,4 +349,124 @@ export async function createDemoDevices(matterbridge) {
         tagList: [getSemtag(CommonNumberTag.Four)],
     }).addRequiredClusters();
     await registerDevice(ep, 'Aggregator', 'GENERIC-11-02');
+    ep = new RoboticVacuumCleaner('Robotic Vacuum Cleaner', 'ROBOTIC-12-01', {
+        id: 'RoboticVacuumCleaner',
+        number: EndpointNumber(12_01),
+        tagList: [getSemtag(CommonNumberTag.One)],
+    });
+    await registerDevice(ep, 'Robotic Vacuum Cleaner', 'ROBOTIC-12-01');
+    ep = new LaundryWasher('Laundry Washer', 'APPLIANCE-13-01', {
+        id: 'LaundryWasher',
+        number: EndpointNumber(13_01),
+        tagList: [getSemtag(CommonNumberTag.One)],
+    });
+    await registerDevice(ep, 'Laundry Washer', 'APPLIANCE-13-01');
+    const refrigeratorDevice = new Refrigerator('Refrigerator', 'APPLIANCE-13-02', {
+        id: 'Refrigerator',
+        number: EndpointNumber(13_02),
+        tagList: [getSemtag(CommonNumberTag.One)],
+    });
+    refrigeratorDevice
+        .addCabinet('Refrigerator Cabinet Top', {
+        id: 'RefrigeratorCabinetTop',
+        number: EndpointNumber(13_02_1),
+        tagList: [getSemtag(CommonPositionTag.Top), getSemtag(RefrigeratorTag.Refrigerator)],
+    })
+        .addRequiredClusters();
+    refrigeratorDevice
+        .addCabinet('Freezer Cabinet Bottom', {
+        id: 'FreezerCabinetBottom',
+        number: EndpointNumber(13_02_2),
+        tagList: [getSemtag(CommonPositionTag.Bottom), getSemtag(RefrigeratorTag.Freezer)],
+        targetTemperature: -20 * 100,
+        minTemperature: -30 * 100,
+        maxTemperature: 10 * 100,
+        step: 10 * 100,
+    })
+        .addRequiredClusters();
+    await registerDevice(refrigeratorDevice, 'Refrigerator', 'APPLIANCE-13-02');
+    ep = new AirConditioner('Air Conditioner', 'APPLIANCE-13-03', {
+        id: 'AirConditioner',
+        number: EndpointNumber(13_03),
+        tagList: [getSemtag(CommonNumberTag.One)],
+    });
+    await registerDevice(ep, 'Air Conditioner', 'APPLIANCE-13-03');
+    ep = new Dishwasher('Dishwasher', 'APPLIANCE-13-05', {
+        id: 'Dishwasher',
+        number: EndpointNumber(13_05),
+        tagList: [getSemtag(CommonNumberTag.One)],
+    });
+    await registerDevice(ep, 'Dishwasher', 'APPLIANCE-13-05');
+    ep = new LaundryDryer('Laundry Dryer', 'APPLIANCE-13-06', {
+        id: 'LaundryDryer',
+        number: EndpointNumber(13_06),
+        tagList: [getSemtag(CommonNumberTag.One)],
+    });
+    await registerDevice(ep, 'Laundry Dryer', 'APPLIANCE-13-06');
+    const cooktopDevice = new Cooktop('Cooktop', 'APPLIANCE-13-08', {
+        id: 'Cooktop',
+        number: EndpointNumber(13_08),
+        tagList: [getSemtag(CommonNumberTag.One)],
+    });
+    cooktopDevice
+        .addSurface('Cook Surface Top Left', {
+        id: 'CookSurfaceTopLeft',
+        number: EndpointNumber(13_08_1),
+        tagList: [getSemtag(CommonPositionTag.Top), getSemtag(CommonPositionTag.Left)],
+    })
+        .addRequiredClusters();
+    cooktopDevice
+        .addSurface('Cook Surface Top Right', {
+        id: 'CookSurfaceTopRight',
+        number: EndpointNumber(13_08_2),
+        tagList: [getSemtag(CommonPositionTag.Top), getSemtag(CommonPositionTag.Right)],
+    })
+        .addRequiredClusters();
+    cooktopDevice
+        .addSurface('Cook Surface Bottom Left', {
+        id: 'CookSurfaceBottomLeft',
+        number: EndpointNumber(13_08_3),
+        tagList: [getSemtag(CommonPositionTag.Bottom), getSemtag(CommonPositionTag.Left)],
+    })
+        .addRequiredClusters();
+    cooktopDevice
+        .addSurface('Cook Surface Bottom Right', {
+        id: 'CookSurfaceBottomRight',
+        number: EndpointNumber(13_08_4),
+        tagList: [getSemtag(CommonPositionTag.Bottom), getSemtag(CommonPositionTag.Right)],
+    })
+        .addRequiredClusters();
+    await registerDevice(cooktopDevice, 'Cooktop', 'APPLIANCE-13-08');
+    const ovenDevice = new Oven('Oven', 'APPLIANCE-13-09', {
+        id: 'Oven',
+        number: EndpointNumber(13_09),
+        tagList: [getSemtag(CommonNumberTag.One)],
+    });
+    ovenDevice
+        .addCabinet('Oven Cabinet Top', {
+        id: 'OvenCabinetTop',
+        number: EndpointNumber(13_09_1),
+        tagList: [getSemtag(CommonPositionTag.Top)],
+    })
+        .addRequiredClusters();
+    ovenDevice
+        .addCabinet('Oven Cabinet Bottom', {
+        id: 'OvenCabinetBottom',
+        number: EndpointNumber(13_09_2),
+        tagList: [getSemtag(CommonPositionTag.Bottom)],
+    })
+        .addRequiredClusters();
+    await registerDevice(ovenDevice, 'Oven', 'APPLIANCE-13-09');
+    ep = new ExtractorHood('Extractor Hood', 'APPLIANCE-13-10', {
+        id: 'ExtractorHood',
+        number: EndpointNumber(13_10),
+        tagList: [getSemtag(CommonNumberTag.One)],
+    });
+    await registerDevice(ep, 'Extractor Hood', 'APPLIANCE-13-10');
+    ep = new MicrowaveOven('Microwave Oven', 'APPLIANCE-13-11', {
+        id: 'MicrowaveOven',
+        number: EndpointNumber(13_11),
+        tagList: [getSemtag(CommonNumberTag.One)],
+    });
+    await registerDevice(ep, 'Microwave Oven', 'APPLIANCE-13-11');
 }

package/dist/devices/airConditioner.d.ts

@@ -1,7 +1,13 @@
+import type { EndpointNumber } from '@matter/types';
 import { FanControl } from '@matter/types/clusters/fan-control';
 import { ThermostatUserInterfaceConfiguration } from '@matter/types/clusters/thermostat-user-interface-configuration';
+import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export interface AirConditionerOptions {
+    mode?: 'server' | 'matter';
+    id?: string;
+    number?: EndpointNumber;
+    tagList?: Semtag[];
     localTemperature?: number;
     occupiedHeatingSetpoint?: number;
     occupiedCoolingSetpoint?: number;

package/dist/devices/airConditioner.js

@@ -5,7 +5,12 @@ import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class AirConditioner extends MatterbridgeEndpoint {
     constructor(name, serial, options = {}) {
         const { localTemperature = 23, occupiedHeatingSetpoint = 21, occupiedCoolingSetpoint = 25, minSetpointDeadBand = 1, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 49, minCoolSetpointLimit = 1, maxCoolSetpointLimit = 50, temperatureDisplayMode = ThermostatUserInterfaceConfiguration.TemperatureDisplayMode.Celsius, keypadLockout = ThermostatUserInterfaceConfiguration.KeypadLockout.NoLockout, scheduleProgrammingVisibility = ThermostatUserInterfaceConfiguration.ScheduleProgrammingVisibility.ScheduleProgrammingPermitted, fanMode = FanControl.FanMode.Off, fanModeSequence = FanControl.FanModeSequence.OffLowMedHighAuto, percentSetting = 0, percentCurrent = 0, } = options;
-        super([roomAirConditioner, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        super([roomAirConditioner, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+            tagList: options.tagList,
+            mode: options.mode,
+        });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Air Conditioner');
         this.createDefaultPowerSourceWiredClusterServer();

package/dist/devices/cooktop.d.ts

@@ -1,6 +1,20 @@
-import type { Semtag } from '@matter/types';
+import type { EndpointNumber, Semtag } from '@matter/types';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface CooktopOptions {
+    mode?: 'server' | 'matter';
+    id?: string;
+    number?: EndpointNumber;
+    tagList?: Semtag[];
+}
+export interface CookSurfaceOptions {
+    id?: string;
+    number?: EndpointNumber;
+    tagList: Semtag[];
+    selectedTemperatureLevel?: number;
+    supportedTemperatureLevels?: string[];
+}
 export declare class Cooktop extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string);
+    constructor(name: string, serial: string, options?: CooktopOptions);
+    addSurface(name: string, options: CookSurfaceOptions): MatterbridgeEndpoint;
     addSurface(name: string, tagList: Semtag[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[]): MatterbridgeEndpoint;
 }

package/dist/devices/cooktop.js

@@ -3,18 +3,24 @@ import { cookSurface, cooktop, powerSource } from '../matterbridgeDeviceTypes.js
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { createLevelTemperatureControlClusterServer } from './temperatureControl.js';
 export class Cooktop extends MatterbridgeEndpoint {
-    constructor(name, serial) {
-        super([cooktop, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+    constructor(name, serial, options = {}) {
+        super([cooktop, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+            tagList: options.tagList,
+            mode: options.mode,
+        });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Cooktop');
         this.createDefaultPowerSourceWiredClusterServer();
         this.createOffOnlyOnOffClusterServer(true);
         fireAndForget(this.addFixedLabel('composed', 'Cooktop'), this.log, 'Error adding composed label to cooktop');
     }
-    addSurface(name, tagList, selectedTemperatureLevel = 2, supportedTemperatureLevels = ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5']) {
-        const surface = this.addChildDeviceType(name, cookSurface, { tagList });
+    addSurface(name, optionsOrTagList, selectedTemperatureLevel, supportedTemperatureLevels) {
+        const options = Array.isArray(optionsOrTagList) ? { tagList: optionsOrTagList, selectedTemperatureLevel, supportedTemperatureLevels } : optionsOrTagList;
+        const surface = this.addChildDeviceType(options.id ?? name, cookSurface, { number: options.number, tagList: options.tagList });
         surface.log.logName = name;
-        createLevelTemperatureControlClusterServer(surface, selectedTemperatureLevel, supportedTemperatureLevels);
+        createLevelTemperatureControlClusterServer(surface, options.selectedTemperatureLevel ?? 2, options.supportedTemperatureLevels ?? ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5']);
         surface.createDefaultTemperatureMeasurementClusterServer(2000);
         surface.createOffOnlyOnOffClusterServer(true);
         return surface;

package/dist/devices/dishwasher.d.ts

@@ -1,9 +1,27 @@
 import { DishwasherModeServer } from '@matter/node/behaviors/dishwasher-mode';
+import type { EndpointNumber } from '@matter/types';
 import { DishwasherMode } from '@matter/types/clusters/dishwasher-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
 import type { OperationalState } from '@matter/types/clusters/operational-state';
+import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface DishwasherOptions {
+    mode?: 'server' | 'matter';
+    id?: string;
+    number?: EndpointNumber;
+    tagList?: Semtag[];
+    currentMode?: number;
+    supportedModes?: DishwasherMode.ModeOption[];
+    selectedTemperatureLevel?: number;
+    supportedTemperatureLevels?: string[];
+    temperatureSetpoint?: number;
+    minTemperature?: number;
+    maxTemperature?: number;
+    step?: number;
+    operationalState?: OperationalState.OperationalStateEnum;
+}
 export declare class Dishwasher extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: DishwasherOptions);
     constructor(name: string, serial: string, currentMode?: number, supportedModes?: DishwasherMode.ModeOption[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number, operationalState?: OperationalState.OperationalStateEnum);
     createDefaultDishwasherModeClusterServer(currentMode?: number, supportedModes?: DishwasherMode.ModeOption[]): this;
     createDefaultDishwasherAlarmClusterServer(): this;

package/dist/devices/dishwasher.js

@@ -9,19 +9,37 @@ import { dishwasher, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { createLevelTemperatureControlClusterServer, createNumberTemperatureControlClusterServer } from './temperatureControl.js';
 export class Dishwasher extends MatterbridgeEndpoint {
-    constructor(name, serial, currentMode, supportedModes, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
-        super([dishwasher, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+    constructor(name, serial, optionsOrCurrentMode, supportedModes, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
+        const options = typeof optionsOrCurrentMode === 'object'
+            ? optionsOrCurrentMode
+            : {
+                currentMode: optionsOrCurrentMode,
+                supportedModes,
+                selectedTemperatureLevel,
+                supportedTemperatureLevels,
+                temperatureSetpoint,
+                minTemperature,
+                maxTemperature,
+                step,
+                operationalState,
+            };
+        super([dishwasher, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+            tagList: options.tagList,
+            mode: options.mode,
+        });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Dishwasher');
         this.createDefaultPowerSourceWiredClusterServer();
         this.createDeadFrontOnOffClusterServer(true);
-        this.createDefaultDishwasherModeClusterServer(currentMode, supportedModes);
+        this.createDefaultDishwasherModeClusterServer(options.currentMode, options.supportedModes);
         this.createDefaultDishwasherAlarmClusterServer();
-        if (temperatureSetpoint)
-            createNumberTemperatureControlClusterServer(this, temperatureSetpoint, minTemperature, maxTemperature, step);
+        if (options.temperatureSetpoint)
+            createNumberTemperatureControlClusterServer(this, options.temperatureSetpoint, options.minTemperature, options.maxTemperature, options.step);
         else
-            createLevelTemperatureControlClusterServer(this, selectedTemperatureLevel, supportedTemperatureLevels);
-        this.createDefaultOperationalStateClusterServer(operationalState);
+            createLevelTemperatureControlClusterServer(this, options.selectedTemperatureLevel, options.supportedTemperatureLevels);
+        this.createDefaultOperationalStateClusterServer(options.operationalState);
     }
     createDefaultDishwasherModeClusterServer(currentMode = 2, supportedModes = [
         { label: 'Light', mode: 1, modeTags: [{ value: DishwasherMode.ModeTag.Light }] },

package/dist/devices/extractorHood.d.ts

@@ -1,5 +1,24 @@
+import type { EndpointNumber } from '@matter/types';
 import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
+import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface ExtractorHoodOptions {
+    mode?: 'server' | 'matter';
+    id?: string;
+    number?: EndpointNumber;
+    tagList?: Semtag[];
+    hepaCondition?: number;
+    hepaChangeIndication?: ResourceMonitoring.ChangeIndication;
+    hepaInPlaceIndicator?: boolean;
+    hepaLastChangedTime?: number | null;
+    hepaReplacementProductList?: ResourceMonitoring.ReplacementProduct[];
+    activatedCarbonCondition?: number;
+    activatedCarbonChangeIndication?: ResourceMonitoring.ChangeIndication;
+    activatedCarbonInPlaceIndicator?: boolean;
+    activatedCarbonLastChangedTime?: number | null;
+    activatedCarbonReplacementProductList?: ResourceMonitoring.ReplacementProduct[];
+}
 export declare class ExtractorHood extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string, hepaCondition?: number, hepaChangeIndication?: ResourceMonitoring.ChangeIndication, hepaInPlaceIndicator?: boolean | undefined, hepaLastChangedTime?: number | null | undefined, hepaReplacementProductList?: ResourceMonitoring.ReplacementProduct[], activatedCarbonCondition?: number, activatedCarbonChangeIndication?: ResourceMonitoring.ChangeIndication, activatedCarbonInPlaceIndicator?: boolean | undefined, activatedCarbonLastChangedTime?: number | null | undefined, activatedCarbonReplacementProductList?: ResourceMonitoring.ReplacementProduct[]);
+    constructor(name: string, serial: string, options?: ExtractorHoodOptions);
+    constructor(name: string, serial: string, hepaCondition?: number, hepaChangeIndication?: ResourceMonitoring.ChangeIndication, hepaInPlaceIndicator?: boolean, hepaLastChangedTime?: number | null, hepaReplacementProductList?: ResourceMonitoring.ReplacementProduct[], activatedCarbonCondition?: number, activatedCarbonChangeIndication?: ResourceMonitoring.ChangeIndication, activatedCarbonInPlaceIndicator?: boolean, activatedCarbonLastChangedTime?: number | null, activatedCarbonReplacementProductList?: ResourceMonitoring.ReplacementProduct[]);
 }

package/dist/devices/extractorHood.js

@@ -3,14 +3,33 @@ import { fireAndForget } from '@matterbridge/utils/wait';
 import { extractorHood, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class ExtractorHood extends MatterbridgeEndpoint {
-    constructor(name, serial, hepaCondition = 100, hepaChangeIndication = ResourceMonitoring.ChangeIndication.Ok, hepaInPlaceIndicator = true, hepaLastChangedTime = null, hepaReplacementProductList = [], activatedCarbonCondition = 100, activatedCarbonChangeIndication = ResourceMonitoring.ChangeIndication.Ok, activatedCarbonInPlaceIndicator = true, activatedCarbonLastChangedTime = null, activatedCarbonReplacementProductList = []) {
-        super([extractorHood, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+    constructor(name, serial, optionsOrHepaCondition, hepaChangeIndication, hepaInPlaceIndicator, hepaLastChangedTime, hepaReplacementProductList, activatedCarbonCondition, activatedCarbonChangeIndication, activatedCarbonInPlaceIndicator, activatedCarbonLastChangedTime, activatedCarbonReplacementProductList) {
+        const options = typeof optionsOrHepaCondition === 'object'
+            ? optionsOrHepaCondition
+            : {
+                hepaCondition: optionsOrHepaCondition,
+                hepaChangeIndication,
+                hepaInPlaceIndicator,
+                hepaLastChangedTime,
+                hepaReplacementProductList,
+                activatedCarbonCondition,
+                activatedCarbonChangeIndication,
+                activatedCarbonInPlaceIndicator,
+                activatedCarbonLastChangedTime,
+                activatedCarbonReplacementProductList,
+            };
+        super([extractorHood, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+            tagList: options.tagList,
+            mode: options.mode,
+        });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Extractor Hood');
         this.createDefaultPowerSourceWiredClusterServer();
         this.createBaseFanControlClusterServer();
-        this.createDefaultHepaFilterMonitoringClusterServer(hepaCondition, hepaChangeIndication, hepaInPlaceIndicator, hepaLastChangedTime, hepaReplacementProductList);
-        this.createDefaultActivatedCarbonFilterMonitoringClusterServer(activatedCarbonCondition, activatedCarbonChangeIndication, activatedCarbonInPlaceIndicator, activatedCarbonLastChangedTime, activatedCarbonReplacementProductList);
+        this.createDefaultHepaFilterMonitoringClusterServer(options.hepaCondition ?? 100, options.hepaChangeIndication ?? ResourceMonitoring.ChangeIndication.Ok, options.hepaInPlaceIndicator ?? true, options.hepaLastChangedTime ?? null, options.hepaReplacementProductList ?? []);
+        this.createDefaultActivatedCarbonFilterMonitoringClusterServer(options.activatedCarbonCondition ?? 100, options.activatedCarbonChangeIndication ?? ResourceMonitoring.ChangeIndication.Ok, options.activatedCarbonInPlaceIndicator ?? true, options.activatedCarbonLastChangedTime ?? null, options.activatedCarbonReplacementProductList ?? []);
         this.subscribeAttribute('fanControl', 'fanMode', (newValue, oldValue, context) => {
             if (context.fabric === undefined)
                 return;

package/dist/devices/laundryDryer.d.ts

@@ -1,8 +1,26 @@
+import type { EndpointNumber } from '@matter/types';
 import { LaundryDryerControls } from '@matter/types/clusters/laundry-dryer-controls';
 import { LaundryWasherMode } from '@matter/types/clusters/laundry-washer-mode';
 import type { OperationalState } from '@matter/types/clusters/operational-state';
+import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface LaundryDryerOptions {
+    mode?: 'server' | 'matter';
+    id?: string;
+    number?: EndpointNumber;
+    tagList?: Semtag[];
+    currentMode?: number;
+    supportedModes?: LaundryWasherMode.ModeOption[];
+    selectedTemperatureLevel?: number;
+    supportedTemperatureLevels?: string[];
+    temperatureSetpoint?: number;
+    minTemperature?: number;
+    maxTemperature?: number;
+    step?: number;
+    operationalState?: OperationalState.OperationalStateEnum;
+}
 export declare class LaundryDryer extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: LaundryDryerOptions);
     constructor(name: string, serial: string, currentMode?: number, supportedModes?: LaundryWasherMode.ModeOption[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number, operationalState?: OperationalState.OperationalStateEnum);
     createDefaultLaundryWasherModeClusterServer(currentMode?: number, supportedModes?: LaundryWasherMode.ModeOption[]): this;
     createDefaultLaundryDryerControlsClusterServer(selectedDrynessLevel?: LaundryDryerControls.DrynessLevel, supportedDrynessLevels?: LaundryDryerControls.DrynessLevel[]): this;

package/dist/devices/laundryDryer.js

@@ -6,19 +6,37 @@ import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { MatterbridgeLaundryWasherModeServer } from './laundryWasher.js';
 import { createLevelTemperatureControlClusterServer, createNumberTemperatureControlClusterServer } from './temperatureControl.js';
 export class LaundryDryer extends MatterbridgeEndpoint {
-    constructor(name, serial, currentMode, supportedModes, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
-        super([laundryDryer, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+    constructor(name, serial, optionsOrCurrentMode, supportedModes, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
+        const options = typeof optionsOrCurrentMode === 'object'
+            ? optionsOrCurrentMode
+            : {
+                currentMode: optionsOrCurrentMode,
+                supportedModes,
+                selectedTemperatureLevel,
+                supportedTemperatureLevels,
+                temperatureSetpoint,
+                minTemperature,
+                maxTemperature,
+                step,
+                operationalState,
+            };
+        super([laundryDryer, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+            tagList: options.tagList,
+            mode: options.mode,
+        });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Laundry Dryer');
         this.createDefaultPowerSourceWiredClusterServer();
         this.createDeadFrontOnOffClusterServer(true);
-        this.createDefaultLaundryWasherModeClusterServer(currentMode, supportedModes);
+        this.createDefaultLaundryWasherModeClusterServer(options.currentMode, options.supportedModes);
         this.createDefaultLaundryDryerControlsClusterServer(1);
-        if (temperatureSetpoint)
-            createNumberTemperatureControlClusterServer(this, temperatureSetpoint, minTemperature, maxTemperature, step);
+        if (options.temperatureSetpoint)
+            createNumberTemperatureControlClusterServer(this, options.temperatureSetpoint, options.minTemperature, options.maxTemperature, options.step);
         else
-            createLevelTemperatureControlClusterServer(this, selectedTemperatureLevel, supportedTemperatureLevels);
-        this.createDefaultOperationalStateClusterServer(operationalState);
+            createLevelTemperatureControlClusterServer(this, options.selectedTemperatureLevel, options.supportedTemperatureLevels);
+        this.createDefaultOperationalStateClusterServer(options.operationalState);
     }
     createDefaultLaundryWasherModeClusterServer(currentMode = 2, supportedModes = [
         { label: 'Delicate', mode: 1, modeTags: [{ value: LaundryWasherMode.ModeTag.Delicate }] },

package/dist/devices/laundryWasher.d.ts

@@ -1,10 +1,32 @@
 import { LaundryWasherModeServer } from '@matter/node/behaviors/laundry-washer-mode';
+import type { EndpointNumber } from '@matter/types';
 import { LaundryWasherControls } from '@matter/types/clusters/laundry-washer-controls';
 import { LaundryWasherMode } from '@matter/types/clusters/laundry-washer-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
 import type { OperationalState } from '@matter/types/clusters/operational-state';
+import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface LaundryWasherOptions {
+    mode?: 'server' | 'matter';
+    id?: string;
+    number?: EndpointNumber;
+    tagList?: Semtag[];
+    currentMode?: number;
+    supportedModes?: LaundryWasherMode.ModeOption[];
+    spinSpeedCurrent?: number;
+    spinSpeeds?: string[];
+    numberOfRinses?: LaundryWasherControls.NumberOfRinses;
+    supportedRinses?: LaundryWasherControls.NumberOfRinses[];
+    selectedTemperatureLevel?: number;
+    supportedTemperatureLevels?: string[];
+    temperatureSetpoint?: number;
+    minTemperature?: number;
+    maxTemperature?: number;
+    step?: number;
+    operationalState?: OperationalState.OperationalStateEnum;
+}
 export declare class LaundryWasher extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: LaundryWasherOptions);
     constructor(name: string, serial: string, currentMode?: number, supportedModes?: LaundryWasherMode.ModeOption[], spinSpeedCurrent?: number, spinSpeeds?: string[], numberOfRinses?: LaundryWasherControls.NumberOfRinses, supportedRinses?: LaundryWasherControls.NumberOfRinses[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number, operationalState?: OperationalState.OperationalStateEnum);
     createDefaultLaundryWasherModeClusterServer(currentMode?: number, supportedModes?: LaundryWasherMode.ModeOption[]): this;
     createDefaultLaundryWasherControlsClusterServer(spinSpeedCurrent?: number, spinSpeeds?: string[], numberOfRinses?: LaundryWasherControls.NumberOfRinses, supportedRinses?: LaundryWasherControls.NumberOfRinses[]): this;

package/dist/devices/laundryWasher.js

@@ -10,19 +10,41 @@ import { laundryWasher, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { createLevelTemperatureControlClusterServer, createNumberTemperatureControlClusterServer } from './temperatureControl.js';
 export class LaundryWasher extends MatterbridgeEndpoint {
-    constructor(name, serial, currentMode, supportedModes, spinSpeedCurrent, spinSpeeds, numberOfRinses, supportedRinses, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
-        super([laundryWasher, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+    constructor(name, serial, optionsOrCurrentMode, supportedModes, spinSpeedCurrent, spinSpeeds, numberOfRinses, supportedRinses, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
+        const options = typeof optionsOrCurrentMode === 'object'
+            ? optionsOrCurrentMode
+            : {
+                currentMode: optionsOrCurrentMode,
+                supportedModes,
+                spinSpeedCurrent,
+                spinSpeeds,
+                numberOfRinses,
+                supportedRinses,
+                selectedTemperatureLevel,
+                supportedTemperatureLevels,
+                temperatureSetpoint,
+                minTemperature,
+                maxTemperature,
+                step,
+                operationalState,
+            };
+        super([laundryWasher, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+            tagList: options.tagList,
+            mode: options.mode,
+        });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Laundry Washer');
         this.createDefaultPowerSourceWiredClusterServer();
         this.createDeadFrontOnOffClusterServer(true);
-        this.createDefaultLaundryWasherModeClusterServer(currentMode, supportedModes);
-        this.createDefaultLaundryWasherControlsClusterServer(spinSpeedCurrent, spinSpeeds, numberOfRinses, supportedRinses);
-        if (temperatureSetpoint)
-            createNumberTemperatureControlClusterServer(this, temperatureSetpoint, minTemperature, maxTemperature, step);
+        this.createDefaultLaundryWasherModeClusterServer(options.currentMode, options.supportedModes);
+        this.createDefaultLaundryWasherControlsClusterServer(options.spinSpeedCurrent, options.spinSpeeds, options.numberOfRinses, options.supportedRinses);
+        if (options.temperatureSetpoint)
+            createNumberTemperatureControlClusterServer(this, options.temperatureSetpoint, options.minTemperature, options.maxTemperature, options.step);
         else
-            createLevelTemperatureControlClusterServer(this, selectedTemperatureLevel, supportedTemperatureLevels);
-        this.createDefaultOperationalStateClusterServer(operationalState);
+            createLevelTemperatureControlClusterServer(this, options.selectedTemperatureLevel, options.supportedTemperatureLevels);
+        this.createDefaultOperationalStateClusterServer(options.operationalState);
     }
     createDefaultLaundryWasherModeClusterServer(currentMode = 2, supportedModes = [
         { label: 'Delicate', mode: 1, modeTags: [{ value: LaundryWasherMode.ModeTag.Delicate }] },

package/dist/devices/microwaveOven.d.ts

@@ -1,8 +1,25 @@
 import { MicrowaveOvenControlServer } from '@matter/node/behaviors/microwave-oven-control';
+import type { EndpointNumber } from '@matter/types';
 import { MicrowaveOvenControl } from '@matter/types/clusters/microwave-oven-control';
 import { MicrowaveOvenMode } from '@matter/types/clusters/microwave-oven-mode';
+import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface MicrowaveOvenOptions {
+    mode?: 'server' | 'matter';
+    id?: string;
+    number?: EndpointNumber;
+    tagList?: Semtag[];
+    currentMode?: number;
+    supportedModes?: MicrowaveOvenMode.ModeOption[];
+    powerSetting?: number;
+    minPower?: number;
+    maxPower?: number;
+    powerStep?: number;
+    cookTime?: number;
+    maxCookTime?: number;
+}
 export declare class MicrowaveOven extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: MicrowaveOvenOptions);
     constructor(name: string, serial: string, currentMode?: number, supportedModes?: MicrowaveOvenMode.ModeOption[], powerSetting?: number, minPower?: number, maxPower?: number, powerStep?: number, cookTime?: number, maxCookTime?: number);
     createDefaultMicrowaveOvenModeClusterServer(currentMode: number, supportedModes: MicrowaveOvenMode.ModeOption[]): this;
     createDefaultMicrowaveOvenControlClusterServer(powerSetting: number, minPower: number, maxPower: number, powerStep: number, cookTime: number, maxCookTime: number): this;

package/dist/devices/microwaveOven.js

@@ -8,22 +8,31 @@ import { MatterbridgeOperationalStateServer } from '../behaviors/operationalStat
 import { microwaveOven, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class MicrowaveOven extends MatterbridgeEndpoint {
-    constructor(name, serial, currentMode = 1, supportedModes = [
-        { label: 'Auto', mode: 1, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Auto }] },
-        { label: 'Quick', mode: 2, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Quick }] },
-        { label: 'Quiet', mode: 3, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Quiet }] },
-        { label: 'Min', mode: 4, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Min }] },
-        { label: 'Max', mode: 5, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Max }] },
-        { label: 'Normal', mode: 6, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Normal }] },
-        { label: 'Defrost', mode: 7, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Defrost }] },
-    ], powerSetting = 100, minPower = 10, maxPower = 100, powerStep = 10, cookTime = 60, maxCookTime = 3600) {
-        super([microwaveOven, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+    constructor(name, serial, optionsOrCurrentMode, supportedModes, powerSetting, minPower, maxPower, powerStep, cookTime, maxCookTime) {
+        const options = typeof optionsOrCurrentMode === 'object'
+            ? optionsOrCurrentMode
+            : { currentMode: optionsOrCurrentMode, supportedModes, powerSetting, minPower, maxPower, powerStep, cookTime, maxCookTime };
+        const configuredSupportedModes = options.supportedModes ?? [
+            { label: 'Auto', mode: 1, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Auto }] },
+            { label: 'Quick', mode: 2, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Quick }] },
+            { label: 'Quiet', mode: 3, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Quiet }] },
+            { label: 'Min', mode: 4, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Min }] },
+            { label: 'Max', mode: 5, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Max }] },
+            { label: 'Normal', mode: 6, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Normal }] },
+            { label: 'Defrost', mode: 7, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Defrost }] },
+        ];
+        super([microwaveOven, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+            tagList: options.tagList,
+            mode: options.mode,
+        });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Microwave Oven');
         this.createDefaultPowerSourceWiredClusterServer();
         this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
-        this.createDefaultMicrowaveOvenModeClusterServer(currentMode, supportedModes);
-        this.createDefaultMicrowaveOvenControlClusterServer(powerSetting, minPower, maxPower, powerStep, cookTime, maxCookTime);
+        this.createDefaultMicrowaveOvenModeClusterServer(options.currentMode ?? 1, configuredSupportedModes);
+        this.createDefaultMicrowaveOvenControlClusterServer(options.powerSetting ?? 100, options.minPower ?? 10, options.maxPower ?? 100, options.powerStep ?? 10, options.cookTime ?? 60, options.maxCookTime ?? 3600);
     }
     createDefaultMicrowaveOvenModeClusterServer(currentMode, supportedModes) {
         this.behaviors.require(MicrowaveOvenModeServer, {

package/dist/devices/oven.d.ts

@@ -1,13 +1,35 @@
 import type { MaybePromise } from '@matter/general';
 import { OvenCavityOperationalStateServer } from '@matter/node/behaviors/oven-cavity-operational-state';
 import { OvenModeServer } from '@matter/node/behaviors/oven-mode';
-import type { Semtag } from '@matter/types';
+import type { EndpointNumber, Semtag } from '@matter/types';
 import { ModeBase } from '@matter/types/clusters/mode-base';
 import { OperationalState } from '@matter/types/clusters/operational-state';
 import { OvenMode } from '@matter/types/clusters/oven-mode';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface OvenOptions {
+    mode?: 'server' | 'matter';
+    id?: string;
+    number?: EndpointNumber;
+    tagList?: Semtag[];
+}
+export interface OvenCabinetOptions {
+    id?: string;
+    number?: EndpointNumber;
+    tagList: Semtag[];
+    currentMode?: number;
+    supportedModes?: OvenMode.ModeOption[];
+    targetTemperature?: number;
+    minTemperature?: number;
+    maxTemperature?: number;
+    step?: number;
+    currentTemperature?: number;
+    operationalState?: OperationalState.OperationalStateEnum;
+    currentPhase?: number;
+    phaseList?: string[];
+}
 export declare class Oven extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string);
+    constructor(name: string, serial: string, options?: OvenOptions);
+    addCabinet(name: string, options: OvenCabinetOptions): MatterbridgeEndpoint;
     addCabinet(name: string, tagList: Semtag[], currentMode?: number, supportedModes?: OvenMode.ModeOption[], targetTemperature?: number, minTemperature?: number, maxTemperature?: number, step?: number, currentTemperature?: number, operationalState?: OperationalState.OperationalStateEnum, currentPhase?: number, phaseList?: string[]): MatterbridgeEndpoint;
     createDefaultOvenModeClusterServer(endpoint: MatterbridgeEndpoint, currentMode: number, supportedModes: OvenMode.ModeOption[]): MatterbridgeEndpoint;
     createDefaultOvenCavityOperationalStateClusterServer(endpoint: MatterbridgeEndpoint, operationalState?: OperationalState.OperationalStateEnum, currentPhase?: number, phaseList?: string[]): MatterbridgeEndpoint;

package/dist/devices/oven.js

@@ -9,31 +9,52 @@ import { oven, powerSource, temperatureControlledCabinetHeater } from '../matter
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { createNumberTemperatureControlClusterServer } from './temperatureControl.js';
 export class Oven extends MatterbridgeEndpoint {
-    constructor(name, serial) {
-        super([oven, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+    constructor(name, serial, options = {}) {
+        super([oven, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+            tagList: options.tagList,
+            mode: options.mode,
+        });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Oven');
         this.createDefaultPowerSourceWiredClusterServer();
         fireAndForget(this.addFixedLabel('composed', 'Oven'), this.log, 'Oven addFixedLabel');
     }
-    addCabinet(name, tagList, currentMode = 2, supportedModes = [
-        { label: 'Bake', mode: 1, modeTags: [{ value: OvenMode.ModeTag.Bake }] },
-        { label: 'Convection', mode: 2, modeTags: [{ value: OvenMode.ModeTag.Convection }] },
-        { label: 'Grill', mode: 3, modeTags: [{ value: OvenMode.ModeTag.Grill }] },
-        { label: 'Roast', mode: 4, modeTags: [{ value: OvenMode.ModeTag.Roast }] },
-        { label: 'Clean', mode: 5, modeTags: [{ value: OvenMode.ModeTag.Clean }] },
-        { label: 'Convection Bake', mode: 6, modeTags: [{ value: OvenMode.ModeTag.ConvectionBake }] },
-        { label: 'Convection Roast', mode: 7, modeTags: [{ value: OvenMode.ModeTag.ConvectionRoast }] },
-        { label: 'Warming', mode: 8, modeTags: [{ value: OvenMode.ModeTag.Warming }] },
-        { label: 'Proofing', mode: 9, modeTags: [{ value: OvenMode.ModeTag.Proofing }] },
-        { label: 'Steam', mode: 10, modeTags: [{ value: OvenMode.ModeTag.Steam }] },
-    ], targetTemperature = 180 * 100, minTemperature = 30 * 100, maxTemperature = 300 * 100, step = 10 * 100, currentTemperature = 20 * 100, operationalState = OperationalState.OperationalStateEnum.Stopped, currentPhase, phaseList) {
-        const cabinet = this.addChildDeviceType(name, temperatureControlledCabinetHeater, { tagList });
+    addCabinet(name, optionsOrTagList, currentMode, supportedModes, targetTemperature, minTemperature, maxTemperature, step, currentTemperature, operationalState, currentPhase, phaseList) {
+        const options = Array.isArray(optionsOrTagList)
+            ? {
+                tagList: optionsOrTagList,
+                currentMode,
+                supportedModes,
+                targetTemperature,
+                minTemperature,
+                maxTemperature,
+                step,
+                currentTemperature,
+                operationalState,
+                currentPhase,
+                phaseList,
+            }
+            : optionsOrTagList;
+        const configuredSupportedModes = options.supportedModes ?? [
+            { label: 'Bake', mode: 1, modeTags: [{ value: OvenMode.ModeTag.Bake }] },
+            { label: 'Convection', mode: 2, modeTags: [{ value: OvenMode.ModeTag.Convection }] },
+            { label: 'Grill', mode: 3, modeTags: [{ value: OvenMode.ModeTag.Grill }] },
+            { label: 'Roast', mode: 4, modeTags: [{ value: OvenMode.ModeTag.Roast }] },
+            { label: 'Clean', mode: 5, modeTags: [{ value: OvenMode.ModeTag.Clean }] },
+            { label: 'Convection Bake', mode: 6, modeTags: [{ value: OvenMode.ModeTag.ConvectionBake }] },
+            { label: 'Convection Roast', mode: 7, modeTags: [{ value: OvenMode.ModeTag.ConvectionRoast }] },
+            { label: 'Warming', mode: 8, modeTags: [{ value: OvenMode.ModeTag.Warming }] },
+            { label: 'Proofing', mode: 9, modeTags: [{ value: OvenMode.ModeTag.Proofing }] },
+            { label: 'Steam', mode: 10, modeTags: [{ value: OvenMode.ModeTag.Steam }] },
+        ];
+        const cabinet = this.addChildDeviceType(options.id ?? name, temperatureControlledCabinetHeater, { number: options.number, tagList: options.tagList });
         cabinet.log.logName = name;
-        createNumberTemperatureControlClusterServer(cabinet, targetTemperature, minTemperature, maxTemperature, step);
-        cabinet.createDefaultTemperatureMeasurementClusterServer(currentTemperature);
-        this.createDefaultOvenModeClusterServer(cabinet, currentMode, supportedModes);
-        this.createDefaultOvenCavityOperationalStateClusterServer(cabinet, operationalState, currentPhase, phaseList);
+        createNumberTemperatureControlClusterServer(cabinet, options.targetTemperature ?? 180 * 100, options.minTemperature ?? 30 * 100, options.maxTemperature ?? 300 * 100, options.step ?? 10 * 100);
+        cabinet.createDefaultTemperatureMeasurementClusterServer(options.currentTemperature ?? 20 * 100);
+        this.createDefaultOvenModeClusterServer(cabinet, options.currentMode ?? 2, configuredSupportedModes);
+        this.createDefaultOvenCavityOperationalStateClusterServer(cabinet, options.operationalState ?? OperationalState.OperationalStateEnum.Stopped, options.currentPhase, options.phaseList);
         return cabinet;
     }
     createDefaultOvenModeClusterServer(endpoint, currentMode, supportedModes) {

package/dist/devices/refrigerator.d.ts

@@ -1,11 +1,31 @@
 import type { MaybePromise } from '@matter/general';
 import { RefrigeratorAndTemperatureControlledCabinetModeServer } from '@matter/node/behaviors/refrigerator-and-temperature-controlled-cabinet-mode';
-import type { Semtag } from '@matter/types';
+import type { EndpointNumber, Semtag } from '@matter/types';
 import { ModeBase } from '@matter/types/clusters/mode-base';
 import { RefrigeratorAndTemperatureControlledCabinetMode } from '@matter/types/clusters/refrigerator-and-temperature-controlled-cabinet-mode';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface RefrigeratorOptions {
+    mode?: 'server' | 'matter';
+    id?: string;
+    number?: EndpointNumber;
+    tagList?: Semtag[];
+    currentMode?: number;
+    supportedModes?: RefrigeratorAndTemperatureControlledCabinetMode.ModeOption[];
+}
+export interface RefrigeratorCabinetOptions {
+    id?: string;
+    number?: EndpointNumber;
+    tagList: Semtag[];
+    targetTemperature?: number;
+    minTemperature?: number;
+    maxTemperature?: number;
+    step?: number;
+    currentTemperature?: number;
+}
 export declare class Refrigerator extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: RefrigeratorOptions);
     constructor(name: string, serial: string, currentMode?: number, supportedModes?: RefrigeratorAndTemperatureControlledCabinetMode.ModeOption[]);
+    addCabinet(name: string, options: RefrigeratorCabinetOptions): MatterbridgeEndpoint;
     addCabinet(name: string, tagList: Semtag[], targetTemperature?: number, minTemperature?: number, maxTemperature?: number, step?: number, currentTemperature?: number): MatterbridgeEndpoint;
     createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(endpoint: MatterbridgeEndpoint, currentMode: number, supportedModes: RefrigeratorAndTemperatureControlledCabinetMode.ModeOption[]): MatterbridgeEndpoint;
     createDefaultRefrigeratorAlarmClusterServer(endpoint: MatterbridgeEndpoint, doorOpen?: boolean): MatterbridgeEndpoint;

package/dist/devices/refrigerator.js

@@ -8,24 +8,34 @@ import { powerSource, refrigerator, temperatureControlledCabinetCooler } from '.
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { createNumberTemperatureControlClusterServer } from './temperatureControl.js';
 export class Refrigerator extends MatterbridgeEndpoint {
-    constructor(name, serial, currentMode = 1, supportedModes = [
-        { label: 'Auto', mode: 1, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.Auto }] },
-        { label: 'RapidCool', mode: 2, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidCool }] },
-        { label: 'RapidFreeze', mode: 3, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidFreeze }] },
-    ]) {
-        super([refrigerator, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+    constructor(name, serial, optionsOrCurrentMode, supportedModes) {
+        const options = typeof optionsOrCurrentMode === 'object' ? optionsOrCurrentMode : { currentMode: optionsOrCurrentMode, supportedModes };
+        const configuredSupportedModes = options.supportedModes ?? [
+            { label: 'Auto', mode: 1, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.Auto }] },
+            { label: 'RapidCool', mode: 2, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidCool }] },
+            { label: 'RapidFreeze', mode: 3, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidFreeze }] },
+        ];
+        super([refrigerator, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+            tagList: options.tagList,
+            mode: options.mode,
+        });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Refrigerator');
         this.createDefaultPowerSourceWiredClusterServer();
         fireAndForget(this.addFixedLabel('composed', 'Refrigerator'), this.log, 'Error adding composed label to Refrigerator');
-        this.createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(this, currentMode, supportedModes);
+        this.createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(this, options.currentMode ?? 1, configuredSupportedModes);
         this.createDefaultRefrigeratorAlarmClusterServer(this, false);
     }
-    addCabinet(name, tagList, targetTemperature = 10 * 100, minTemperature = -30 * 100, maxTemperature = 20 * 100, step = 1 * 100, currentTemperature = 10 * 100) {
-        const cabinet = this.addChildDeviceType(name, temperatureControlledCabinetCooler, { tagList });
+    addCabinet(name, optionsOrTagList, targetTemperature, minTemperature, maxTemperature, step, currentTemperature) {
+        const options = Array.isArray(optionsOrTagList)
+            ? { tagList: optionsOrTagList, targetTemperature, minTemperature, maxTemperature, step, currentTemperature }
+            : optionsOrTagList;
+        const cabinet = this.addChildDeviceType(options.id ?? name, temperatureControlledCabinetCooler, { number: options.number, tagList: options.tagList });
         cabinet.log.logName = name;
-        createNumberTemperatureControlClusterServer(cabinet, targetTemperature, minTemperature, maxTemperature, step);
-        cabinet.createDefaultTemperatureMeasurementClusterServer(currentTemperature);
+        createNumberTemperatureControlClusterServer(cabinet, options.targetTemperature ?? 10 * 100, options.minTemperature ?? -30 * 100, options.maxTemperature ?? 20 * 100, options.step ?? 1 * 100);
+        cabinet.createDefaultTemperatureMeasurementClusterServer(options.currentTemperature ?? 10 * 100);
         return cabinet;
     }
     createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(endpoint, currentMode, supportedModes) {

package/dist/devices/roboticVacuumCleaner.d.ts

@@ -1,14 +1,35 @@
 import { RvcCleanModeServer } from '@matter/node/behaviors/rvc-clean-mode';
 import { RvcOperationalStateServer } from '@matter/node/behaviors/rvc-operational-state';
 import { RvcRunModeServer } from '@matter/node/behaviors/rvc-run-mode';
+import type { EndpointNumber } from '@matter/types';
 import { ModeBase } from '@matter/types/clusters/mode-base';
 import { OperationalState } from '@matter/types/clusters/operational-state';
 import { RvcCleanMode } from '@matter/types/clusters/rvc-clean-mode';
 import { RvcOperationalState } from '@matter/types/clusters/rvc-operational-state';
 import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
 import { ServiceArea } from '@matter/types/clusters/service-area';
+import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface RoboticVacuumCleanerOptions {
+    mode?: 'server' | 'matter';
+    id?: string;
+    number?: EndpointNumber;
+    tagList?: Semtag[];
+    currentRunMode?: number;
+    supportedRunModes?: RvcRunMode.ModeOption[];
+    currentCleanMode?: number;
+    supportedCleanModes?: RvcCleanMode.ModeOption[];
+    currentPhase?: number | null;
+    phaseList?: string[] | null;
+    operationalState?: RvcOperationalState.OperationalState;
+    operationalStateList?: RvcOperationalState.OperationalStateStruct[];
+    supportedAreas?: ServiceArea.Area[];
+    selectedAreas?: number[];
+    currentArea?: number | null;
+    supportedMaps?: ServiceArea.Map[];
+}
 export declare class RoboticVacuumCleaner extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: RoboticVacuumCleanerOptions);
     constructor(name: string, serial: string, mode?: 'server' | 'matter', currentRunMode?: number, supportedRunModes?: RvcRunMode.ModeOption[], currentCleanMode?: number, supportedCleanModes?: RvcCleanMode.ModeOption[], currentPhase?: number | null, phaseList?: string[] | null, operationalState?: RvcOperationalState.OperationalState, operationalStateList?: RvcOperationalState.OperationalStateStruct[], supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number | null, supportedMaps?: ServiceArea.Map[]);
     createDefaultRvcRunModeClusterServer(currentMode?: number, supportedModes?: RvcRunMode.ModeOption[]): this;
     createDefaultRvcCleanModeClusterServer(currentMode?: number, supportedModes?: RvcCleanMode.ModeOption[]): this;

package/dist/devices/roboticVacuumCleaner.js

@@ -14,15 +14,37 @@ import { MatterbridgeServiceAreaServer } from '../behaviors/serviceAreaServer.js
 import { powerSource, roboticVacuumCleaner } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
-    constructor(name, serial, mode, currentRunMode, supportedRunModes, currentCleanMode, supportedCleanModes, currentPhase = null, phaseList = null, operationalState, operationalStateList, supportedAreas, selectedAreas, currentArea, supportedMaps) {
-        super([roboticVacuumCleaner, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, mode });
+    constructor(name, serial, modeOrOptions, currentRunMode, supportedRunModes, currentCleanMode, supportedCleanModes, currentPhase = null, phaseList = null, operationalState, operationalStateList, supportedAreas, selectedAreas, currentArea, supportedMaps) {
+        const options = typeof modeOrOptions === 'object'
+            ? modeOrOptions
+            : {
+                mode: modeOrOptions,
+                currentRunMode,
+                supportedRunModes,
+                currentCleanMode,
+                supportedCleanModes,
+                currentPhase,
+                phaseList,
+                operationalState,
+                operationalStateList,
+                supportedAreas,
+                selectedAreas,
+                currentArea,
+                supportedMaps,
+            };
+        super([roboticVacuumCleaner, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+            tagList: options.tagList,
+            mode: options.mode,
+        });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Robot Vacuum Cleaner')
             .createDefaultPowerSourceRechargeableBatteryClusterServer(80, PowerSource.BatChargeLevel.Ok, 5900)
-            .createDefaultRvcRunModeClusterServer(currentRunMode, supportedRunModes)
-            .createDefaultRvcCleanModeClusterServer(currentCleanMode, supportedCleanModes)
-            .createDefaultRvcOperationalStateClusterServer(phaseList, currentPhase, operationalStateList, operationalState)
-            .createDefaultServiceAreaClusterServer(supportedAreas, selectedAreas, currentArea, supportedMaps);
+            .createDefaultRvcRunModeClusterServer(options.currentRunMode, options.supportedRunModes)
+            .createDefaultRvcCleanModeClusterServer(options.currentCleanMode, options.supportedCleanModes)
+            .createDefaultRvcOperationalStateClusterServer(options.phaseList, options.currentPhase, options.operationalStateList, options.operationalState)
+            .createDefaultServiceAreaClusterServer(options.supportedAreas, options.selectedAreas, options.currentArea, options.supportedMaps);
     }
     createDefaultRvcRunModeClusterServer(currentMode, supportedModes) {
         this.behaviors.require(MatterbridgeRvcRunModeServer, {

package/dist/matterbridgeEndpoint.d.ts

@@ -207,7 +207,7 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     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, movementDuration?: number, autoClose?: boolean): this;
-    createDefaultPumpConfigurationAndControlClusterServer(pumpMode?: PumpConfigurationAndControl.OperationMode): this;
+    createDefaultPumpConfigurationAndControlClusterServer(pumpMode?: PumpConfigurationAndControl.OperationMode, maxPressure?: number | null, maxSpeed?: number | null, maxFlow?: number | null, minConstSpeed?: number | null, maxConstSpeed?: number | null, speed?: number | null): this;
     createDefaultSmokeCOAlarmClusterServer(smokeState?: SmokeCoAlarm.AlarmState, coState?: SmokeCoAlarm.AlarmState): this;
     createSmokeOnlySmokeCOAlarmClusterServer(smokeState?: SmokeCoAlarm.AlarmState): this;
     createCoOnlySmokeCOAlarmClusterServer(coState?: SmokeCoAlarm.AlarmState): this;

package/dist/matterbridgeEndpoint.js

@@ -20,7 +20,6 @@ import { Pm10ConcentrationMeasurementServer } from '@matter/node/behaviors/pm10-
 import { Pm25ConcentrationMeasurementServer } from '@matter/node/behaviors/pm25-concentration-measurement';
 import { PowerTopologyServer } from '@matter/node/behaviors/power-topology';
 import { PressureMeasurementServer } from '@matter/node/behaviors/pressure-measurement';
-import { PumpConfigurationAndControlServer } from '@matter/node/behaviors/pump-configuration-and-control';
 import { RadonConcentrationMeasurementServer } from '@matter/node/behaviors/radon-concentration-measurement';
 import { RelativeHumidityMeasurementServer } from '@matter/node/behaviors/relative-humidity-measurement';
 import { ScenesManagementServer } from '@matter/node/behaviors/scenes-management';
@@ -77,6 +76,7 @@ import { MatterbridgeOccupancySensingServer } from './behaviors/occupancySensing
 import { MatterbridgeOnOffServer } from './behaviors/onOffServer.js';
 import { MatterbridgeOperationalStateServer } from './behaviors/operationalStateServer.js';
 import { MatterbridgePowerSourceServer } from './behaviors/powerSourceServer.js';
+import { MatterbridgePumpConfigurationAndControlServer } from './behaviors/pumpConfigurationAndControlServer.js';
 import { MatterbridgeSmokeCoAlarmServer } from './behaviors/smokeCoAlarmServer.js';
 import { MatterbridgeSwitchServer } from './behaviors/switchServer.js';
 import { MatterbridgeThermostatServer } from './behaviors/thermostatServer.js';
@@ -1303,17 +1303,20 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
-    createDefaultPumpConfigurationAndControlClusterServer(pumpMode = PumpConfigurationAndControl.OperationMode.Normal) {
-        this.behaviors.require(PumpConfigurationAndControlServer.with(PumpConfigurationAndControl.Feature.ConstantSpeed), {
-            minConstSpeed: null,
-            maxConstSpeed: null,
-            maxPressure: null,
-            maxSpeed: null,
-            maxFlow: null,
+    createDefaultPumpConfigurationAndControlClusterServer(pumpMode = PumpConfigurationAndControl.OperationMode.Normal, maxPressure = null, maxSpeed = null, maxFlow = null, minConstSpeed = null, maxConstSpeed = null, speed = null) {
+        this.behaviors.require(MatterbridgePumpConfigurationAndControlServer.with(PumpConfigurationAndControl.Feature.ConstantSpeed), {
+            minConstSpeed,
+            maxConstSpeed,
+            maxPressure,
+            maxSpeed,
+            maxFlow,
+            speed,
             effectiveOperationMode: pumpMode,
             effectiveControlMode: PumpConfigurationAndControl.ControlMode.ConstantSpeed,
             capacity: null,
+            pumpStatus: new PumpConfigurationAndControl.PumpStatus({ running: false }),
             operationMode: pumpMode,
+            controlMode: PumpConfigurationAndControl.ControlMode.ConstantSpeed,
         });
         return this;
     }

package/dist/matterbridgeEndpointHelpers.js

@@ -37,7 +37,7 @@ import { Pm25ConcentrationMeasurementServer } from '@matter/node/behaviors/pm25-
 import { PowerSourceServer } from '@matter/node/behaviors/power-source';
 import { PowerTopologyServer } from '@matter/node/behaviors/power-topology';
 import { PressureMeasurementClient, PressureMeasurementServer } from '@matter/node/behaviors/pressure-measurement';
-import { PumpConfigurationAndControlClient, PumpConfigurationAndControlServer } from '@matter/node/behaviors/pump-configuration-and-control';
+import { PumpConfigurationAndControlClient } from '@matter/node/behaviors/pump-configuration-and-control';
 import { RadonConcentrationMeasurementServer } from '@matter/node/behaviors/radon-concentration-measurement';
 import { RelativeHumidityMeasurementClient, RelativeHumidityMeasurementServer } from '@matter/node/behaviors/relative-humidity-measurement';
 import { ScenesManagementClient, ScenesManagementServer } from '@matter/node/behaviors/scenes-management';
@@ -125,6 +125,7 @@ import { MatterbridgeOccupancySensingServer } from './behaviors/occupancySensing
 import { MatterbridgeOnOffServer } from './behaviors/onOffServer.js';
 import { MatterbridgeOperationalStateServer } from './behaviors/operationalStateServer.js';
 import { MatterbridgePowerSourceServer } from './behaviors/powerSourceServer.js';
+import { MatterbridgePumpConfigurationAndControlServer } from './behaviors/pumpConfigurationAndControlServer.js';
 import { MatterbridgeSmokeCoAlarmServer } from './behaviors/smokeCoAlarmServer.js';
 import { MatterbridgeThermostatServer } from './behaviors/thermostatServer.js';
 import { MatterbridgeValveConfigurationAndControlServer } from './behaviors/valveConfigurationAndControlServer.js';
@@ -293,7 +294,7 @@ export function getBehaviourTypeFromClusterServerId(clusterId) {
     if (clusterId === ValveConfigurationAndControl.id)
         return MatterbridgeValveConfigurationAndControlServer.with('Level');
     if (clusterId === PumpConfigurationAndControl.id)
-        return PumpConfigurationAndControlServer.with('ConstantSpeed');
+        return MatterbridgePumpConfigurationAndControlServer.with('ConstantSpeed');
     if (clusterId === SmokeCoAlarm.id)
         return MatterbridgeSmokeCoAlarmServer.with('SmokeAlarm', 'CoAlarm');
     if (clusterId === Switch.id)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.7-dev-20260823-6142c00",
+  "version": "3.10.7-dev-20260825-7ebac36",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -132,10 +132,10 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.7-dev-20260823-6142c00",
-    "@matterbridge/thread": "3.10.7-dev-20260823-6142c00",
-    "@matterbridge/types": "3.10.7-dev-20260823-6142c00",
-    "@matterbridge/utils": "3.10.7-dev-20260823-6142c00",
+    "@matterbridge/dgram": "3.10.7-dev-20260825-7ebac36",
+    "@matterbridge/thread": "3.10.7-dev-20260825-7ebac36",
+    "@matterbridge/types": "3.10.7-dev-20260825-7ebac36",
+    "@matterbridge/utils": "3.10.7-dev-20260825-7ebac36",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.6.2",