@matterbridge/core 3.10.5-dev-20260807-79a10b4 → 3.10.5-dev-20260809-ffe76d7

package/dist/behaviors/thermostatServer.d.ts

@@ -6,15 +6,15 @@ declare const MatterbridgeThermostatServer_base: import("@matter/node").ClusterB
     events: false;
     heating: true;
     localTemperatureNotExposed: false;
-    matterScheduleConfiguration: false;
+    matterScheduleConfiguration: true;
     occupancy: false;
     presets: true;
     setback: false;
     thermostatSuggestions: false;
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/thermostat").ThermostatBaseServer.Internal, "thermostat">;
 export declare class MatterbridgeThermostatServer extends MatterbridgeThermostatServer_base {
-    initialize(): Promise<void>;
     setpointRaiseLower(request: Thermostat.SetpointRaiseLowerRequest): Promise<void>;
     setActivePresetRequest(request: Thermostat.SetActivePresetRequest): Promise<void>;
+    setActiveScheduleRequest(request: Thermostat.SetActiveScheduleRequest): Promise<void>;
 }
 export {};

package/dist/behaviors/thermostatServer.js

@@ -1,18 +1,9 @@
+import { Bytes } from '@matter/general';
 import { ThermostatServer } from '@matter/node/behaviors/thermostat';
+import { StatusResponse } from '@matter/types';
 import { Thermostat } from '@matter/types/clusters/thermostat';
 import { MatterbridgeServer } from './matterbridgeServer.js';
-export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode, Thermostat.Feature.Presets) {
-    async initialize() {
-        await super.initialize();
-        this.endpoint.construction.onSuccess(async () => {
-            const device = this.endpoint.stateOf(MatterbridgeServer);
-            device.log.debug(`Removing atomic commands (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-            await this.endpoint.setStateOf(ThermostatServer, {
-                acceptedCommandList: [0],
-                generatedCommandList: [],
-            });
-        });
-    }
+export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode, Thermostat.Feature.Presets, Thermostat.Feature.MatterScheduleConfiguration) {
     async setpointRaiseLower(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting setpoint by ${request.amount} in mode ${request.mode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -45,4 +36,23 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
         const activePresetHandle = this.state.activePresetHandle ? `0x${Buffer.from(this.state.activePresetHandle).toString('hex')}` : 'null';
         device.log.debug(`MatterbridgeThermostatServer: setActivePresetRequest completed with activePresetHandle: ${activePresetHandle} occupiedHeatingSetpoint: ${this.state.occupiedHeatingSetpoint} occupiedCoolingSetpoint: ${this.state.occupiedCoolingSetpoint}`);
     }
+    async setActiveScheduleRequest(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const scheduleHandle = `0x${Buffer.from(request.scheduleHandle).toString('hex')}`;
+        device.log.info(`Setting schedule to ${scheduleHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('Thermostat.setActiveScheduleRequest', {
+            command: 'setActiveScheduleRequest',
+            request,
+            cluster: ThermostatServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        const schedule = this.state.schedules.find((s) => s.scheduleHandle !== null && Bytes.areEqual(s.scheduleHandle, request.scheduleHandle));
+        if (schedule === undefined) {
+            throw new StatusResponse.InvalidCommandError('Requested ScheduleHandle not found');
+        }
+        this.state.activeScheduleHandle = Uint8Array.from(request.scheduleHandle);
+        device.log.debug(`MatterbridgeThermostatServer: setActiveScheduleRequest completed with activeScheduleHandle: ${scheduleHandle}`);
+    }
 }

package/dist/devices/closure.d.ts

@@ -2,7 +2,7 @@ import { ClosureControlServer } from '@matter/node/behaviors/closure-control';
 import { ClosureControl } from '@matter/types/clusters/closure-control';
 import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-import { type ClosurePanelOptions } from './closurePanel.js';
+import { type ClosureDimensionType, type ClosurePanelOptions } from './closurePanel.js';
 declare const MatterbridgeClosureControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof ClosureControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<ClosureControl, {
     calibration: false;
     instantaneous: false;
@@ -30,6 +30,6 @@ export interface ClosureOptions {
 export declare class Closure extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, options?: ClosureOptions);
     getMainState(): ClosureControl.MainState | undefined;
-    addPanel(name: string, tagList: Semtag[], options?: Pick<ClosurePanelOptions, 'currentState' | 'targetState' | 'resolution' | 'stepValue' | 'latchControlModes'>): MatterbridgeEndpoint;
+    addPanel(name: string, tagList: Semtag[], dimensionType: ClosureDimensionType, options?: Omit<ClosurePanelOptions, 'tagList'>): MatterbridgeEndpoint;
 }
 export {};

package/dist/devices/closure.js

@@ -4,7 +4,7 @@ import { ThreeLevelAuto } from '@matter/types/globals';
 import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
 import { closure, closurePanel } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-import { MatterbridgeClosureDimensionServer } from './closurePanel.js';
+import { createClosureDimensionClusterServer } from './closurePanel.js';
 export class MatterbridgeClosureControlServer extends ClosureControlServer.with(ClosureControl.Feature.Positioning, ClosureControl.Feature.MotionLatching, ClosureControl.Feature.Speed) {
     moveTo = async (request) => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -21,10 +21,15 @@ export class MatterbridgeClosureControlServer extends ClosureControlServer.with(
             ...previousTarget,
             ...(request?.position !== undefined ? { position: request.position } : null),
             ...(request?.latch !== undefined ? { latch: request.latch } : null),
-            speed: request?.speed ?? previousTarget.speed ?? ThreeLevelAuto.Auto,
+            speed: request?.speed ?? ThreeLevelAuto.Auto,
         };
         this.state.overallTargetState = nextTarget;
-        this.state.mainState = ClosureControl.MainState.Moving;
+        const currentState = this.state.overallCurrentState;
+        const isAtTarget = currentState !== null &&
+            (nextTarget.position === undefined || nextTarget.position === currentState.position) &&
+            (nextTarget.latch === undefined || nextTarget.latch === currentState.latch) &&
+            nextTarget.speed === currentState.speed;
+        this.state.mainState = isAtTarget ? ClosureControl.MainState.Stopped : ClosureControl.MainState.Moving;
     };
     stop = async () => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -65,15 +70,9 @@ export class Closure extends MatterbridgeEndpoint {
     getMainState() {
         return this.getAttribute(ClosureControlServer, 'mainState');
     }
-    addPanel(name, tagList, options = {}) {
+    addPanel(name, tagList, dimensionType, options = {}) {
         const panel = this.addChildDeviceType(name, closurePanel, { tagList });
-        panel.behaviors.require(MatterbridgeClosureDimensionServer, {
-            currentState: options.currentState ?? { position: 0, latch: true, speed: ThreeLevelAuto.Auto },
-            targetState: options.targetState ?? { position: 0, latch: true, speed: ThreeLevelAuto.Auto },
-            resolution: options.resolution ?? 1,
-            stepValue: options.stepValue ?? 1,
-            latchControlModes: options.latchControlModes ?? { remoteLatching: true, remoteUnlatching: true },
-        });
+        createClosureDimensionClusterServer(panel, dimensionType, options);
         return panel;
     }
 }

package/dist/devices/closurePanel.d.ts

@@ -2,6 +2,7 @@ import { ClosureDimensionServer } from '@matter/node/behaviors/closure-dimension
 import { ClosureDimension } from '@matter/types/clusters/closure-dimension';
 import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export type ClosureDimensionType = 'lift' | 'tilt' | 'modulation';
 declare const MatterbridgeClosureDimensionServer_base: import("@matter/node").ClusterBehavior.Type<typeof ClosureDimensionServer, import("@matter/types").ClusterType.WithSupportedFeatures<ClosureDimension, {
     limitation: false;
     modulation: false;
@@ -22,9 +23,14 @@ export interface ClosurePanelOptions {
     resolution?: number;
     stepValue?: number;
     latchControlModes?: ClosureDimension.LatchControlModes;
+    translationDirection?: ClosureDimension.TranslationDirection;
+    rotationAxis?: ClosureDimension.RotationAxis;
+    overflow?: ClosureDimension.Overflow;
+    modulationType?: ClosureDimension.ModulationType;
     tagList?: Semtag[];
 }
 export declare class ClosurePanel extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string, options?: ClosurePanelOptions);
+    constructor(name: string, serial: string, dimensionType: ClosureDimensionType, options?: ClosurePanelOptions);
 }
+export declare function createClosureDimensionClusterServer(endpoint: MatterbridgeEndpoint, dimensionType: ClosureDimensionType, options: ClosurePanelOptions): MatterbridgeEndpoint;
 export {};

package/dist/devices/closurePanel.js

@@ -20,7 +20,7 @@ export class MatterbridgeClosureDimensionServer extends ClosureDimensionServer.w
             ...previousTarget,
             ...(request?.position !== undefined ? { position: request.position } : null),
             ...(request?.latch !== undefined ? { latch: request.latch } : null),
-            speed: request?.speed ?? previousTarget.speed ?? ThreeLevelAuto.Auto,
+            speed: request?.speed ?? ThreeLevelAuto.Auto,
         };
         this.state.targetState = nextTarget;
     };
@@ -53,15 +53,38 @@ export class MatterbridgeClosureDimensionServer extends ClosureDimensionServer.w
     };
 }
 export class ClosurePanel extends MatterbridgeEndpoint {
-    constructor(name, serial, options = {}) {
+    constructor(name, serial, dimensionType, options = {}) {
         super([closurePanel], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, tagList: options.tagList });
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Closure Panel');
-        this.behaviors.require(MatterbridgeClosureDimensionServer, {
-            currentState: options.currentState ?? { position: 0, latch: true, speed: ThreeLevelAuto.Auto },
-            targetState: options.targetState ?? { position: 0, latch: true, speed: ThreeLevelAuto.Auto },
-            resolution: options.resolution ?? 1,
-            stepValue: options.stepValue ?? 1,
-            latchControlModes: options.latchControlModes ?? { remoteLatching: true, remoteUnlatching: true },
+        createClosureDimensionClusterServer(this, dimensionType, options);
+    }
+}
+export function createClosureDimensionClusterServer(endpoint, dimensionType, options) {
+    const commonOptions = {
+        currentState: options.currentState ?? { position: 0, latch: true, speed: ThreeLevelAuto.Auto },
+        targetState: options.targetState ?? { position: 0, latch: true, speed: ThreeLevelAuto.Auto },
+        resolution: options.resolution ?? 1,
+        stepValue: options.stepValue ?? 1,
+        latchControlModes: options.latchControlModes ?? { remoteLatching: true, remoteUnlatching: true },
+    };
+    if (dimensionType === 'lift') {
+        endpoint.behaviors.require(MatterbridgeClosureDimensionServer.with(ClosureDimension.Feature.Positioning, ClosureDimension.Feature.MotionLatching, ClosureDimension.Feature.Speed, ClosureDimension.Feature.Translation), {
+            ...commonOptions,
+            translationDirection: options.translationDirection ?? ClosureDimension.TranslationDirection.Downward,
+        });
+    }
+    else if (dimensionType === 'tilt') {
+        endpoint.behaviors.require(MatterbridgeClosureDimensionServer.with(ClosureDimension.Feature.Positioning, ClosureDimension.Feature.MotionLatching, ClosureDimension.Feature.Speed, ClosureDimension.Feature.Rotation), {
+            ...commonOptions,
+            rotationAxis: options.rotationAxis ?? ClosureDimension.RotationAxis.CenteredHorizontal,
+            overflow: options.overflow ?? ClosureDimension.Overflow.NoOverflow,
+        });
+    }
+    else {
+        endpoint.behaviors.require(MatterbridgeClosureDimensionServer.with(ClosureDimension.Feature.Positioning, ClosureDimension.Feature.MotionLatching, ClosureDimension.Feature.Speed, ClosureDimension.Feature.Modulation), {
+            ...commonOptions,
+            modulationType: options.modulationType ?? ClosureDimension.ModulationType.SlatsOrientation,
         });
     }
+    return endpoint;
 }

package/dist/devices/irrigationSystem.d.ts

@@ -2,7 +2,6 @@ import { OperationalState } from '@matter/types/clusters/operational-state';
 import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export interface IrrigationSystemOptions {
-    singleZone?: boolean;
     batteryPowered?: boolean;
     operationalState?: OperationalState.OperationalStateEnum;
     flowMeasuredValue?: number | null;

package/dist/devices/irrigationSystem.js

@@ -5,8 +5,7 @@ import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { getSemtag } from '../matterbridgeEndpointHelpers.js';
 export class IrrigationSystem extends MatterbridgeEndpoint {
     constructor(name, serial, options = {}) {
-        const deviceTypes = options.singleZone ? [irrigationSystem, waterValve, powerSource] : [irrigationSystem, powerSource];
-        super(deviceTypes, { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        super([irrigationSystem, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Irrigation System');
         if (options.batteryPowered) {
@@ -18,9 +17,6 @@ export class IrrigationSystem extends MatterbridgeEndpoint {
         this.createDefaultOperationalStateClusterServer(options.operationalState ?? OperationalState.OperationalStateEnum.Stopped);
         if (options.flowMeasuredValue !== undefined)
             this.createDefaultFlowMeasurementClusterServer(options.flowMeasuredValue);
-        if (options.singleZone) {
-            this.createDefaultValveConfigurationAndControlClusterServer();
-        }
         this.addRequiredClusterServers();
     }
     addZone(tag) {

package/dist/devices/microwaveOven.d.ts

@@ -3,14 +3,14 @@ import { MicrowaveOvenControl } from '@matter/types/clusters/microwave-oven-cont
 import { MicrowaveOvenMode } from '@matter/types/clusters/microwave-oven-mode';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class MicrowaveOven extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string, currentMode?: number, supportedModes?: MicrowaveOvenMode.ModeOption[], selectedWattIndex?: number, supportedWatts?: number[], cookTime?: number, maxCookTime?: number);
+    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(selectedWattIndex: number, supportedWatts: number[], cookTime: number, maxCookTime: number): this;
+    createDefaultMicrowaveOvenControlClusterServer(powerSetting: number, minPower: number, maxPower: number, powerStep: number, cookTime: number, maxCookTime: number): this;
 }
 declare const MatterbridgeMicrowaveOvenControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof MicrowaveOvenControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<MicrowaveOvenControl, {
-    powerAsNumber: false;
-    powerInWatts: true;
-    powerNumberLimits: false;
+    powerAsNumber: true;
+    powerInWatts: false;
+    powerNumberLimits: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "microwaveOvenControl">;
 export declare class MatterbridgeMicrowaveOvenControlServer extends MatterbridgeMicrowaveOvenControlServer_base {
     initialize(): Promise<void>;

package/dist/devices/microwaveOven.js

@@ -16,14 +16,14 @@ export class MicrowaveOven extends MatterbridgeEndpoint {
         { 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 }] },
-    ], selectedWattIndex = 5, supportedWatts = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000], cookTime = 60, maxCookTime = 3600) {
+    ], powerSetting = 100, minPower = 10, maxPower = 100, powerStep = 10, cookTime = 60, maxCookTime = 3600) {
         super([microwaveOven, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Microwave Oven');
         this.createDefaultPowerSourceWiredClusterServer();
         this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
         this.createDefaultMicrowaveOvenModeClusterServer(currentMode, supportedModes);
-        this.createDefaultMicrowaveOvenControlClusterServer(selectedWattIndex, supportedWatts, cookTime, maxCookTime);
+        this.createDefaultMicrowaveOvenControlClusterServer(powerSetting, minPower, maxPower, powerStep, cookTime, maxCookTime);
     }
     createDefaultMicrowaveOvenModeClusterServer(currentMode, supportedModes) {
         this.behaviors.require(MicrowaveOvenModeServer, {
@@ -32,17 +32,19 @@ export class MicrowaveOven extends MatterbridgeEndpoint {
         });
         return this;
     }
-    createDefaultMicrowaveOvenControlClusterServer(selectedWattIndex, supportedWatts, cookTime, maxCookTime) {
-        this.behaviors.require(MatterbridgeMicrowaveOvenControlServer.with(MicrowaveOvenControl.Feature.PowerInWatts), {
-            supportedWatts,
-            selectedWattIndex,
+    createDefaultMicrowaveOvenControlClusterServer(powerSetting, minPower, maxPower, powerStep, cookTime, maxCookTime) {
+        this.behaviors.require(MatterbridgeMicrowaveOvenControlServer.with(MicrowaveOvenControl.Feature.PowerAsNumber, MicrowaveOvenControl.Feature.PowerNumberLimits), {
+            powerSetting,
+            minPower,
+            maxPower,
+            powerStep,
             cookTime,
             maxCookTime,
         });
         return this;
     }
 }
-export class MatterbridgeMicrowaveOvenControlServer extends MicrowaveOvenControlServer.with(MicrowaveOvenControl.Feature.PowerInWatts) {
+export class MatterbridgeMicrowaveOvenControlServer extends MicrowaveOvenControlServer.with(MicrowaveOvenControl.Feature.PowerAsNumber, MicrowaveOvenControl.Feature.PowerNumberLimits) {
     async initialize() {
         await super.initialize();
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -76,13 +78,13 @@ export class MatterbridgeMicrowaveOvenControlServer extends MicrowaveOvenControl
             device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called with no cookTime so set to 30sec.`);
             this.state.cookTime = 30;
         }
-        if (request.wattSettingIndex !== undefined && request.wattSettingIndex >= 0 && request.wattSettingIndex < this.state.supportedWatts.length) {
-            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting selectedWattIndex to ${request.wattSettingIndex}`);
-            this.state.selectedWattIndex = request.wattSettingIndex;
+        if (request.powerSetting !== undefined && request.powerSetting >= this.state.minPower && request.powerSetting <= this.state.maxPower) {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting powerSetting to ${request.powerSetting}`);
+            this.state.powerSetting = request.powerSetting;
         }
         else {
-            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called with no wattSettingIndex so set to the highest Watt setting for the selected CookMode`);
-            this.state.selectedWattIndex = this.state.supportedWatts.length - 1;
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called with no powerSetting so set to maxPower`);
+            this.state.powerSetting = this.state.maxPower;
         }
         if (request.startAfterSetting === true) {
             device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting startAfterSetting = true`);

package/dist/matterbridgeEndpoint.d.ts

@@ -175,6 +175,7 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     createDefaultThermostatClusterServer(localTemperature?: number, occupiedHeatingSetpoint?: number, occupiedCoolingSetpoint?: number, minSetpointDeadBand?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, minCoolSetpointLimit?: number, maxCoolSetpointLimit?: number, unoccupiedHeatingSetpoint?: number, unoccupiedCoolingSetpoint?: number, occupied?: boolean, outdoorTemperature?: number | null): this;
     createDefaultHeatingThermostatClusterServer(localTemperature?: number, occupiedHeatingSetpoint?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, unoccupiedHeatingSetpoint?: number, occupied?: boolean, outdoorTemperature?: number | null): this;
     createDefaultPresetsThermostatClusterServer(localTemperature?: number, occupiedHeatingSetpoint?: number, occupiedCoolingSetpoint?: number, minSetpointDeadBand?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, minCoolSetpointLimit?: number, maxCoolSetpointLimit?: number, unoccupiedHeatingSetpoint?: number, unoccupiedCoolingSetpoint?: number, occupied?: boolean, outdoorTemperature?: number | null, activePresetHandle?: Uint8Array | null, presets?: Thermostat.Preset[], presetTypes?: Thermostat.PresetType[]): this;
+    createDefaultSchedulesThermostatClusterServer(localTemperature?: number, occupiedHeatingSetpoint?: number, occupiedCoolingSetpoint?: number, minSetpointDeadBand?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, minCoolSetpointLimit?: number, maxCoolSetpointLimit?: number, unoccupiedHeatingSetpoint?: number, unoccupiedCoolingSetpoint?: number, occupied?: boolean, outdoorTemperature?: number | null, activeScheduleHandle?: Uint8Array | null, schedules?: Thermostat.Schedule[], scheduleTypes?: Thermostat.ScheduleType[], numberOfScheduleTransitions?: number, numberOfScheduleTransitionPerDay?: number | null): this;
     createDefaultCoolingThermostatClusterServer(localTemperature?: number, occupiedCoolingSetpoint?: number, minCoolSetpointLimit?: number, maxCoolSetpointLimit?: number, unoccupiedCoolingSetpoint?: number, occupied?: boolean, outdoorTemperature?: number | null): this;
     createDefaultThermostatUserInterfaceConfigurationClusterServer(temperatureDisplayMode?: ThermostatUserInterfaceConfiguration.TemperatureDisplayMode, keypadLockout?: ThermostatUserInterfaceConfiguration.KeypadLockout, scheduleProgrammingVisibility?: ThermostatUserInterfaceConfiguration.ScheduleProgrammingVisibility): this;
     createDefaultFanControlClusterServer(fanMode?: FanControl.FanMode, fanModeSequence?: FanControl.FanModeSequence, percentSetting?: number, percentCurrent?: number): this;

package/dist/matterbridgeEndpoint.js

@@ -992,7 +992,7 @@ export class MatterbridgeEndpoint extends Endpoint {
             ...(occupied !== undefined ? { unoccupiedCoolingSetpoint: unoccupiedCoolingSetpoint !== undefined ? unoccupiedCoolingSetpoint * 100 : 2700 } : {}),
             ...(occupied !== undefined ? { occupancy: { occupied } } : {}),
             ...(occupied !== undefined ? { externallyMeasuredOccupancy: true } : {}),
-            numberOfPresets: Math.max(Array.isArray(presets) ? presets.length : 0, 10),
+            numberOfPresets: Math.max(Array.isArray(presets) ? presets.length : 0, Array.isArray(presetTypes) ? Math.max(0, ...presetTypes.map((pt) => pt.numberOfPresets ?? 0)) : 0, 1),
             activePresetHandle: activePresetHandle ? Uint8Array.from([activePresetHandle]) : null,
             presets: (presets ?? []).map((p) => ({
                 presetHandle: p.presetHandle ? Uint8Array.from(p.presetHandle) : null,
@@ -1010,6 +1010,55 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    createDefaultSchedulesThermostatClusterServer(localTemperature = 23, occupiedHeatingSetpoint = 21, occupiedCoolingSetpoint = 25, minSetpointDeadBand = 0, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50, unoccupiedHeatingSetpoint, unoccupiedCoolingSetpoint, occupied, outdoorTemperature, activeScheduleHandle = null, schedules = [], scheduleTypes = [
+        {
+            systemMode: Thermostat.SystemMode.Auto,
+            numberOfSchedules: 10,
+            scheduleTypeFeatures: { supportsSetpoints: true, supportsNames: true, supportsPresets: false, supportsOff: false },
+        },
+    ], numberOfScheduleTransitions = 10, numberOfScheduleTransitionPerDay = null) {
+        this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : []), Thermostat.Feature.MatterScheduleConfiguration), {
+            localTemperature: localTemperature * 100,
+            externalMeasuredIndoorTemperature: localTemperature * 100,
+            ...(outdoorTemperature !== undefined ? { outdoorTemperature: outdoorTemperature !== null ? outdoorTemperature * 100 : outdoorTemperature } : {}),
+            systemMode: Thermostat.SystemMode.Auto,
+            controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation.CoolingAndHeating,
+            occupiedHeatingSetpoint: occupiedHeatingSetpoint * 100,
+            minHeatSetpointLimit: minHeatSetpointLimit * 100,
+            maxHeatSetpointLimit: maxHeatSetpointLimit * 100,
+            absMinHeatSetpointLimit: minHeatSetpointLimit * 100,
+            absMaxHeatSetpointLimit: maxHeatSetpointLimit * 100,
+            occupiedCoolingSetpoint: occupiedCoolingSetpoint * 100,
+            minCoolSetpointLimit: minCoolSetpointLimit * 100,
+            maxCoolSetpointLimit: maxCoolSetpointLimit * 100,
+            absMinCoolSetpointLimit: minCoolSetpointLimit * 100,
+            absMaxCoolSetpointLimit: maxCoolSetpointLimit * 100,
+            minSetpointDeadBand: minSetpointDeadBand * 10,
+            thermostatRunningMode: Thermostat.ThermostatRunningMode.Off,
+            ...(occupied !== undefined ? { unoccupiedHeatingSetpoint: unoccupiedHeatingSetpoint !== undefined ? unoccupiedHeatingSetpoint * 100 : 1900 } : {}),
+            ...(occupied !== undefined ? { unoccupiedCoolingSetpoint: unoccupiedCoolingSetpoint !== undefined ? unoccupiedCoolingSetpoint * 100 : 2700 } : {}),
+            ...(occupied !== undefined ? { occupancy: { occupied } } : {}),
+            ...(occupied !== undefined ? { externallyMeasuredOccupancy: true } : {}),
+            numberOfSchedules: Math.max(Array.isArray(schedules) ? schedules.length : 0, Array.isArray(scheduleTypes) ? Math.max(0, ...scheduleTypes.map((st) => st.numberOfSchedules ?? 0)) : 0, 1),
+            numberOfScheduleTransitions,
+            numberOfScheduleTransitionPerDay,
+            activeScheduleHandle: activeScheduleHandle ? Uint8Array.from(activeScheduleHandle) : null,
+            schedules: (schedules ?? []).map((s) => ({
+                scheduleHandle: s.scheduleHandle ? Uint8Array.from(s.scheduleHandle) : null,
+                systemMode: s.systemMode,
+                name: s.name,
+                presetHandle: s.presetHandle ? Uint8Array.from(s.presetHandle) : undefined,
+                transitions: s.transitions ?? [],
+                builtIn: s.builtIn ?? true,
+            })),
+            scheduleTypes: (scheduleTypes ?? []).map((st) => ({
+                ...st,
+                numberOfSchedules: st.numberOfSchedules ?? 0,
+                scheduleTypeFeatures: st.scheduleTypeFeatures ?? { supportsSetpoints: true, supportsNames: true, supportsPresets: false, supportsOff: false },
+            })),
+        });
+        return this;
+    }
     createDefaultCoolingThermostatClusterServer(localTemperature = 23, occupiedCoolingSetpoint = 25, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50, unoccupiedCoolingSetpoint, occupied, outdoorTemperature) {
         this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Cooling, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : [])), {
             localTemperature: localTemperature * 100,

package/dist/matterbridgeEndpointCommandHandler.d.ts

@@ -457,6 +457,7 @@ export type CommandHandlerDataMap = {
     };
     'setpointRaiseLower': CommandHandlerData<'Thermostat.setpointRaiseLower'>;
     'setActivePresetRequest': CommandHandlerData<'Thermostat.setActivePresetRequest'>;
+    'setActiveScheduleRequest': CommandHandlerData<'Thermostat.setActiveScheduleRequest'>;
     'Thermostat.setpointRaiseLower': {
         command: 'setpointRaiseLower';
         request: Thermostat.SetpointRaiseLowerRequest;
@@ -471,6 +472,13 @@ export type CommandHandlerDataMap = {
         attributes: ClusterAttributeValues<(typeof Thermostat)['attributes']>;
         endpoint: MatterbridgeEndpoint;
     };
+    'Thermostat.setActiveScheduleRequest': {
+        command: 'setActiveScheduleRequest';
+        request: Thermostat.SetActiveScheduleRequest;
+        cluster: 'thermostat';
+        attributes: ClusterAttributeValues<(typeof Thermostat)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'step': CommandHandlerData<'FanControl.step'>;
     'FanControl.step': {
         command: 'step';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.5-dev-20260807-79a10b4",
+  "version": "3.10.5-dev-20260809-ffe76d7",
   "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.5-dev-20260807-79a10b4",
-    "@matterbridge/thread": "3.10.5-dev-20260807-79a10b4",
-    "@matterbridge/types": "3.10.5-dev-20260807-79a10b4",
-    "@matterbridge/utils": "3.10.5-dev-20260807-79a10b4",
+    "@matterbridge/dgram": "3.10.5-dev-20260809-ffe76d7",
+    "@matterbridge/thread": "3.10.5-dev-20260809-ffe76d7",
+    "@matterbridge/types": "3.10.5-dev-20260809-ffe76d7",
+    "@matterbridge/utils": "3.10.5-dev-20260809-ffe76d7",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.6.2",