@matter/types 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/cjs/clusters/thermostat.js

@@ -0,0 +1,1371 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var thermostat_exports = {};
+__export(thermostat_exports, {
+  Thermostat: () => Thermostat,
+  ThermostatCluster: () => ThermostatCluster
+});
+module.exports = __toCommonJS(thermostat_exports);
+var import_MutableCluster = require("../cluster/mutation/MutableCluster.js");
+var import_Cluster = require("../cluster/Cluster.js");
+var import_occupancy_sensing = require("./occupancy-sensing.js");
+var import_TlvNumber = require("../tlv/TlvNumber.js");
+var import_BitmapSchema = require("../schema/BitmapSchema.js");
+var import_model = require("#model");
+var import_TlvObject = require("../tlv/TlvObject.js");
+var import_TlvArray = require("../tlv/TlvArray.js");
+var import_TlvNullable = require("../tlv/TlvNullable.js");
+var import_TlvNoArguments = require("../tlv/TlvNoArguments.js");
+var import_ClusterRegistry = require("../cluster/ClusterRegistry.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var Thermostat;
+((Thermostat2) => {
+  let Feature;
+  ((Feature2) => {
+    Feature2["Heating"] = "Heating";
+    Feature2["Cooling"] = "Cooling";
+    Feature2["Occupancy"] = "Occupancy";
+    Feature2["ScheduleConfiguration"] = "ScheduleConfiguration";
+    Feature2["Setback"] = "Setback";
+    Feature2["AutoMode"] = "AutoMode";
+    Feature2["LocalTemperatureNotExposed"] = "LocalTemperatureNotExposed";
+  })(Feature = Thermostat2.Feature || (Thermostat2.Feature = {}));
+  let ThermostatRunningMode;
+  ((ThermostatRunningMode2) => {
+    ThermostatRunningMode2[ThermostatRunningMode2["Off"] = 0] = "Off";
+    ThermostatRunningMode2[ThermostatRunningMode2["Cool"] = 3] = "Cool";
+    ThermostatRunningMode2[ThermostatRunningMode2["Heat"] = 4] = "Heat";
+  })(ThermostatRunningMode = Thermostat2.ThermostatRunningMode || (Thermostat2.ThermostatRunningMode = {}));
+  let StartOfWeek;
+  ((StartOfWeek2) => {
+    StartOfWeek2[StartOfWeek2["Sunday"] = 0] = "Sunday";
+    StartOfWeek2[StartOfWeek2["Monday"] = 1] = "Monday";
+    StartOfWeek2[StartOfWeek2["Tuesday"] = 2] = "Tuesday";
+    StartOfWeek2[StartOfWeek2["Wednesday"] = 3] = "Wednesday";
+    StartOfWeek2[StartOfWeek2["Thursday"] = 4] = "Thursday";
+    StartOfWeek2[StartOfWeek2["Friday"] = 5] = "Friday";
+    StartOfWeek2[StartOfWeek2["Saturday"] = 6] = "Saturday";
+  })(StartOfWeek = Thermostat2.StartOfWeek || (Thermostat2.StartOfWeek = {}));
+  Thermostat2.ScheduleDayOfWeek = {
+    /**
+     * Sunday
+     */
+    sunday: (0, import_BitmapSchema.BitFlag)(0),
+    /**
+     * Monday
+     */
+    monday: (0, import_BitmapSchema.BitFlag)(1),
+    /**
+     * Tuesday
+     */
+    tuesday: (0, import_BitmapSchema.BitFlag)(2),
+    /**
+     * Wednesday
+     */
+    wednesday: (0, import_BitmapSchema.BitFlag)(3),
+    /**
+     * Thursday
+     */
+    thursday: (0, import_BitmapSchema.BitFlag)(4),
+    /**
+     * Friday
+     */
+    friday: (0, import_BitmapSchema.BitFlag)(5),
+    /**
+     * Saturday
+     */
+    saturday: (0, import_BitmapSchema.BitFlag)(6),
+    /**
+     * Away or Vacation
+     */
+    away: (0, import_BitmapSchema.BitFlag)(7)
+  };
+  Thermostat2.ScheduleMode = {
+    /**
+     * Adjust Heat Setpoint
+     */
+    heatSetpointPresent: (0, import_BitmapSchema.BitFlag)(0),
+    /**
+     * Adjust Cool Setpoint
+     */
+    coolSetpointPresent: (0, import_BitmapSchema.BitFlag)(1)
+  };
+  Thermostat2.TlvWeeklyScheduleTransition = (0, import_TlvObject.TlvObject)({
+    /**
+     * This field shall represent the start time of the schedule transition during the associated day. The time
+     * will be represented by a 16 bits unsigned integer to designate the minutes since midnight. For example, 6am
+     * will be represented by 360 minutes since midnight and 11:30pm will be represented by 1410 minutes since
+     * midnight.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.8.24.1
+     */
+    transitionTime: (0, import_TlvObject.TlvField)(0, import_TlvNumber.TlvUInt16.bound({ max: 1439 })),
+    /**
+     * This field shall represent the heat setpoint to be applied at this associated transition start time.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.8.24.2
+     */
+    heatSetpoint: (0, import_TlvObject.TlvField)(1, (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvInt16)),
+    /**
+     * This field shall represent the cool setpoint to be applied at this associated transition start time.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.8.24.3
+     */
+    coolSetpoint: (0, import_TlvObject.TlvField)(2, (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvInt16))
+  });
+  Thermostat2.TlvSetWeeklyScheduleRequest = (0, import_TlvObject.TlvObject)({
+    /**
+     * This field shall indicate how many individual transitions to expect for this sequence of commands. If a
+     * device supports more than 10 transitions in its schedule they can send this by sending more than 1 “Set
+     * Weekly Schedule” command, each containing the separate information that the device needs to set.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.10.4.1
+     */
+    numberOfTransitionsForSequence: (0, import_TlvObject.TlvField)(0, import_TlvNumber.TlvUInt8),
+    /**
+     * This field shall represent the day of the week at which all the transitions within the payload of the
+     * command SHOULD be associated to. This field is a bitmap and therefore the associated setpoint could overlap
+     * onto multiple days (you could set one transition time for all “week days” or whatever combination of days
+     * the implementation requests).
+     *
+     * Each setpoint transition will begin with the day of week for this transition. There can be up to 10
+     * transitions for each command.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.10.4.2
+     */
+    dayOfWeekForSequence: (0, import_TlvObject.TlvField)(1, (0, import_TlvNumber.TlvBitmap)(import_TlvNumber.TlvUInt8, Thermostat2.ScheduleDayOfWeek)),
+    /**
+     * This field shall indicate how the application decodes the setpoint fields of each transition in the
+     * Transitions list.
+     *
+     * If the HeatSetpointPresent bit is On, the HeatSetpoint field shall NOT be null in every entry of the
+     * Transitions list.
+     *
+     * If the HeatSetpointPresent bit is Off, the HeatSetpoint field shall be null in every entry of the
+     * Transitions list.
+     *
+     * If the CoolSetpointPresent bit is On, the CoolSetpoint field shall NOT be null in every entry of the
+     * Transitions list.
+     *
+     * If the CoolSetpointPresent bit is Off, the CoolSetpoint field shall be null in every entry of the
+     * Transitions list.
+     *
+     * At least one of the bits in the Mode For Sequence byte shall be on.
+     *
+     * Both bits must be respected, even if the HEAT or COOL feature is not supported, to ensure the command is
+     * decoded and handled correctly.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.10.4.3
+     */
+    modeForSequence: (0, import_TlvObject.TlvField)(2, (0, import_TlvNumber.TlvBitmap)(import_TlvNumber.TlvUInt8, Thermostat2.ScheduleMode)),
+    /**
+     * This field shall contain the list of setpoint transitions used to update the specified daily schedules
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.10.4.4
+     */
+    transitions: (0, import_TlvObject.TlvField)(3, (0, import_TlvArray.TlvArray)(Thermostat2.TlvWeeklyScheduleTransition, { maxLength: 10 }))
+  });
+  Thermostat2.TlvGetWeeklyScheduleRequest = (0, import_TlvObject.TlvObject)({
+    /**
+     * This field shall indicate the number of days the client would like to return the setpoint values for and
+     * could be any combination of single days or the entire week.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.10.5.1
+     */
+    daysToReturn: (0, import_TlvObject.TlvField)(0, (0, import_TlvNumber.TlvBitmap)(import_TlvNumber.TlvUInt8, Thermostat2.ScheduleDayOfWeek)),
+    /**
+     * This field shall indicate the mode the client would like to return the set point values for and could be any
+     * combination of heat only, cool only or heat & cool.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.10.5.2
+     */
+    modeToReturn: (0, import_TlvObject.TlvField)(1, (0, import_TlvNumber.TlvBitmap)(import_TlvNumber.TlvUInt8, Thermostat2.ScheduleMode))
+  });
+  Thermostat2.TlvGetWeeklyScheduleResponse = (0, import_TlvObject.TlvObject)({
+    numberOfTransitionsForSequence: (0, import_TlvObject.TlvField)(0, import_TlvNumber.TlvUInt8),
+    dayOfWeekForSequence: (0, import_TlvObject.TlvField)(1, (0, import_TlvNumber.TlvBitmap)(import_TlvNumber.TlvUInt8, Thermostat2.ScheduleDayOfWeek)),
+    modeForSequence: (0, import_TlvObject.TlvField)(2, (0, import_TlvNumber.TlvBitmap)(import_TlvNumber.TlvUInt8, Thermostat2.ScheduleMode)),
+    transitions: (0, import_TlvObject.TlvField)(3, (0, import_TlvArray.TlvArray)(Thermostat2.TlvWeeklyScheduleTransition, { maxLength: 10 }))
+  });
+  Thermostat2.RemoteSensing = {
+    /**
+     * Calculated Local Temperature is derived from a remote node
+     */
+    localTemperature: (0, import_BitmapSchema.BitFlag)(0),
+    /**
+     * OutdoorTemperature is derived from a remote node
+     *
+     * This bit shall be supported if the OutdoorTemperature attribute is supported.
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.8.9.1
+     */
+    outdoorTemperature: (0, import_BitmapSchema.BitFlag)(1),
+    /**
+     * Occupancy is derived from a remote node
+     */
+    occupancy: (0, import_BitmapSchema.BitFlag)(2)
+  };
+  let ControlSequenceOfOperation;
+  ((ControlSequenceOfOperation2) => {
+    ControlSequenceOfOperation2[ControlSequenceOfOperation2["CoolingOnly"] = 0] = "CoolingOnly";
+    ControlSequenceOfOperation2[ControlSequenceOfOperation2["CoolingWithReheat"] = 1] = "CoolingWithReheat";
+    ControlSequenceOfOperation2[ControlSequenceOfOperation2["HeatingOnly"] = 2] = "HeatingOnly";
+    ControlSequenceOfOperation2[ControlSequenceOfOperation2["HeatingWithReheat"] = 3] = "HeatingWithReheat";
+    ControlSequenceOfOperation2[ControlSequenceOfOperation2["CoolingAndHeating"] = 4] = "CoolingAndHeating";
+    ControlSequenceOfOperation2[ControlSequenceOfOperation2["CoolingAndHeatingWithReheat"] = 5] = "CoolingAndHeatingWithReheat";
+  })(ControlSequenceOfOperation = Thermostat2.ControlSequenceOfOperation || (Thermostat2.ControlSequenceOfOperation = {}));
+  let SystemMode;
+  ((SystemMode2) => {
+    SystemMode2[SystemMode2["Off"] = 0] = "Off";
+    SystemMode2[SystemMode2["Auto"] = 1] = "Auto";
+    SystemMode2[SystemMode2["Cool"] = 3] = "Cool";
+    SystemMode2[SystemMode2["Heat"] = 4] = "Heat";
+    SystemMode2[SystemMode2["EmergencyHeat"] = 5] = "EmergencyHeat";
+    SystemMode2[SystemMode2["Precooling"] = 6] = "Precooling";
+    SystemMode2[SystemMode2["FanOnly"] = 7] = "FanOnly";
+    SystemMode2[SystemMode2["Dry"] = 8] = "Dry";
+    SystemMode2[SystemMode2["Sleep"] = 9] = "Sleep";
+  })(SystemMode = Thermostat2.SystemMode || (Thermostat2.SystemMode = {}));
+  let TemperatureSetpointHold;
+  ((TemperatureSetpointHold2) => {
+    TemperatureSetpointHold2[TemperatureSetpointHold2["SetpointHoldOff"] = 0] = "SetpointHoldOff";
+    TemperatureSetpointHold2[TemperatureSetpointHold2["SetpointHoldOn"] = 1] = "SetpointHoldOn";
+  })(TemperatureSetpointHold = Thermostat2.TemperatureSetpointHold || (Thermostat2.TemperatureSetpointHold = {}));
+  Thermostat2.ProgrammingOperationMode = {
+    /**
+     * Schedule programming mode. This enables any programmed weekly schedule configurations.
+     */
+    scheduleActive: (0, import_BitmapSchema.BitFlag)(0),
+    /**
+     * Auto/recovery mode
+     */
+    autoRecovery: (0, import_BitmapSchema.BitFlag)(1),
+    /**
+     * Economy/EnergyStar mode
+     */
+    economy: (0, import_BitmapSchema.BitFlag)(2)
+  };
+  Thermostat2.RelayState = {
+    /**
+     * Heat State On
+     */
+    heat: (0, import_BitmapSchema.BitFlag)(0),
+    /**
+     * Cool State On
+     */
+    cool: (0, import_BitmapSchema.BitFlag)(1),
+    /**
+     * Fan State On
+     */
+    fan: (0, import_BitmapSchema.BitFlag)(2),
+    /**
+     * Heat 2nd State On
+     */
+    heatStage2: (0, import_BitmapSchema.BitFlag)(3),
+    /**
+     * Cool 2nd State On
+     */
+    coolStage2: (0, import_BitmapSchema.BitFlag)(4),
+    /**
+     * Fan 2nd State On
+     */
+    fanStage2: (0, import_BitmapSchema.BitFlag)(5),
+    /**
+     * Fan 3rd Stage On
+     */
+    fanStage3: (0, import_BitmapSchema.BitFlag)(6)
+  };
+  let SetpointChangeSource;
+  ((SetpointChangeSource2) => {
+    SetpointChangeSource2[SetpointChangeSource2["Manual"] = 0] = "Manual";
+    SetpointChangeSource2[SetpointChangeSource2["Schedule"] = 1] = "Schedule";
+    SetpointChangeSource2[SetpointChangeSource2["External"] = 2] = "External";
+  })(SetpointChangeSource = Thermostat2.SetpointChangeSource || (Thermostat2.SetpointChangeSource = {}));
+  let AcType;
+  ((AcType2) => {
+    AcType2[AcType2["Unknown"] = 0] = "Unknown";
+    AcType2[AcType2["CoolingFixed"] = 1] = "CoolingFixed";
+    AcType2[AcType2["HeatPumpFixed"] = 2] = "HeatPumpFixed";
+    AcType2[AcType2["CoolingInverter"] = 3] = "CoolingInverter";
+    AcType2[AcType2["HeatPumpInverter"] = 4] = "HeatPumpInverter";
+  })(AcType = Thermostat2.AcType || (Thermostat2.AcType = {}));
+  let AcRefrigerantType;
+  ((AcRefrigerantType2) => {
+    AcRefrigerantType2[AcRefrigerantType2["Unknown"] = 0] = "Unknown";
+    AcRefrigerantType2[AcRefrigerantType2["R22"] = 1] = "R22";
+    AcRefrigerantType2[AcRefrigerantType2["R410A"] = 2] = "R410A";
+    AcRefrigerantType2[AcRefrigerantType2["R407C"] = 3] = "R407C";
+  })(AcRefrigerantType = Thermostat2.AcRefrigerantType || (Thermostat2.AcRefrigerantType = {}));
+  let AcCompressorType;
+  ((AcCompressorType2) => {
+    AcCompressorType2[AcCompressorType2["Unknown"] = 0] = "Unknown";
+    AcCompressorType2[AcCompressorType2["T1"] = 1] = "T1";
+    AcCompressorType2[AcCompressorType2["T2"] = 2] = "T2";
+    AcCompressorType2[AcCompressorType2["T3"] = 3] = "T3";
+  })(AcCompressorType = Thermostat2.AcCompressorType || (Thermostat2.AcCompressorType = {}));
+  Thermostat2.AcErrorCode = {
+    /**
+     * Compressor Failure or Refrigerant Leakage
+     */
+    compressorFail: (0, import_BitmapSchema.BitFlag)(0),
+    /**
+     * Room Temperature Sensor Failure
+     */
+    roomSensorFail: (0, import_BitmapSchema.BitFlag)(1),
+    /**
+     * Outdoor Temperature Sensor Failure
+     */
+    outdoorSensorFail: (0, import_BitmapSchema.BitFlag)(2),
+    /**
+     * Indoor Coil Temperature Sensor Failure
+     */
+    coilSensorFail: (0, import_BitmapSchema.BitFlag)(3),
+    /**
+     * Fan Failure
+     */
+    fanFail: (0, import_BitmapSchema.BitFlag)(4)
+  };
+  let AcLouverPosition;
+  ((AcLouverPosition2) => {
+    AcLouverPosition2[AcLouverPosition2["Closed"] = 1] = "Closed";
+    AcLouverPosition2[AcLouverPosition2["Open"] = 2] = "Open";
+    AcLouverPosition2[AcLouverPosition2["Quarter"] = 3] = "Quarter";
+    AcLouverPosition2[AcLouverPosition2["Half"] = 4] = "Half";
+    AcLouverPosition2[AcLouverPosition2["ThreeQuarters"] = 5] = "ThreeQuarters";
+  })(AcLouverPosition = Thermostat2.AcLouverPosition || (Thermostat2.AcLouverPosition = {}));
+  let AcCapacityFormat;
+  ((AcCapacityFormat2) => {
+    AcCapacityFormat2[AcCapacityFormat2["BtUh"] = 0] = "BtUh";
+  })(AcCapacityFormat = Thermostat2.AcCapacityFormat || (Thermostat2.AcCapacityFormat = {}));
+  let SetpointRaiseLowerMode;
+  ((SetpointRaiseLowerMode2) => {
+    SetpointRaiseLowerMode2[SetpointRaiseLowerMode2["Heat"] = 0] = "Heat";
+    SetpointRaiseLowerMode2[SetpointRaiseLowerMode2["Cool"] = 1] = "Cool";
+    SetpointRaiseLowerMode2[SetpointRaiseLowerMode2["Both"] = 2] = "Both";
+  })(SetpointRaiseLowerMode = Thermostat2.SetpointRaiseLowerMode || (Thermostat2.SetpointRaiseLowerMode = {}));
+  Thermostat2.TlvSetpointRaiseLowerRequest = (0, import_TlvObject.TlvObject)({
+    mode: (0, import_TlvObject.TlvField)(0, (0, import_TlvNumber.TlvEnum)()),
+    amount: (0, import_TlvObject.TlvField)(1, import_TlvNumber.TlvInt8)
+  });
+  Thermostat2.AlarmCode = {
+    /**
+     * Initialization failure. The device failed to complete initialization at power-up.
+     */
+    initialization: (0, import_BitmapSchema.BitFlag)(0),
+    /**
+     * Hardware failure
+     */
+    hardware: (0, import_BitmapSchema.BitFlag)(1),
+    /**
+     * Self-calibration failure
+     */
+    selfCalibration: (0, import_BitmapSchema.BitFlag)(2)
+  };
+  Thermostat2.HvacSystemType = {
+    /**
+     * Stage of cooling the HVAC system is using.
+     *
+     * These bits shall indicate what stage of cooling the HVAC system is using.
+     *
+     *   • 00 = Cool Stage 1
+     *
+     *   • 01 = Cool Stage 2
+     *
+     *   • 10 = Cool Stage 3
+     *
+     *   • 11 = Reserved
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.8.6.1
+     */
+    coolingStage: (0, import_BitmapSchema.BitField)(0, 2),
+    /**
+     * Stage of heating the HVAC system is using.
+     *
+     * These bits shall indicate what stage of heating the HVAC system is using.
+     *
+     *   • 00 = Heat Stage 1
+     *
+     *   • 01 = Heat Stage 2
+     *
+     *   • 10 = Heat Stage 3
+     *
+     *   • 11 = Reserved
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.8.6.2
+     */
+    heatingStage: (0, import_BitmapSchema.BitField)(2, 2),
+    /**
+     * Is the heating type Heat Pump.
+     *
+     * This bit shall indicate whether the HVAC system is conventional or a heat pump.
+     *
+     *   • 0 = Conventional
+     *
+     *   • 1 = Heat Pump
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.8.6.3
+     */
+    heatingIsHeatPump: (0, import_BitmapSchema.BitFlag)(4),
+    /**
+     * Does the HVAC system use fuel.
+     *
+     * This bit shall indicate whether the HVAC system uses fuel.
+     *
+     *   • 0 = Does not use fuel
+     *
+     *   • 1 = Uses fuel
+     *
+     * @see {@link MatterSpecification.v13.Cluster} § 4.3.8.6.4
+     */
+    heatingUsesFuel: (0, import_BitmapSchema.BitFlag)(5)
+  };
+  Thermostat2.OccupancyComponent = import_MutableCluster.MutableCluster.Component({
+    attributes: {
+      /**
+       * Indicates whether the heated/cooled space is occupied or not, as measured locally or remotely (over the
+       * network).
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.5
+       */
+      occupancy: (0, import_Cluster.Attribute)(
+        2,
+        (0, import_TlvNumber.TlvBitmap)(import_TlvNumber.TlvUInt8, import_occupancy_sensing.OccupancySensing.Occupancy),
+        { default: (0, import_BitmapSchema.BitsFromPartial)(import_occupancy_sensing.OccupancySensing.Occupancy, { occupied: true }) }
+      )
+    }
+  });
+  Thermostat2.HeatingComponent = import_MutableCluster.MutableCluster.Component({
+    attributes: {
+      /**
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9
+       */
+      absMinHeatSetpointLimit: (0, import_Cluster.OptionalFixedAttribute)(3, import_TlvNumber.TlvInt16, { default: 700 }),
+      /**
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9
+       */
+      absMaxHeatSetpointLimit: (0, import_Cluster.OptionalFixedAttribute)(4, import_TlvNumber.TlvInt16, { default: 3e3 }),
+      /**
+       * Indicates the level of heating demanded by the PI loop in percent. This value is 0 when the thermostat
+       * is in “off” or “cooling” mode.
+       *
+       * This attribute is reported regularly and may be used to control a heating device.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.11
+       */
+      piHeatingDemand: (0, import_Cluster.OptionalAttribute)(8, import_TlvNumber.TlvUInt8.bound({ max: 100 })),
+      /**
+       * Indicates the heating mode setpoint when the room is occupied.
+       *
+       * Refer to Setpoint Limits for constraints. If an attempt is made to set this attribute such that these
+       * constraints are violated, a response with the status code CONSTRAINT_ERROR shall be returned.
+       *
+       * If the occupancy status of the room is unknown, this attribute shall be used as the heating mode
+       * setpoint.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.15
+       */
+      occupiedHeatingSetpoint: (0, import_Cluster.WritableAttribute)(
+        18,
+        import_TlvNumber.TlvInt16,
+        { scene: true, persistent: true, default: 2e3 }
+      ),
+      /**
+       * Indicates the minimum level that the heating setpoint may be set to.
+       *
+       * This attribute, and the following three attributes, allow the user to define setpoint limits more
+       * constrictive than the manufacturer imposed ones. Limiting users (e.g., in a commercial building) to such
+       * setpoint limits can help conserve power.
+       *
+       * Refer to Setpoint Limits for constraints. If an attempt is made to set this attribute to a value which
+       * conflicts with setpoint values then those setpoints shall be adjusted by the minimum amount to permit
+       * this attribute to be set to the desired value. If an attempt is made to set this attribute to a value
+       * which is not consistent with the constraints and cannot be resolved by modifying setpoints then a
+       * response with the status code CONSTRAINT_ERROR shall be returned.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.18
+       */
+      minHeatSetpointLimit: (0, import_Cluster.OptionalWritableAttribute)(
+        21,
+        import_TlvNumber.TlvInt16,
+        { persistent: true, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the maximum level that the heating setpoint may be set to.
+       *
+       * Refer to Setpoint Limits for constraints. If an attempt is made to set this attribute to a value which
+       * conflicts with setpoint values then those setpoints shall be adjusted by the minimum amount to permit
+       * this attribute to be set to the desired value. If an attempt is made to set this attribute to a value
+       * which is not consistent with the constraints and cannot be resolved by modifying setpoints then a
+       * response with the status code CONSTRAINT_ERROR shall be returned.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.19
+       */
+      maxHeatSetpointLimit: (0, import_Cluster.OptionalWritableAttribute)(
+        22,
+        import_TlvNumber.TlvInt16,
+        { persistent: true, writeAcl: import_model.AccessLevel.Manage }
+      )
+    }
+  });
+  Thermostat2.CoolingComponent = import_MutableCluster.MutableCluster.Component({
+    attributes: {
+      /**
+       * Indicates the absolute minimum level that the cooling setpoint may be set to. This is a limitation
+       * imposed by the manufacturer.
+       *
+       * Refer to Setpoint Limits for constraints
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.8
+       */
+      absMinCoolSetpointLimit: (0, import_Cluster.OptionalFixedAttribute)(5, import_TlvNumber.TlvInt16, { default: 1600 }),
+      /**
+       * Indicates the absolute maximum level that the cooling setpoint may be set to. This is a limitation
+       * imposed by the manufacturer.
+       *
+       * Refer to Setpoint Limits for constraints
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.9
+       */
+      absMaxCoolSetpointLimit: (0, import_Cluster.OptionalFixedAttribute)(6, import_TlvNumber.TlvInt16, { default: 3200 }),
+      /**
+       * Indicates the level of cooling demanded by the PI (proportional integral) control loop in use by the
+       * thermostat (if any), in percent. This value is 0 when the thermostat is in “off” or “heating” mode.
+       *
+       * This attribute is reported regularly and may be used to control a cooling device.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.10
+       */
+      piCoolingDemand: (0, import_Cluster.OptionalAttribute)(7, import_TlvNumber.TlvUInt8.bound({ max: 100 })),
+      /**
+       * Indicates the cooling mode setpoint when the room is occupied.
+       *
+       * Refer to Setpoint Limits for constraints. If an attempt is made to set this attribute such that these
+       * constraints are violated, a response with the status code CONSTRAINT_ERROR shall be returned.
+       *
+       * If the occupancy status of the room is unknown, this attribute shall be used as the cooling mode
+       * setpoint.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.14
+       */
+      occupiedCoolingSetpoint: (0, import_Cluster.WritableAttribute)(
+        17,
+        import_TlvNumber.TlvInt16,
+        { scene: true, persistent: true, default: 2600 }
+      ),
+      /**
+       * Indicates the minimum level that the cooling setpoint may be set to.
+       *
+       * Refer to Setpoint Limits for constraints. If an attempt is made to set this attribute to a value which
+       * conflicts with setpoint values then those setpoints shall be adjusted by the minimum amount to permit
+       * this attribute to be set to the desired value. If an attempt is made to set this attribute to a value
+       * which is not consistent with the constraints and cannot be resolved by modifying setpoints then a
+       * response with the status code CONSTRAINT_ERROR shall be returned.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.20
+       */
+      minCoolSetpointLimit: (0, import_Cluster.OptionalWritableAttribute)(
+        23,
+        import_TlvNumber.TlvInt16,
+        { persistent: true, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the maximum level that the cooling setpoint may be set to.
+       *
+       * Refer to Setpoint Limits for constraints. If an attempt is made to set this attribute to a value which
+       * conflicts with setpoint values then those setpoints shall be adjusted by the minimum amount to permit
+       * this attribute to be set to the desired value. If an attempt is made to set this attribute to a value
+       * which is not consistent with the constraints and cannot be resolved by modifying setpoints then a
+       * response with the status code CONSTRAINT_ERROR shall be returned.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.21
+       */
+      maxCoolSetpointLimit: (0, import_Cluster.OptionalWritableAttribute)(
+        24,
+        import_TlvNumber.TlvInt16,
+        { persistent: true, writeAcl: import_model.AccessLevel.Manage }
+      )
+    }
+  });
+  Thermostat2.NotLocalTemperatureNotExposedComponent = import_MutableCluster.MutableCluster.Component({
+    attributes: {
+      /**
+       * Indicates the offset the Thermostat server shall make to the measured temperature (locally or remotely)
+       * to adjust the Calculated Local Temperature prior to using, displaying or reporting it.
+       *
+       * The purpose of this attribute is to adjust the calibration of the Thermostat server per the user’s
+       * preferences (e.g., to match if there are multiple servers displaying different values for the same HVAC
+       * area) or compensate for variability amongst temperature sensors.
+       *
+       * If a Thermostat client attempts to write LocalTemperatureCalibration attribute to an unsupported value
+       * (e.g., out of the range supported by the Thermostat server), the Thermostat server shall respond with a
+       * status of SUCCESS and set the value of LocalTemperatureCalibration to the upper or lower limit reached.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.13
+       */
+      localTemperatureCalibration: (0, import_Cluster.OptionalWritableAttribute)(
+        16,
+        import_TlvNumber.TlvInt8,
+        { persistent: true, writeAcl: import_model.AccessLevel.Manage }
+      )
+    }
+  });
+  Thermostat2.CoolingAndOccupancyComponent = import_MutableCluster.MutableCluster.Component({
+    attributes: {
+      /**
+       * Indicates the cooling mode setpoint when the room is unoccupied.
+       *
+       * Refer to Setpoint Limits for constraints. If an attempt is made to set this attribute such that these
+       * constraints are violated, a response with the status code CONSTRAINT_ERROR shall be returned.
+       *
+       * If the occupancy status of the room is unknown, this attribute shall NOT be used.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.16
+       */
+      unoccupiedCoolingSetpoint: (0, import_Cluster.WritableAttribute)(19, import_TlvNumber.TlvInt16, { persistent: true, default: 2600 })
+    }
+  });
+  Thermostat2.HeatingAndOccupancyComponent = import_MutableCluster.MutableCluster.Component({
+    attributes: {
+      /**
+       * Indicates the heating mode setpoint when the room is unoccupied.
+       *
+       * Refer to Setpoint Limits for constraints. If an attempt is made to set this attribute such that these
+       * constraints are violated, a response with the status code CONSTRAINT_ERROR shall be returned.
+       *
+       * If the occupancy status of the room is unknown, this attribute shall NOT be used.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.17
+       */
+      unoccupiedHeatingSetpoint: (0, import_Cluster.WritableAttribute)(20, import_TlvNumber.TlvInt16, { persistent: true, default: 2e3 })
+    }
+  });
+  Thermostat2.AutoModeComponent = import_MutableCluster.MutableCluster.Component({
+    attributes: {
+      /**
+       * On devices which support the AUTO feature, this attribute shall indicate the minimum difference between
+       * the Heat Setpoint and the Cool Setpoint.
+       *
+       * Refer to Setpoint Limits for constraints. If an attempt is made to set this attribute to a value which
+       * conflicts with setpoint values then those setpoints shall be adjusted by the minimum amount to permit
+       * this attribute to be set to the desired value. If an attempt is made to set this attribute to a value
+       * which is not consistent with the constraints and cannot be resolved by modifying setpoints then a
+       * response with the status code CONSTRAINT_ERROR shall be returned.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.22
+       */
+      minSetpointDeadBand: (0, import_Cluster.WritableAttribute)(25, import_TlvNumber.TlvInt8, { persistent: true, writeAcl: import_model.AccessLevel.Manage }),
+      /**
+       * Indicates the running mode of the thermostat. This attribute uses the same values as SystemModeEnum but
+       * can only be Off, Cool or Heat. This attribute is intended to provide additional information when the
+       * thermostat’s system mode is in auto mode.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.27
+       */
+      thermostatRunningMode: (0, import_Cluster.OptionalAttribute)(
+        30,
+        (0, import_TlvNumber.TlvEnum)(),
+        { default: 0 /* Off */ }
+      )
+    }
+  });
+  Thermostat2.ScheduleConfigurationComponent = import_MutableCluster.MutableCluster.Component({
+    attributes: {
+      /**
+       * Indicates the day of the week that this thermostat considers to be the start of week for weekly setpoint
+       * scheduling.
+       *
+       * This attribute may be able to be used as the base to determine if the device supports weekly scheduling
+       * by reading the attribute. Successful response means that the weekly scheduling is supported.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.28
+       */
+      startOfWeek: (0, import_Cluster.FixedAttribute)(32, (0, import_TlvNumber.TlvEnum)()),
+      /**
+       * Indicates how many weekly schedule transitions the thermostat is capable of handling.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.29
+       */
+      numberOfWeeklyTransitions: (0, import_Cluster.FixedAttribute)(33, import_TlvNumber.TlvUInt8, { default: 0 }),
+      /**
+       * Indicates how many daily schedule transitions the thermostat is capable of handling.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.30
+       */
+      numberOfDailyTransitions: (0, import_Cluster.FixedAttribute)(34, import_TlvNumber.TlvUInt8, { default: 0 })
+    },
+    commands: {
+      /**
+       * Upon receipt, the weekly schedule for updating setpoints shall be stored in the thermostat and SHOULD
+       * begin at the time of receipt. A status code shall be sent in response.
+       *
+       * When a command is received that requires a total number of transitions greater than the device supports,
+       * the status of the response shall be INSUFFICIENT_SPACE.
+       *
+       * When any of the setpoints sent in the sequence is out of range (AbsMin/MaxSetPointLimit), or when the
+       * Mode for Sequence field includes a mode not supported by the device, the status of the response shall be
+       * CONSTRAINT_ERROR and no setpoints from the entire sequence SHOULD be used.
+       *
+       * When an overlapping transition is detected, the status of the response shall be FAILURE.
+       *
+       * When a device which does not support multiple days in a command receives a command with more than one
+       * bit set in the DayOfWeekForSequence field, or when a device which does not support multiple modes in a
+       * command receives a command with more than one bit set in the ModeForSequence field, or when the contents
+       * of the Transitions field does not agree with NumberOfTransitionsForSequence, DayOfWeekForSequence or
+       * ModeForSequence, the status of the response shall be INVALID_COMMAND.
+       *
+       * When the transitions could be added successfully, the status of the response shall be SUCCESS.
+       *
+       * The set weekly schedule command is used to update the thermostat weekly setpoint schedule from a
+       * management system. If the thermostat already has a weekly setpoint schedule programmed, then it SHOULD
+       * replace each daily setpoint set as it receives the updates from the management system. For example, if
+       * the thermostat has 4 setpoints for every day of the week and is sent a Set Weekly Schedule command with
+       * one setpoint for Saturday then the thermostat SHOULD remove all 4 setpoints for Saturday and replace
+       * those with the updated setpoint but leave all other days unchanged. If the schedule is larger than what
+       * fits in one frame or contains more than 10 transitions, the schedule shall then be sent using multiple
+       * Set Weekly Schedule Commands.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.10.4
+       */
+      setWeeklySchedule: (0, import_Cluster.Command)(
+        1,
+        Thermostat2.TlvSetWeeklyScheduleRequest,
+        1,
+        import_Cluster.TlvNoResponse,
+        { invokeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Upon receipt, the unit SHOULD send in return the Get Weekly Schedule Response command. The Days to
+       * Return and Mode to Return fields are defined as bitmask for the flexibility to support multiple days and
+       * multiple modes within one command. If thermostat cannot handle incoming command with multiple days
+       * and/or multiple modes within one command, it shall send default response of INVALID_COMMAND in return.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.10.5
+       */
+      getWeeklySchedule: (0, import_Cluster.Command)(2, Thermostat2.TlvGetWeeklyScheduleRequest, 0, Thermostat2.TlvGetWeeklyScheduleResponse),
+      /**
+       * This command is used to clear the weekly schedule. The Clear weekly schedule has no payload.
+       *
+       * Upon receipt, all transitions currently stored shall be cleared and a default response of SUCCESS shall
+       * be sent in response. There are no error responses to this command.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.10.7
+       */
+      clearWeeklySchedule: (0, import_Cluster.Command)(3, import_TlvNoArguments.TlvNoArguments, 3, import_Cluster.TlvNoResponse, { invokeAcl: import_model.AccessLevel.Manage })
+    }
+  });
+  Thermostat2.SetbackComponent = import_MutableCluster.MutableCluster.Component({
+    attributes: {
+      /**
+       * Indicates the amount that the Thermostat server will allow the Calculated Local Temperature to float
+       * above the OccupiedCoolingSetpoint (i.e., OccupiedCoolingSetpoint + OccupiedSetback) or below the
+       * OccupiedHeatingSetpoint setpoint (i.e., OccupiedHeatingSetpoint – OccupiedSetback) before initiating a
+       * state change to bring the temperature back to the user’s desired setpoint. This attribute is sometimes
+       * also referred to as the “span.”
+       *
+       * The purpose of this attribute is to allow remote configuration of the span between the desired setpoint
+       * and the measured temperature to help prevent over-cycling and reduce energy bills, though this may
+       * result in lower comfort on the part of some users.
+       *
+       * The null value indicates the attribute is unused.
+       *
+       * If the Thermostat client attempts to write OccupiedSetback to a value greater than OccupiedSetbackMax,
+       * the Thermostat server shall set its OccupiedSetback value to OccupiedSetbackMax and shall send a Write
+       * Attribute Response command with a Status Code field enumeration of SUCCESS response.
+       *
+       * If the Thermostat client attempts to write OccupiedSetback to a value less than OccupiedSetbackMin, the
+       * Thermostat server shall set its OccupiedSetback value to OccupiedSetbackMin and shall send a Write
+       * Attribute Response command with a Status Code field enumeration of SUCCESS response.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.38
+       */
+      occupiedSetback: (0, import_Cluster.WritableAttribute)(
+        52,
+        (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvUInt8),
+        { persistent: true, default: null, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the minimum value that the Thermostat server will allow the OccupiedSetback attribute to be
+       * configured by a user.
+       *
+       * The null value indicates the attribute is unused.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.39
+       */
+      occupiedSetbackMin: (0, import_Cluster.FixedAttribute)(53, (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvUInt8), { default: null }),
+      /**
+       * Indicates the maximum value that the Thermostat server will allow the OccupiedSetback attribute to be
+       * configured by a user.
+       *
+       * The null value indicates the attribute is unused.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.40
+       */
+      occupiedSetbackMax: (0, import_Cluster.FixedAttribute)(54, (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvUInt8), { default: null })
+    }
+  });
+  Thermostat2.SetbackAndOccupancyComponent = import_MutableCluster.MutableCluster.Component({
+    attributes: {
+      /**
+       * Indicates the amount that the Thermostat server will allow the Calculated Local Temperature to float
+       * above the UnoccupiedCoolingSetpoint (i.e., UnoccupiedCoolingSetpoint + UnoccupiedSetback) or below the
+       * UnoccupiedHeatingSetpoint setpoint (i.e., UnoccupiedHeatingSetpoint - UnoccupiedSetback) before
+       * initiating a state change to bring the temperature back to the user’s desired setpoint. This attribute
+       * is sometimes also referred to as the “span.”
+       *
+       * The purpose of this attribute is to allow remote configuration of the span between the desired setpoint
+       * and the measured temperature to help prevent over-cycling and reduce energy bills, though this may
+       * result in lower comfort on the part of some users.
+       *
+       * The null value indicates the attribute is unused.
+       *
+       * If the Thermostat client attempts to write UnoccupiedSetback to a value greater than
+       * UnoccupiedSetbackMax, the Thermostat server shall set its UnoccupiedSetback value to
+       * UnoccupiedSetbackMax and shall send a Write Attribute Response command with a Status Code field
+       * enumeration of SUCCESS response.
+       *
+       * If the Thermostat client attempts to write UnoccupiedSetback to a value less than UnoccupiedSetbackMin,
+       * the Thermostat server shall set its UnoccupiedSetback value to UnoccupiedSetbackMin and shall send a
+       * Write Attribute Response command with a Status Code field enumeration of SUCCESS response.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.41
+       */
+      unoccupiedSetback: (0, import_Cluster.WritableAttribute)(
+        55,
+        (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvUInt8),
+        { persistent: true, default: null, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the minimum value that the Thermostat server will allow the UnoccupiedSetback attribute to be
+       * configured by a user.
+       *
+       * The null value indicates the attribute is unused.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.42
+       */
+      unoccupiedSetbackMin: (0, import_Cluster.FixedAttribute)(56, (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvUInt8), { default: null }),
+      /**
+       * Indicates the maximum value that the Thermostat server will allow the UnoccupiedSetback attribute to be
+       * configured by a user.
+       *
+       * The null value indicates the attribute is unused.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.43
+       */
+      unoccupiedSetbackMax: (0, import_Cluster.FixedAttribute)(57, (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvUInt8), { default: null })
+    }
+  });
+  Thermostat2.Base = import_MutableCluster.MutableCluster.Component({
+    id: 513,
+    name: "Thermostat",
+    revision: 6,
+    features: {
+      /**
+       * Heating
+       *
+       * Thermostat is capable of managing a heating device
+       */
+      heating: (0, import_BitmapSchema.BitFlag)(0),
+      /**
+       * Cooling
+       *
+       * Thermostat is capable of managing a cooling device
+       */
+      cooling: (0, import_BitmapSchema.BitFlag)(1),
+      /**
+       * Occupancy
+       *
+       * Supports Occupied and Unoccupied setpoints
+       */
+      occupancy: (0, import_BitmapSchema.BitFlag)(2),
+      /**
+       * ScheduleConfiguration
+       *
+       * Supports remote configuration of a weekly schedule of setpoint transitions
+       */
+      scheduleConfiguration: (0, import_BitmapSchema.BitFlag)(3),
+      /**
+       * Setback
+       *
+       * Supports configurable setback (or span)
+       */
+      setback: (0, import_BitmapSchema.BitFlag)(4),
+      /**
+       * AutoMode
+       *
+       * Supports a System Mode of Auto
+       */
+      autoMode: (0, import_BitmapSchema.BitFlag)(5),
+      /**
+       * LocalTemperatureNotExposed
+       *
+       * This feature indicates that the Calculated Local Temperature used internally is unavailable to report
+       * externally, for example due to the temperature control being done by a separate subsystem which does not
+       * offer a view into the currently measured temperature, but allows setpoints to be provided.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.4.1
+       */
+      localTemperatureNotExposed: (0, import_BitmapSchema.BitFlag)(6)
+    },
+    attributes: {
+      /**
+       * Indicates the current Calculated Local Temperature, when available.
+       *
+       *   • If the LTNE feature is not supported:
+       *
+       *     ◦ If the LocalTemperatureCalibration is invalid or currently unavailable, the attribute shall report
+       *       null.
+       *
+       *     ◦ If the LocalTemperatureCalibration is valid, the attribute shall report that value.
+       *
+       *   • Otherwise, if the LTNE feature is supported, there is no feedback externally available for the
+       *     LocalTemperatureCalibration. In that case, the LocalTemperature attribute shall always report null.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.3
+       */
+      localTemperature: (0, import_Cluster.Attribute)(0, (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvInt16), { default: null }),
+      /**
+       * Indicates the outdoor temperature, as measured locally or remotely (over the network).
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.4
+       */
+      outdoorTemperature: (0, import_Cluster.OptionalAttribute)(1, (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvInt16), { default: null }),
+      /**
+       * Indicates when the local temperature, outdoor temperature and occupancy are being sensed by remote
+       * networked sensors, rather than internal sensors.
+       *
+       * If the LTNE feature is present in the server, the LocalTemperature RemoteSensing bit value shall always
+       * report a value of 0.
+       *
+       * If the LocalTemperature RemoteSensing bit is written with a value of 1 when the LTNE feature is present,
+       * the write shall fail and the server shall report a CONSTRAINT_ERROR.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.23
+       */
+      remoteSensing: (0, import_Cluster.OptionalWritableAttribute)(
+        26,
+        (0, import_TlvNumber.TlvBitmap)(import_TlvNumber.TlvUInt8, Thermostat2.RemoteSensing),
+        { persistent: true, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the overall operating environment of the thermostat, and thus the possible system modes that
+       * the thermostat can operate in.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.24
+       */
+      controlSequenceOfOperation: (0, import_Cluster.WritableAttribute)(
+        27,
+        (0, import_TlvNumber.TlvEnum)(),
+        {
+          persistent: true,
+          default: 4 /* CoolingAndHeating */,
+          writeAcl: import_model.AccessLevel.Manage
+        }
+      ),
+      /**
+       * Indicates the current operating mode of the thermostat. Its value shall be limited by the
+       * ControlSequenceOfOperation attribute.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.25
+       */
+      systemMode: (0, import_Cluster.WritableAttribute)(
+        28,
+        (0, import_TlvNumber.TlvEnum)(),
+        { scene: true, persistent: true, default: 1 /* Auto */, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the temperature hold status on the thermostat. If hold status is on, the thermostat SHOULD
+       * maintain the temperature setpoint for the current mode until a system mode change. If hold status is
+       * off, the thermostat SHOULD follow the setpoint transitions specified by its internal scheduling program.
+       * If the thermostat supports setpoint hold for a specific duration, it SHOULD also implement the
+       * TemperatureSetpointHoldDuration attribute.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.31
+       */
+      temperatureSetpointHold: (0, import_Cluster.OptionalWritableAttribute)(
+        35,
+        (0, import_TlvNumber.TlvEnum)(),
+        { persistent: true, default: 0 /* SetpointHoldOff */, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the period in minutes for which a setpoint hold is active. Thermostats that support hold for a
+       * specified duration SHOULD implement this attribute. The null value indicates the field is unused. All
+       * other values are reserved.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.32
+       */
+      temperatureSetpointHoldDuration: (0, import_Cluster.OptionalWritableAttribute)(
+        36,
+        (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvUInt16.bound({ max: 1440 })),
+        { persistent: true, default: null, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the operational state of the thermostat’s programming. The thermostat shall modify its
+       * programming operation when this attribute is modified by a client and update this attribute when its
+       * programming operation is modified locally by a user. The thermostat may support more than one active
+       * ProgrammingOperationModeBitmap. For example, the thermostat may operate simultaneously in Schedule
+       * Programming Mode and Recovery Mode.
+       *
+       * Thermostats which contain a schedule may use this attribute to control how that schedule is used, even
+       * if they do not support the ScheduleConfiguration feature.
+       *
+       * When ScheduleActive is not set, the setpoint is altered only by manual up/down changes at the thermostat
+       * or remotely, not by internal schedule programming.
+       *
+       * NOTE
+       *
+       * Modifying the ScheduleActive bit does not clear or delete previous weekly schedule programming
+       * configurations.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.33
+       */
+      thermostatProgrammingOperationMode: (0, import_Cluster.OptionalWritableAttribute)(
+        37,
+        (0, import_TlvNumber.TlvBitmap)(import_TlvNumber.TlvUInt8, Thermostat2.ProgrammingOperationMode),
+        { writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the current relay state of the heat, cool, and fan relays. Unimplemented outputs shall be
+       * treated as if they were Off.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.34
+       */
+      thermostatRunningState: (0, import_Cluster.OptionalAttribute)(41, (0, import_TlvNumber.TlvBitmap)(import_TlvNumber.TlvUInt16, Thermostat2.RelayState)),
+      /**
+       * Indicates the source of the current active OccupiedCoolingSetpoint or OccupiedHeatingSetpoint (i.e., who
+       * or what determined the current setpoint).
+       *
+       * This attribute enables service providers to determine whether changes to setpoints were initiated due to
+       * occupant comfort, scheduled programming or some other source (e.g., electric utility or other service
+       * provider). Because automation services may initiate frequent setpoint changes, this attribute clearly
+       * differentiates the source of setpoint changes made at the thermostat.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.35
+       */
+      setpointChangeSource: (0, import_Cluster.OptionalAttribute)(
+        48,
+        (0, import_TlvNumber.TlvEnum)(),
+        { default: 0 /* Manual */ }
+      ),
+      /**
+       * Indicates the delta between the current active OccupiedCoolingSetpoint or OccupiedHeatingSetpoint and
+       * the previous active setpoint. This attribute is meant to accompany the SetpointChangeSource attribute;
+       * devices implementing SetpointChangeAmount SHOULD also implement SetpointChangeSource.
+       *
+       * The null value indicates that the previous setpoint was unknown.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.36
+       */
+      setpointChangeAmount: (0, import_Cluster.OptionalAttribute)(49, (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvInt16), { default: null }),
+      /**
+       * Indicates the time in UTC at which the SetpointChangeAmount attribute change was recorded.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.37
+       */
+      setpointChangeSourceTimestamp: (0, import_Cluster.OptionalAttribute)(50, import_TlvNumber.TlvEpochS, { default: 0 }),
+      /**
+       * Indicates the delta between the Calculated Local Temperature and the OccupiedHeatingSetpoint or
+       * UnoccupiedHeatingSetpoint attributes at which the Thermostat server will operate in emergency heat mode.
+       *
+       * If the difference between the Calculated Local Temperature and OccupiedCoolingSetpoint or
+       * UnoccupiedCoolingSetpoint is greater than or equal to the EmergencyHeatDelta and the Thermostat server’s
+       * SystemMode attribute is in a heating-related mode, then the Thermostat server shall immediately switch
+       * to the SystemMode attribute value that provides the highest stage of heating (e.g., emergency heat) and
+       * continue operating in that running state until the OccupiedHeatingSetpoint value is reached. For example:
+       *
+       *   • Calculated Local Temperature = 10.0°C
+       *
+       *   • OccupiedHeatingSetpoint = 16.0°C
+       *
+       *   • EmergencyHeatDelta = 2.0°C
+       *
+       * ⇒ OccupiedHeatingSetpoint - Calculated Local Temperature ≥? EmergencyHeatDelta
+       *
+       * ⇒ 16°C - 10°C ≥? 2°C
+       *
+       * ⇒ TRUE >>> Thermostat server changes its SystemMode to operate in 2nd stage or emergency heat mode
+       *
+       * The purpose of this attribute is to provide Thermostat clients the ability to configure rapid heating
+       * when a setpoint is of a specified amount greater than the measured temperature. This allows the heated
+       * space to be quickly heated to the desired level set by the user.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.44
+       */
+      emergencyHeatDelta: (0, import_Cluster.OptionalWritableAttribute)(
+        58,
+        import_TlvNumber.TlvUInt8,
+        { persistent: true, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the type of Mini Split ACTypeEnum of Mini Split AC is defined depending on how Cooling and
+       * Heating condition is achieved by Mini Split AC.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.45
+       */
+      acType: (0, import_Cluster.OptionalWritableAttribute)(
+        64,
+        (0, import_TlvNumber.TlvEnum)(),
+        { persistent: true, default: 0 /* Unknown */, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates capacity of Mini Split AC in terms of the format defined by the ACCapacityFormat attribute
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.46
+       */
+      acCapacity: (0, import_Cluster.OptionalWritableAttribute)(
+        65,
+        import_TlvNumber.TlvUInt16,
+        { persistent: true, default: 0, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates type of refrigerant used within the Mini Split AC.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.47
+       */
+      acRefrigerantType: (0, import_Cluster.OptionalWritableAttribute)(
+        66,
+        (0, import_TlvNumber.TlvEnum)(),
+        { persistent: true, default: 0 /* Unknown */, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the type of compressor used within the Mini Split AC.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.48
+       */
+      acCompressorType: (0, import_Cluster.OptionalWritableAttribute)(
+        67,
+        (0, import_TlvNumber.TlvEnum)(),
+        { persistent: true, default: 0 /* Unknown */, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the type of errors encountered within the Mini Split AC.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.49
+       */
+      acErrorCode: (0, import_Cluster.OptionalWritableAttribute)(
+        68,
+        (0, import_TlvNumber.TlvBitmap)(import_TlvNumber.TlvUInt32, Thermostat2.AcErrorCode),
+        { writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the position of Louver on the AC.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.50
+       */
+      acLouverPosition: (0, import_Cluster.OptionalWritableAttribute)(
+        69,
+        (0, import_TlvNumber.TlvEnum)(),
+        { persistent: true, writeAcl: import_model.AccessLevel.Manage }
+      ),
+      /**
+       * Indicates the temperature of the AC coil, as measured locally or remotely (over the network).
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.51
+       */
+      acCoilTemperature: (0, import_Cluster.OptionalAttribute)(70, (0, import_TlvNullable.TlvNullable)(import_TlvNumber.TlvInt16), { default: null }),
+      /**
+       * Indicates the format for the ACCapacity attribute.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.9.52
+       */
+      acCapacityFormat: (0, import_Cluster.OptionalWritableAttribute)(
+        71,
+        (0, import_TlvNumber.TlvEnum)(),
+        { persistent: true, default: 0 /* BtUh */, writeAcl: import_model.AccessLevel.Manage }
+      )
+    },
+    commands: {
+      /**
+       * Upon receipt, the attributes for the indicated setpoint(s) shall have the amount specified in the Amount
+       * field added to them. If the resulting value is outside the limits imposed by MinCoolSetpointLimit,
+       * MaxCoolSetpointLimit, MinHeatSetpointLimit and MaxHeatSetpointLimit, the value is clamped to those
+       * limits. This is not considered an error condition.
+       *
+       * @see {@link MatterSpecification.v13.Cluster} § 4.3.10.1
+       */
+      setpointRaiseLower: (0, import_Cluster.Command)(0, Thermostat2.TlvSetpointRaiseLowerRequest, 0, import_Cluster.TlvNoResponse)
+    },
+    /**
+     * This metadata controls which ThermostatCluster elements matter.js activates for specific feature
+     * combinations.
+     */
+    extensions: import_MutableCluster.MutableCluster.Extensions(
+      { flags: { occupancy: true }, component: Thermostat2.OccupancyComponent },
+      { flags: { heating: true }, component: Thermostat2.HeatingComponent },
+      { flags: { cooling: true }, component: Thermostat2.CoolingComponent },
+      { flags: { localTemperatureNotExposed: false }, component: Thermostat2.NotLocalTemperatureNotExposedComponent },
+      { flags: { cooling: true, occupancy: true }, component: Thermostat2.CoolingAndOccupancyComponent },
+      { flags: { heating: true, occupancy: true }, component: Thermostat2.HeatingAndOccupancyComponent },
+      { flags: { autoMode: true }, component: Thermostat2.AutoModeComponent },
+      { flags: { scheduleConfiguration: true }, component: Thermostat2.ScheduleConfigurationComponent },
+      { flags: { setback: true }, component: Thermostat2.SetbackComponent },
+      { flags: { setback: true, occupancy: true }, component: Thermostat2.SetbackAndOccupancyComponent },
+      { flags: { autoMode: true, heating: false }, component: false },
+      { flags: { autoMode: true, cooling: false }, component: false },
+      { flags: { heating: false, cooling: false }, component: false }
+    )
+  });
+  Thermostat2.ClusterInstance = import_MutableCluster.MutableCluster.ExtensibleOnly(Thermostat2.Base);
+  Thermostat2.Cluster = Thermostat2.ClusterInstance;
+  const OCC = { occupancy: true };
+  const HEAT = { heating: true };
+  const COOL = { cooling: true };
+  const COOL_OCC = { cooling: true, occupancy: true };
+  const HEAT_OCC = { heating: true, occupancy: true };
+  const AUTO = { autoMode: true };
+  const SCH = { scheduleConfiguration: true };
+  const SB = { setback: true };
+  const SB_OCC = { setback: true, occupancy: true };
+  Thermostat2.CompleteInstance = (0, import_MutableCluster.MutableCluster)({
+    id: Thermostat2.Base.id,
+    name: Thermostat2.Base.name,
+    revision: Thermostat2.Base.revision,
+    features: Thermostat2.Base.features,
+    attributes: {
+      ...Thermostat2.Base.attributes,
+      occupancy: import_MutableCluster.MutableCluster.AsConditional(Thermostat2.OccupancyComponent.attributes.occupancy, { mandatoryIf: [OCC] }),
+      absMinHeatSetpointLimit: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.HeatingComponent.attributes.absMinHeatSetpointLimit,
+        { optionalIf: [HEAT] }
+      ),
+      absMaxHeatSetpointLimit: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.HeatingComponent.attributes.absMaxHeatSetpointLimit,
+        { optionalIf: [HEAT] }
+      ),
+      absMinCoolSetpointLimit: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.CoolingComponent.attributes.absMinCoolSetpointLimit,
+        { optionalIf: [COOL] }
+      ),
+      absMaxCoolSetpointLimit: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.CoolingComponent.attributes.absMaxCoolSetpointLimit,
+        { optionalIf: [COOL] }
+      ),
+      piCoolingDemand: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.CoolingComponent.attributes.piCoolingDemand,
+        { optionalIf: [COOL] }
+      ),
+      piHeatingDemand: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.HeatingComponent.attributes.piHeatingDemand,
+        { optionalIf: [HEAT] }
+      ),
+      localTemperatureCalibration: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.NotLocalTemperatureNotExposedComponent.attributes.localTemperatureCalibration,
+        { optionalIf: [] }
+      ),
+      occupiedCoolingSetpoint: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.CoolingComponent.attributes.occupiedCoolingSetpoint,
+        { mandatoryIf: [COOL] }
+      ),
+      occupiedHeatingSetpoint: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.HeatingComponent.attributes.occupiedHeatingSetpoint,
+        { mandatoryIf: [HEAT] }
+      ),
+      unoccupiedCoolingSetpoint: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.CoolingAndOccupancyComponent.attributes.unoccupiedCoolingSetpoint,
+        { mandatoryIf: [COOL_OCC] }
+      ),
+      unoccupiedHeatingSetpoint: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.HeatingAndOccupancyComponent.attributes.unoccupiedHeatingSetpoint,
+        { mandatoryIf: [HEAT_OCC] }
+      ),
+      minHeatSetpointLimit: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.HeatingComponent.attributes.minHeatSetpointLimit,
+        { optionalIf: [HEAT] }
+      ),
+      maxHeatSetpointLimit: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.HeatingComponent.attributes.maxHeatSetpointLimit,
+        { optionalIf: [HEAT] }
+      ),
+      minCoolSetpointLimit: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.CoolingComponent.attributes.minCoolSetpointLimit,
+        { optionalIf: [COOL] }
+      ),
+      maxCoolSetpointLimit: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.CoolingComponent.attributes.maxCoolSetpointLimit,
+        { optionalIf: [COOL] }
+      ),
+      minSetpointDeadBand: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.AutoModeComponent.attributes.minSetpointDeadBand,
+        { mandatoryIf: [AUTO] }
+      ),
+      thermostatRunningMode: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.AutoModeComponent.attributes.thermostatRunningMode,
+        { optionalIf: [AUTO] }
+      ),
+      startOfWeek: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.ScheduleConfigurationComponent.attributes.startOfWeek,
+        { mandatoryIf: [SCH] }
+      ),
+      numberOfWeeklyTransitions: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.ScheduleConfigurationComponent.attributes.numberOfWeeklyTransitions,
+        { mandatoryIf: [SCH] }
+      ),
+      numberOfDailyTransitions: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.ScheduleConfigurationComponent.attributes.numberOfDailyTransitions,
+        { mandatoryIf: [SCH] }
+      ),
+      occupiedSetback: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.SetbackComponent.attributes.occupiedSetback,
+        { mandatoryIf: [SB] }
+      ),
+      occupiedSetbackMin: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.SetbackComponent.attributes.occupiedSetbackMin,
+        { mandatoryIf: [SB] }
+      ),
+      occupiedSetbackMax: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.SetbackComponent.attributes.occupiedSetbackMax,
+        { mandatoryIf: [SB] }
+      ),
+      unoccupiedSetback: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.SetbackAndOccupancyComponent.attributes.unoccupiedSetback,
+        { mandatoryIf: [SB_OCC] }
+      ),
+      unoccupiedSetbackMin: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.SetbackAndOccupancyComponent.attributes.unoccupiedSetbackMin,
+        { mandatoryIf: [SB_OCC] }
+      ),
+      unoccupiedSetbackMax: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.SetbackAndOccupancyComponent.attributes.unoccupiedSetbackMax,
+        { mandatoryIf: [SB_OCC] }
+      )
+    },
+    commands: {
+      ...Thermostat2.Base.commands,
+      setWeeklySchedule: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.ScheduleConfigurationComponent.commands.setWeeklySchedule,
+        { mandatoryIf: [SCH] }
+      ),
+      getWeeklySchedule: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.ScheduleConfigurationComponent.commands.getWeeklySchedule,
+        { mandatoryIf: [SCH] }
+      ),
+      clearWeeklySchedule: import_MutableCluster.MutableCluster.AsConditional(
+        Thermostat2.ScheduleConfigurationComponent.commands.clearWeeklySchedule,
+        { mandatoryIf: [SCH] }
+      )
+    }
+  });
+  Thermostat2.Complete = Thermostat2.CompleteInstance;
+})(Thermostat || (Thermostat = {}));
+const ThermostatCluster = Thermostat.Cluster;
+import_ClusterRegistry.ClusterRegistry.register(Thermostat.Complete);
+//# sourceMappingURL=thermostat.js.map