matterbridge-dyson-robot 0.1.0

package/dist/endpoint-air-purifier.js

@@ -0,0 +1,97 @@
+// Matterbridge plugin for Dyson robot vacuum and air treatment devices
+// Copyright © 2025 Alexander Thoukydides
+import { FanControl, ResourceMonitoring } from 'matterbridge/matter/clusters';
+import { ActivatedCarbonFilterMonitoringServer, FanControlServer, HepaFilterMonitoringServer } from 'matterbridge/matter/behaviors';
+import { MatterbridgeOnOffServer } from 'matterbridge';
+// Create the On/Off cluster
+export function createOnOffClusterServer({ behaviors }) {
+    behaviors.require(MatterbridgeOnOffServer, {
+        // Variable attributes
+        onOff: false
+    });
+}
+// Create the Fan Control cluster
+export function createFanControlClusterServer({ behaviors }, options) {
+    const { directionSupport } = options;
+    let { rockSupport, windSupport } = options;
+    const features = [
+        FanControl.Feature.MultiSpeed,
+        FanControl.Feature.Auto
+    ];
+    if (directionSupport)
+        features.push(FanControl.Feature.AirflowDirection);
+    if (!rockSupport?.rockLeftRight && !rockSupport?.rockUpDown && !rockSupport?.rockRound)
+        rockSupport = undefined;
+    else
+        features.push(FanControl.Feature.Rocking);
+    if (!windSupport?.sleepWind && !windSupport?.naturalWind)
+        windSupport = undefined;
+    else
+        features.push(FanControl.Feature.Wind);
+    behaviors.require(FanControlServer.withFeatures(...features), {
+        // Constant attributes
+        rockSupport,
+        windSupport,
+        speedMax: 10,
+        fanModeSequence: FanControl.FanModeSequence.OffLowMedHighAuto,
+        // Variable attributes
+        fanMode: FanControl.FanMode.Off,
+        percentSetting: 0,
+        percentCurrent: 0,
+        speedSetting: 0,
+        speedCurrent: 0,
+        rockSetting: rockSupport && {},
+        windSetting: windSupport && {},
+        airflowDirection: directionSupport ? FanControl.AirflowDirection.Forward : undefined
+    });
+}
+// Create the HEPA Filter Monitoring cluster
+export function createHepaFilterMonitoringClusterServer({ behaviors }, options) {
+    const { features, replacementProductList } = makeFeaturesAndReplacements(options);
+    behaviors.require(HepaFilterMonitoringServer.withFeatures(...features), {
+        // Constant attributes
+        degradationDirection: ResourceMonitoring.DegradationDirection.Down,
+        replacementProductList,
+        // Variable attributes
+        condition: 0,
+        changeIndication: ResourceMonitoring.ChangeIndication.Ok,
+        inPlaceIndicator: true,
+        // Unsupported attributes
+        lastChangedTime: undefined
+    });
+}
+// Create the Activated Carbon Filter Monitoring cluster
+export function createActivatedCarbonFilterMonitoringClusterServer({ behaviors }, options) {
+    const { features, replacementProductList } = makeFeaturesAndReplacements(options);
+    behaviors.require(ActivatedCarbonFilterMonitoringServer.withFeatures(...features), {
+        // Constant attributes
+        degradationDirection: ResourceMonitoring.DegradationDirection.Down,
+        replacementProductList,
+        // Variable attributes
+        condition: 0,
+        changeIndication: ResourceMonitoring.ChangeIndication.Ok,
+        inPlaceIndicator: false,
+        // Unsupported attributes
+        lastChangedTime: undefined
+    });
+}
+// Prepare features and replacement products for a Filter Monitoring cluster
+function makeFeaturesAndReplacements(options) {
+    // Default features that are always supported
+    const features = [
+        ResourceMonitoring.Feature.Condition,
+        ResourceMonitoring.Feature.Warning
+    ];
+    let replacementProductList;
+    // Add a ReplacementProductList if filter part numbers were provided
+    const { filterPartNumbers } = options;
+    if (filterPartNumbers?.length) {
+        features.push(ResourceMonitoring.Feature.ReplacementProductList);
+        replacementProductList = filterPartNumbers.map(identifier => ({
+            productIdentifierType: ResourceMonitoring.ProductIdentifierType.Oem,
+            productIdentifierValue: identifier.substring(0, 20)
+        }));
+    }
+    return { features, replacementProductList };
+}
+//# sourceMappingURL=endpoint-air-purifier.js.map

package/dist/endpoint-air-purifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-air-purifier.js","sourceRoot":"","sources":["../src/endpoint-air-purifier.ts"],"names":[],"mappings":"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"}

package/dist/endpoint-air-quality.d.ts

@@ -0,0 +1,11 @@
+import { Endpoint } from 'matterbridge/matter';
+export declare function createAirQualityClusterServer({ behaviors }: Endpoint): void;
+export declare function createTemperatureMeasurementClusterServer({ behaviors }: Endpoint): void;
+export declare function createRelativeHumidityMeasurementClusterServer({ behaviors }: Endpoint): void;
+export declare function createTotalVolatileOrganicCompoundsConcentrationMeasurementClusterServer({ behaviors }: Endpoint): void;
+export declare function createCarbonDioxideConcentrationMeasurementClusterServer({ behaviors }: Endpoint): void;
+export declare function createNitrogenDioxideConcentrationMeasurementClusterServer({ behaviors }: Endpoint): void;
+export declare function createFormaldehydeConcentrationMeasurementClusterServer({ behaviors }: Endpoint): void;
+export declare function createPm25ConcentrationMeasurementClusterServer({ behaviors }: Endpoint): void;
+export declare function createPm10ConcentrationMeasurementClusterServer({ behaviors }: Endpoint): void;
+//# sourceMappingURL=endpoint-air-quality.d.ts.map

package/dist/endpoint-air-quality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-air-quality.d.ts","sourceRoot":"","sources":["../src/endpoint-air-quality.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAG/C,wBAAgB,6BAA6B,CAAC,EAAE,SAAS,EAAE,EAAE,QAAQ,GAAG,IAAI,CAU3E;AAGD,wBAAgB,yCAAyC,CAAC,EAAE,SAAS,EAAE,EAAE,QAAQ,GAAG,IAAI,CASvF;AAGD,wBAAgB,8CAA8C,CAAC,EAAE,SAAS,EAAE,EAAE,QAAQ,GAAG,IAAI,CAS5F;AAGD,wBAAgB,wEAAwE,CAAC,EAAE,SAAS,EAAE,EAAE,QAAQ,GAAG,IAAI,CAWtH;AAGD,wBAAgB,wDAAwD,CAAC,EAAE,SAAS,EAAE,EAAE,QAAQ,GAAG,IAAI,CAatG;AAGD,wBAAgB,0DAA0D,CAAC,EAAE,SAAS,EAAE,EAAE,QAAQ,GAAG,IAAI,CAWxG;AAGD,wBAAgB,uDAAuD,CAAC,EAAE,SAAS,EAAE,EAAE,QAAQ,GAAG,IAAI,CAarG;AAGD,wBAAgB,+CAA+C,CAAC,EAAE,SAAS,EAAE,EAAE,QAAQ,GAAG,IAAI,CAa7F;AAGD,wBAAgB,+CAA+C,CAAC,EAAE,SAAS,EAAE,EAAE,QAAQ,GAAG,IAAI,CAa7F"}

package/dist/endpoint-air-quality.js

@@ -0,0 +1,104 @@
+// Matterbridge plugin for Dyson robot vacuum and air treatment devices
+// Copyright © 2025 Alexander Thoukydides
+import { AirQuality, ConcentrationMeasurement } from 'matterbridge/matter/clusters';
+import { AirQualityServer, CarbonDioxideConcentrationMeasurementServer, FormaldehydeConcentrationMeasurementServer, NitrogenDioxideConcentrationMeasurementServer, Pm10ConcentrationMeasurementServer, Pm25ConcentrationMeasurementServer, RelativeHumidityMeasurementServer, TemperatureMeasurementServer, TotalVolatileOrganicCompoundsConcentrationMeasurementServer } from 'matterbridge/matter/behaviors';
+// Create the Air Quality cluster
+export function createAirQualityClusterServer({ behaviors }) {
+    behaviors.require(AirQualityServer.withFeatures(AirQuality.Feature.Fair, AirQuality.Feature.Moderate, AirQuality.Feature.VeryPoor, AirQuality.Feature.ExtremelyPoor), {
+        // Variable attributes
+        airQuality: AirQuality.AirQualityEnum.Unknown
+    });
+}
+// Create the Temperature Measurement cluster
+export function createTemperatureMeasurementClusterServer({ behaviors }) {
+    behaviors.require(TemperatureMeasurementServer, {
+        // Constant attributes
+        minMeasuredValue: -30.15 * 100, // centi-°C
+        maxMeasuredValue: 79.85 * 100, // centi-°C
+        tolerance: 0.50 * 100, // centi-°C (5 deci-K steps)
+        // Variable attributes
+        measuredValue: null
+    });
+}
+// Create the Relative Humidity Measurement cluster
+export function createRelativeHumidityMeasurementClusterServer({ behaviors }) {
+    behaviors.require(RelativeHumidityMeasurementServer, {
+        // Constant attributes
+        minMeasuredValue: 0.00 * 100, // centi-%
+        maxMeasuredValue: 100.00 * 100, // centi-%
+        tolerance: 1.00 * 100, // centi-% (Dyson measures %)
+        // Variable attributes
+        measuredValue: null
+    });
+}
+// Create the Total Volatile Organic Compounds Concentration Measurement cluster
+export function createTotalVolatileOrganicCompoundsConcentrationMeasurementClusterServer({ behaviors }) {
+    behaviors.require(TotalVolatileOrganicCompoundsConcentrationMeasurementServer.withFeatures(ConcentrationMeasurement.Feature.LevelIndication, ConcentrationMeasurement.Feature.MediumLevel, ConcentrationMeasurement.Feature.CriticalLevel), {
+        // Constant attributes
+        measurementMedium: ConcentrationMeasurement.MeasurementMedium.Air,
+        // Variable attributes
+        levelValue: ConcentrationMeasurement.LevelValue.Unknown
+    });
+}
+// Create the Carbon Dioxide Concentration Measurement cluster
+export function createCarbonDioxideConcentrationMeasurementClusterServer({ behaviors }) {
+    behaviors.require(CarbonDioxideConcentrationMeasurementServer.withFeatures(ConcentrationMeasurement.Feature.NumericMeasurement), {
+        // Constant attributes
+        minMeasuredValue: 0, // ppm
+        maxMeasuredValue: 9999, // ppm
+        measurementMedium: ConcentrationMeasurement.MeasurementMedium.Air,
+        measurementUnit: ConcentrationMeasurement.MeasurementUnit.Ppm,
+        uncertainty: 1,
+        // Variable attributes
+        measuredValue: null
+    });
+}
+// Create the Nitrogen Dioxide Concentration Measurement cluster
+export function createNitrogenDioxideConcentrationMeasurementClusterServer({ behaviors }) {
+    behaviors.require(NitrogenDioxideConcentrationMeasurementServer.withFeatures(ConcentrationMeasurement.Feature.LevelIndication, ConcentrationMeasurement.Feature.MediumLevel, ConcentrationMeasurement.Feature.CriticalLevel), {
+        // Constant attributes
+        measurementMedium: ConcentrationMeasurement.MeasurementMedium.Air,
+        // Variable attributes
+        levelValue: ConcentrationMeasurement.LevelValue.Unknown
+    });
+}
+// Create the Formaldehyde Concentration Measurement cluster
+export function createFormaldehydeConcentrationMeasurementClusterServer({ behaviors }) {
+    behaviors.require(FormaldehydeConcentrationMeasurementServer.withFeatures(ConcentrationMeasurement.Feature.NumericMeasurement), {
+        // Constant attributes
+        minMeasuredValue: 0, // µg/m³
+        maxMeasuredValue: 999, // µg/m³ (99 for v1 sensors)
+        measurementMedium: ConcentrationMeasurement.MeasurementMedium.Air,
+        measurementUnit: ConcentrationMeasurement.MeasurementUnit.Ugm3,
+        uncertainty: 1,
+        // Variable attributes
+        measuredValue: null
+    });
+}
+// Create the PM2.5 Concentration Measurement cluster
+export function createPm25ConcentrationMeasurementClusterServer({ behaviors }) {
+    behaviors.require(Pm25ConcentrationMeasurementServer.withFeatures(ConcentrationMeasurement.Feature.NumericMeasurement), {
+        // Constant attributes
+        minMeasuredValue: 0, // µg/m³
+        maxMeasuredValue: 999, // µg/m³ (149 for v1 sensors)
+        measurementMedium: ConcentrationMeasurement.MeasurementMedium.Air,
+        measurementUnit: ConcentrationMeasurement.MeasurementUnit.Ugm3,
+        uncertainty: 1,
+        // Variable attributes
+        measuredValue: null
+    });
+}
+// Create the PM10 Concentration Measurement cluster
+export function createPm10ConcentrationMeasurementClusterServer({ behaviors }) {
+    behaviors.require(Pm10ConcentrationMeasurementServer.withFeatures(ConcentrationMeasurement.Feature.NumericMeasurement), {
+        // Constant attributes
+        minMeasuredValue: 0, // µg/m³
+        maxMeasuredValue: 999, // µg/m³ (149 for v1 sensors)
+        measurementMedium: ConcentrationMeasurement.MeasurementMedium.Air,
+        measurementUnit: ConcentrationMeasurement.MeasurementUnit.Ugm3,
+        uncertainty: 1,
+        // Variable attributes
+        measuredValue: null
+    });
+}
+//# sourceMappingURL=endpoint-air-quality.js.map

package/dist/endpoint-air-quality.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-air-quality.js","sourceRoot":"","sources":["../src/endpoint-air-quality.ts"],"names":[],"mappings":"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"}

package/dist/endpoint-air-thermostat.d.ts

@@ -0,0 +1,358 @@
+import { Endpoint, MaybePromise } from 'matterbridge/matter';
+import { Thermostat } from 'matterbridge/matter/clusters';
+import { ThermostatServer } from 'matterbridge/matter/behaviors';
+declare const ThermostatServerAir_base: import("matterbridge/matter").ClusterBehavior.Type<import("matterbridge").ClusterComposer.WithFeatures<import("matterbridge").ClusterType.Of<{
+    readonly id: 513;
+    readonly name: "Thermostat";
+    readonly revision: 8;
+    readonly features: {
+        readonly heating: import("matterbridge").BitFlag;
+        readonly cooling: import("matterbridge").BitFlag;
+        readonly occupancy: import("matterbridge").BitFlag;
+        readonly scheduleConfiguration: import("matterbridge").BitFlag;
+        readonly setback: import("matterbridge").BitFlag;
+        readonly autoMode: import("matterbridge").BitFlag;
+        readonly localTemperatureNotExposed: import("matterbridge").BitFlag;
+        readonly matterScheduleConfiguration: import("matterbridge").BitFlag;
+        readonly presets: import("matterbridge").BitFlag;
+    };
+    readonly attributes: {
+        readonly localTemperature: import("matterbridge").Attribute<number | null, any>;
+        readonly outdoorTemperature: import("matterbridge").OptionalAttribute<number | null, any>;
+        readonly hvacSystemTypeConfiguration: import("matterbridge").OptionalWritableAttribute<import("matterbridge").TypeFromPartialBitSchema<{
+            coolingStage: import("matterbridge").BitField;
+            heatingStage: import("matterbridge").BitField;
+            heatingIsHeatPump: import("matterbridge").BitFlag;
+            heatingUsesFuel: import("matterbridge").BitFlag;
+        }>, any>;
+        readonly remoteSensing: import("matterbridge").OptionalWritableAttribute<import("matterbridge").TypeFromPartialBitSchema<{
+            localTemperature: import("matterbridge").BitFlag;
+            outdoorTemperature: import("matterbridge").BitFlag;
+            occupancy: import("matterbridge").BitFlag;
+        }>, any>;
+        readonly controlSequenceOfOperation: import("matterbridge").WritableAttribute<Thermostat.ControlSequenceOfOperation, any>;
+        readonly systemMode: import("matterbridge").WritableAttribute<Thermostat.SystemMode, any>;
+        readonly temperatureSetpointHold: import("matterbridge").OptionalWritableAttribute<Thermostat.TemperatureSetpointHold, any>;
+        readonly temperatureSetpointHoldDuration: import("matterbridge").OptionalWritableAttribute<number | null, any>;
+        readonly thermostatProgrammingOperationMode: import("matterbridge").OptionalWritableAttribute<import("matterbridge").TypeFromPartialBitSchema<{
+            scheduleActive: import("matterbridge").BitFlag;
+            autoRecovery: import("matterbridge").BitFlag;
+            economy: import("matterbridge").BitFlag;
+        }>, any>;
+        readonly thermostatRunningState: import("matterbridge").OptionalAttribute<import("matterbridge").TypeFromPartialBitSchema<{
+            heat: import("matterbridge").BitFlag;
+            cool: import("matterbridge").BitFlag;
+            fan: import("matterbridge").BitFlag;
+            heatStage2: import("matterbridge").BitFlag;
+            coolStage2: import("matterbridge").BitFlag;
+            fanStage2: import("matterbridge").BitFlag;
+            fanStage3: import("matterbridge").BitFlag;
+        }>, any>;
+        readonly setpointChangeSource: import("matterbridge").OptionalAttribute<Thermostat.SetpointChangeSource, any>;
+        readonly setpointChangeAmount: import("matterbridge").OptionalAttribute<number | null, any>;
+        readonly setpointChangeSourceTimestamp: import("matterbridge").OptionalAttribute<number, any>;
+        readonly emergencyHeatDelta: import("matterbridge").OptionalWritableAttribute<number, any>;
+        readonly acType: import("matterbridge").OptionalWritableAttribute<Thermostat.AcType, any>;
+        readonly acCapacity: import("matterbridge").OptionalWritableAttribute<number, any>;
+        readonly acRefrigerantType: import("matterbridge").OptionalWritableAttribute<Thermostat.AcRefrigerantType, any>;
+        readonly acCompressorType: import("matterbridge").OptionalWritableAttribute<Thermostat.AcCompressorType, any>;
+        readonly acErrorCode: import("matterbridge").OptionalWritableAttribute<import("matterbridge").TypeFromPartialBitSchema<{
+            compressorFail: import("matterbridge").BitFlag;
+            roomSensorFail: import("matterbridge").BitFlag;
+            outdoorSensorFail: import("matterbridge").BitFlag;
+            coilSensorFail: import("matterbridge").BitFlag;
+            fanFail: import("matterbridge").BitFlag;
+        }>, any>;
+        readonly acLouverPosition: import("matterbridge").OptionalWritableAttribute<Thermostat.AcLouverPosition, any>;
+        readonly acCoilTemperature: import("matterbridge").OptionalAttribute<number | null, any>;
+        readonly acCapacityFormat: import("matterbridge").OptionalWritableAttribute<Thermostat.AcCapacityFormat, any>;
+        readonly setpointHoldExpiryTimestamp: import("matterbridge").OptionalAttribute<number | null, any>;
+    };
+    readonly commands: {
+        readonly setpointRaiseLower: import("matterbridge").Command<import("matterbridge").TypeFromFields<{
+            mode: import("matterbridge").FieldType<Thermostat.SetpointRaiseLowerMode>;
+            amount: import("matterbridge").FieldType<number>;
+        }>, void, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly occupancy: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly occupancy: import("matterbridge").Attribute<import("matterbridge").TypeFromPartialBitSchema<{
+                    occupied: import("matterbridge").BitFlag;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly heating: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly absMinHeatSetpointLimit: import("matterbridge").OptionalFixedAttribute<number, any>;
+                readonly absMaxHeatSetpointLimit: import("matterbridge").OptionalFixedAttribute<number, any>;
+                readonly piHeatingDemand: import("matterbridge").OptionalAttribute<number, any>;
+                readonly occupiedHeatingSetpoint: import("matterbridge").WritableAttribute<number, any>;
+                readonly minHeatSetpointLimit: import("matterbridge").OptionalWritableAttribute<number, any>;
+                readonly maxHeatSetpointLimit: import("matterbridge").OptionalWritableAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly cooling: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly absMinCoolSetpointLimit: import("matterbridge").OptionalFixedAttribute<number, any>;
+                readonly absMaxCoolSetpointLimit: import("matterbridge").OptionalFixedAttribute<number, any>;
+                readonly piCoolingDemand: import("matterbridge").OptionalAttribute<number, any>;
+                readonly occupiedCoolingSetpoint: import("matterbridge").WritableAttribute<number, any>;
+                readonly minCoolSetpointLimit: import("matterbridge").OptionalWritableAttribute<number, any>;
+                readonly maxCoolSetpointLimit: import("matterbridge").OptionalWritableAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly localTemperatureNotExposed: false;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly localTemperatureCalibration: import("matterbridge").OptionalWritableAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly cooling: true;
+            readonly occupancy: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly unoccupiedCoolingSetpoint: import("matterbridge").WritableAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly heating: true;
+            readonly occupancy: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly unoccupiedHeatingSetpoint: import("matterbridge").WritableAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly autoMode: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly minSetpointDeadBand: import("matterbridge").WritableAttribute<number, any>;
+                readonly thermostatRunningMode: import("matterbridge").OptionalAttribute<Thermostat.ThermostatRunningMode, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly scheduleConfiguration: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly startOfWeek: import("matterbridge").FixedAttribute<Thermostat.StartOfWeek, any>;
+                readonly numberOfWeeklyTransitions: import("matterbridge").FixedAttribute<number, any>;
+                readonly numberOfDailyTransitions: import("matterbridge").FixedAttribute<number, any>;
+            };
+            readonly commands: {
+                readonly setWeeklySchedule: import("matterbridge").Command<import("matterbridge").TypeFromFields<{
+                    numberOfTransitionsForSequence: import("matterbridge").FieldType<number>;
+                    dayOfWeekForSequence: import("matterbridge").FieldType<import("matterbridge").TypeFromPartialBitSchema<{
+                        sunday: import("matterbridge").BitFlag;
+                        monday: import("matterbridge").BitFlag;
+                        tuesday: import("matterbridge").BitFlag;
+                        wednesday: import("matterbridge").BitFlag;
+                        thursday: import("matterbridge").BitFlag;
+                        friday: import("matterbridge").BitFlag;
+                        saturday: import("matterbridge").BitFlag;
+                        away: import("matterbridge").BitFlag;
+                    }>>;
+                    modeForSequence: import("matterbridge").FieldType<import("matterbridge").TypeFromPartialBitSchema<{
+                        heatSetpointPresent: import("matterbridge").BitFlag;
+                        coolSetpointPresent: import("matterbridge").BitFlag;
+                    }>>;
+                    transitions: import("matterbridge").FieldType<import("matterbridge").TypeFromFields<{
+                        transitionTime: import("matterbridge").FieldType<number>;
+                        heatSetpoint: import("matterbridge").FieldType<number | null>;
+                        coolSetpoint: import("matterbridge").FieldType<number | null>;
+                    }>[]>;
+                }>, void, any>;
+                readonly getWeeklySchedule: import("matterbridge").Command<import("matterbridge").TypeFromFields<{
+                    daysToReturn: import("matterbridge").FieldType<import("matterbridge").TypeFromPartialBitSchema<{
+                        sunday: import("matterbridge").BitFlag;
+                        monday: import("matterbridge").BitFlag;
+                        tuesday: import("matterbridge").BitFlag;
+                        wednesday: import("matterbridge").BitFlag;
+                        thursday: import("matterbridge").BitFlag;
+                        friday: import("matterbridge").BitFlag;
+                        saturday: import("matterbridge").BitFlag;
+                        away: import("matterbridge").BitFlag;
+                    }>>;
+                    modeToReturn: import("matterbridge").FieldType<import("matterbridge").TypeFromPartialBitSchema<{
+                        heatSetpointPresent: import("matterbridge").BitFlag;
+                        coolSetpointPresent: import("matterbridge").BitFlag;
+                    }>>;
+                }>, import("matterbridge").TypeFromFields<{
+                    numberOfTransitionsForSequence: import("matterbridge").FieldType<number>;
+                    dayOfWeekForSequence: import("matterbridge").FieldType<import("matterbridge").TypeFromPartialBitSchema<{
+                        sunday: import("matterbridge").BitFlag;
+                        monday: import("matterbridge").BitFlag;
+                        tuesday: import("matterbridge").BitFlag;
+                        wednesday: import("matterbridge").BitFlag;
+                        thursday: import("matterbridge").BitFlag;
+                        friday: import("matterbridge").BitFlag;
+                        saturday: import("matterbridge").BitFlag;
+                        away: import("matterbridge").BitFlag;
+                    }>>;
+                    modeForSequence: import("matterbridge").FieldType<import("matterbridge").TypeFromPartialBitSchema<{
+                        heatSetpointPresent: import("matterbridge").BitFlag;
+                        coolSetpointPresent: import("matterbridge").BitFlag;
+                    }>>;
+                    transitions: import("matterbridge").FieldType<import("matterbridge").TypeFromFields<{
+                        transitionTime: import("matterbridge").FieldType<number>;
+                        heatSetpoint: import("matterbridge").FieldType<number | null>;
+                        coolSetpoint: import("matterbridge").FieldType<number | null>;
+                    }>[]>;
+                }>, any>;
+                readonly clearWeeklySchedule: import("matterbridge").Command<void, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly setback: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly occupiedSetback: import("matterbridge").WritableAttribute<number | null, any>;
+                readonly occupiedSetbackMin: import("matterbridge").FixedAttribute<number | null, any>;
+                readonly occupiedSetbackMax: import("matterbridge").FixedAttribute<number | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly setback: true;
+            readonly occupancy: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly unoccupiedSetback: import("matterbridge").WritableAttribute<number | null, any>;
+                readonly unoccupiedSetbackMin: import("matterbridge").FixedAttribute<number | null, any>;
+                readonly unoccupiedSetbackMax: import("matterbridge").FixedAttribute<number | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly presets: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly presetTypes: import("matterbridge").FixedAttribute<import("matterbridge").TypeFromFields<{
+                    presetScenario: import("matterbridge").FieldType<Thermostat.PresetScenario>;
+                    numberOfPresets: import("matterbridge").FieldType<number>;
+                    presetTypeFeatures: import("matterbridge").FieldType<import("matterbridge").TypeFromPartialBitSchema<{
+                        automatic: import("matterbridge").BitFlag;
+                        supportsNames: import("matterbridge").BitFlag;
+                    }>>;
+                }>[], any>;
+                readonly numberOfPresets: import("matterbridge").FixedAttribute<number, any>;
+                readonly activePresetHandle: import("matterbridge").Attribute<Uint8Array<ArrayBufferLike> | null, any>;
+                readonly presets: import("matterbridge").WritableAttribute<import("matterbridge").TypeFromFields<{
+                    presetHandle: import("matterbridge").FieldType<Uint8Array<ArrayBufferLike> | null>;
+                    presetScenario: import("matterbridge").FieldType<Thermostat.PresetScenario>;
+                    name: import("matterbridge").OptionalFieldType<string | null>;
+                    coolingSetpoint: import("matterbridge").OptionalFieldType<number>;
+                    heatingSetpoint: import("matterbridge").OptionalFieldType<number>;
+                    builtIn: import("matterbridge").FieldType<boolean | null>;
+                }>[], any>;
+            };
+            readonly commands: {
+                readonly setActivePresetRequest: import("matterbridge").Command<import("matterbridge").TypeFromFields<{
+                    presetHandle: import("matterbridge").FieldType<Uint8Array<ArrayBufferLike> | null>;
+                }>, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly matterScheduleConfiguration: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly scheduleTypes: import("matterbridge").FixedAttribute<import("matterbridge").TypeFromFields<{
+                    systemMode: import("matterbridge").FieldType<Thermostat.SystemMode>;
+                    numberOfSchedules: import("matterbridge").FieldType<number>;
+                    scheduleTypeFeatures: import("matterbridge").FieldType<import("matterbridge").TypeFromPartialBitSchema<{
+                        supportsPresets: import("matterbridge").BitFlag;
+                        supportsSetpoints: import("matterbridge").BitFlag;
+                        supportsNames: import("matterbridge").BitFlag;
+                        supportsOff: import("matterbridge").BitFlag;
+                    }>>;
+                }>[], any>;
+                readonly numberOfSchedules: import("matterbridge").FixedAttribute<number, any>;
+                readonly numberOfScheduleTransitions: import("matterbridge").FixedAttribute<number, any>;
+                readonly numberOfScheduleTransitionPerDay: import("matterbridge").FixedAttribute<number | null, any>;
+                readonly activeScheduleHandle: import("matterbridge").Attribute<Uint8Array<ArrayBufferLike> | null, any>;
+                readonly schedules: import("matterbridge").WritableAttribute<import("matterbridge").TypeFromFields<{
+                    scheduleHandle: import("matterbridge").FieldType<Uint8Array<ArrayBufferLike> | null>;
+                    systemMode: import("matterbridge").FieldType<Thermostat.SystemMode>;
+                    name: import("matterbridge").OptionalFieldType<string>;
+                    presetHandle: import("matterbridge").OptionalFieldType<Uint8Array<ArrayBufferLike>>;
+                    transitions: import("matterbridge").FieldType<import("matterbridge").TypeFromFields<{
+                        dayOfWeek: import("matterbridge").FieldType<import("matterbridge").TypeFromPartialBitSchema<{
+                            sunday: import("matterbridge").BitFlag;
+                            monday: import("matterbridge").BitFlag;
+                            tuesday: import("matterbridge").BitFlag;
+                            wednesday: import("matterbridge").BitFlag;
+                            thursday: import("matterbridge").BitFlag;
+                            friday: import("matterbridge").BitFlag;
+                            saturday: import("matterbridge").BitFlag;
+                            away: import("matterbridge").BitFlag;
+                        }>>;
+                        transitionTime: import("matterbridge").FieldType<number>;
+                        presetHandle: import("matterbridge").OptionalFieldType<Uint8Array<ArrayBufferLike>>;
+                        systemMode: import("matterbridge").OptionalFieldType<Thermostat.SystemMode>;
+                        coolingSetpoint: import("matterbridge").OptionalFieldType<number>;
+                        heatingSetpoint: import("matterbridge").OptionalFieldType<number>;
+                    }>[]>;
+                    builtIn: import("matterbridge").FieldType<boolean | null>;
+                }>[], any>;
+            };
+            readonly commands: {
+                readonly setActiveScheduleRequest: import("matterbridge").Command<import("matterbridge").TypeFromFields<{
+                    scheduleHandle: import("matterbridge").FieldType<Uint8Array<ArrayBufferLike>>;
+                }>, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly autoMode: true;
+            readonly heating: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly autoMode: true;
+            readonly cooling: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly heating: false;
+            readonly cooling: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [Thermostat.Feature.Heating]>, typeof ThermostatServer, import("matterbridge/matter/behaviors").ThermostatInterface>;
+export declare class ThermostatServerAir extends ThermostatServerAir_base {
+    setpointRaiseLower(request: Thermostat.SetpointRaiseLowerRequest): MaybePromise;
+}
+export declare function createThermostatClusterServer({ behaviors }: Endpoint): void;
+export {};
+//# sourceMappingURL=endpoint-air-thermostat.d.ts.map

package/dist/endpoint-air-thermostat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-air-thermostat.d.ts","sourceRoot":"","sources":["../src/endpoint-air-thermostat.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIjE,qBAAa,mBAAoB,SAAQ,wBAExC;IAEY,kBAAkB,CAAC,OAAO,EAAE,UAAU,CAAC,yBAAyB,GAAG,YAAY;CAI3F;AAGD,wBAAgB,6BAA6B,CAAC,EAAE,SAAS,EAAE,EAAE,QAAQ,GAAG,IAAI,CAqD3E"}