Variable CompleteInstanceConst

Type declaration

• Readonlyattributes: {
      absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
          optional: true;
          optionalIf: [] | [{
              cooling: boolean;
          }];
      };
      absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
          optional: true;
          optionalIf: [] | [{
              heating: boolean;
          }];
      };
      absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
          optional: true;
          optionalIf: [] | [{
              cooling: boolean;
          }];
      };
      absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
          optional: true;
          optionalIf: [] | [{
              heating: boolean;
          }];
      };
      acCapacity: OptionalWritableAttribute<number, any>;
      acCapacityFormat: OptionalWritableAttribute<BtUh, any>;
      acCoilTemperature: OptionalAttribute<null | number, any>;
      acCompressorType: OptionalWritableAttribute<Thermostat.AcCompressorType, any>;
      acErrorCode: OptionalWritableAttribute<TypeFromPartialBitSchema<{
          coilSensorFail: BitFlag;
          compressorFail: BitFlag;
          fanFail: BitFlag;
          outdoorSensorFail: BitFlag;
          roomSensorFail: BitFlag;
      }>, any>;
      acLouverPosition: OptionalWritableAttribute<Thermostat.AcLouverPosition, any>;
      acRefrigerantType: OptionalWritableAttribute<Thermostat.AcRefrigerantType, any>;
      acType: OptionalWritableAttribute<Thermostat.AcType, any>;
      controlSequenceOfOperation: WritableAttribute<Thermostat.ControlSequenceOfOperation, any>;
      emergencyHeatDelta: OptionalWritableAttribute<number, any>;
      localTemperature: Attribute<null | number, any>;
      localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
          optional: true;
          optionalIf: [];
      };
      maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
          optional: true;
          optionalIf: [] | [{
              cooling: boolean;
          }];
      };
      maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
          optional: true;
          optionalIf: [] | [{
              heating: boolean;
          }];
      };
      minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
          optional: true;
          optionalIf: [] | [{
              cooling: boolean;
          }];
      };
      minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
          optional: true;
          optionalIf: [] | [{
              heating: boolean;
          }];
      };
      minSetpointDeadBand: WritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              autoMode: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      numberOfDailyTransitions: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              scheduleConfiguration: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      numberOfWeeklyTransitions: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              scheduleConfiguration: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      occupancy: Attribute<TypeFromPartialBitSchema<{
          occupied: BitFlag;
      }>, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              occupancy: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      occupiedCoolingSetpoint: WritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              cooling: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      occupiedHeatingSetpoint: WritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              heating: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      occupiedSetback: WritableAttribute<null | number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              setback: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      occupiedSetbackMax: FixedAttribute<null | number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              setback: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      occupiedSetbackMin: FixedAttribute<null | number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              setback: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      outdoorTemperature: OptionalAttribute<null | number, any>;
      piCoolingDemand: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
          optional: true;
          optionalIf: [] | [{
              cooling: boolean;
          }];
      };
      piHeatingDemand: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
          optional: true;
          optionalIf: [] | [{
              heating: boolean;
          }];
      };
      remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
          localTemperature: BitFlag;
          occupancy: BitFlag;
          outdoorTemperature: BitFlag;
      }>, any>;
      setpointChangeAmount: OptionalAttribute<null | number, any>;
      setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
      setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
      startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              scheduleConfiguration: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      systemMode: WritableAttribute<Thermostat.SystemMode, any>;
      temperatureSetpointHold: OptionalWritableAttribute<Thermostat.TemperatureSetpointHold, any>;
      temperatureSetpointHoldDuration: OptionalWritableAttribute<null | number, any>;
      thermostatProgrammingOperationMode: OptionalWritableAttribute<TypeFromPartialBitSchema<{
          autoRecovery: BitFlag;
          economy: BitFlag;
          scheduleActive: BitFlag;
      }>, any>;
      thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
          optional: true;
          optionalIf: [] | [{
              autoMode: boolean;
          }];
      };
      thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
          cool: BitFlag;
          coolStage2: BitFlag;
          fan: BitFlag;
          fanStage2: BitFlag;
          fanStage3: BitFlag;
          heat: BitFlag;
          heatStage2: BitFlag;
      }>, any>;
      unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              cooling: boolean;
              occupancy: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              heating: boolean;
              occupancy: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      unoccupiedSetback: WritableAttribute<null | number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              occupancy: boolean;
              setback: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              occupancy: boolean;
              setback: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              occupancy: boolean;
              setback: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
  }

  • ReadonlyabsMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    }

  • ReadonlyabsMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    }

  • ReadonlyabsMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    }

  • ReadonlyabsMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    }

  • ReadonlyacCapacity: OptionalWritableAttribute<number, any>

    Indicates capacity of Mini Split AC in terms of the format defined by the ACCapacityFormat attribute

    See

    MatterSpecification.v13.Cluster § 4.3.9.46

  • ReadonlyacCapacityFormat: OptionalWritableAttribute<BtUh, any>

    Indicates the format for the ACCapacity attribute.

    See

    MatterSpecification.v13.Cluster § 4.3.9.52

  • ReadonlyacCoilTemperature: OptionalAttribute<null | number, any>

    Indicates the temperature of the AC coil, as measured locally or remotely (over the network).

    See

    MatterSpecification.v13.Cluster § 4.3.9.51

  • ReadonlyacCompressorType: OptionalWritableAttribute<Thermostat.AcCompressorType, any>

    Indicates the type of compressor used within the Mini Split AC.

    See

    MatterSpecification.v13.Cluster § 4.3.9.48

  • ReadonlyacErrorCode: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        coilSensorFail: BitFlag;
        compressorFail: BitFlag;
        fanFail: BitFlag;
        outdoorSensorFail: BitFlag;
        roomSensorFail: BitFlag;
    }>, any>

    Indicates the type of errors encountered within the Mini Split AC.

    See

    MatterSpecification.v13.Cluster § 4.3.9.49

  • ReadonlyacLouverPosition: OptionalWritableAttribute<Thermostat.AcLouverPosition, any>

    Indicates the position of Louver on the AC.

    See

    MatterSpecification.v13.Cluster § 4.3.9.50

  • ReadonlyacRefrigerantType: OptionalWritableAttribute<Thermostat.AcRefrigerantType, any>

    Indicates type of refrigerant used within the Mini Split AC.

    See

    MatterSpecification.v13.Cluster § 4.3.9.47

  • ReadonlyacType: OptionalWritableAttribute<Thermostat.AcType, any>

    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

    MatterSpecification.v13.Cluster § 4.3.9.45

  • ReadonlycontrolSequenceOfOperation: WritableAttribute<Thermostat.ControlSequenceOfOperation, any>

    Indicates the overall operating environment of the thermostat, and thus the possible system modes that the thermostat can operate in.

    See

    MatterSpecification.v13.Cluster § 4.3.9.24

  • ReadonlyemergencyHeatDelta: OptionalWritableAttribute<number, any>

    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

    MatterSpecification.v13.Cluster § 4.3.9.44

  • ReadonlylocalTemperature: Attribute<null | number, any>

    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

    MatterSpecification.v13.Cluster § 4.3.9.3

  • ReadonlylocalTemperatureCalibration: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [];
    }

  • ReadonlymaxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    }

  • ReadonlymaxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    }

  • ReadonlyminCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    }

  • ReadonlyminHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    }

  • ReadonlyminSetpointDeadBand: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            autoMode: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlynumberOfDailyTransitions: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlynumberOfWeeklyTransitions: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • Readonlyoccupancy: Attribute<TypeFromPartialBitSchema<{
        occupied: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            occupancy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            cooling: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            heating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyoccupiedSetback: WritableAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyoccupiedSetbackMax: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyoccupiedSetbackMin: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyoutdoorTemperature: OptionalAttribute<null | number, any>

    Indicates the outdoor temperature, as measured locally or remotely (over the network).

    See

    MatterSpecification.v13.Cluster § 4.3.9.4

  • ReadonlypiCoolingDemand: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    }

  • ReadonlypiHeatingDemand: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    }

  • ReadonlyremoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        localTemperature: BitFlag;
        occupancy: BitFlag;
        outdoorTemperature: BitFlag;
    }>, any>

    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

    MatterSpecification.v13.Cluster § 4.3.9.23

  • ReadonlysetpointChangeAmount: OptionalAttribute<null | number, any>

    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

    MatterSpecification.v13.Cluster § 4.3.9.36

  • ReadonlysetpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>

    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

    MatterSpecification.v13.Cluster § 4.3.9.35

  • ReadonlysetpointChangeSourceTimestamp: OptionalAttribute<number, any>

    Indicates the time in UTC at which the SetpointChangeAmount attribute change was recorded.

    See

    MatterSpecification.v13.Cluster § 4.3.9.37

  • ReadonlystartOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlysystemMode: WritableAttribute<Thermostat.SystemMode, any>

    Indicates the current operating mode of the thermostat. Its value shall be limited by the ControlSequenceOfOperation attribute.

    See

    MatterSpecification.v13.Cluster § 4.3.9.25

  • ReadonlytemperatureSetpointHold: OptionalWritableAttribute<Thermostat.TemperatureSetpointHold, any>

    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

    MatterSpecification.v13.Cluster § 4.3.9.31

  • ReadonlytemperatureSetpointHoldDuration: OptionalWritableAttribute<null | number, any>

    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

    MatterSpecification.v13.Cluster § 4.3.9.32

  • ReadonlythermostatProgrammingOperationMode: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        autoRecovery: BitFlag;
        economy: BitFlag;
        scheduleActive: BitFlag;
    }>, any>

    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

    MatterSpecification.v13.Cluster § 4.3.9.33

  • ReadonlythermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            autoMode: boolean;
        }];
    }

  • ReadonlythermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
        cool: BitFlag;
        coolStage2: BitFlag;
        fan: BitFlag;
        fanStage2: BitFlag;
        fanStage3: BitFlag;
        heat: BitFlag;
        heatStage2: BitFlag;
    }>, any>

    Indicates the current relay state of the heat, cool, and fan relays. Unimplemented outputs shall be treated as if they were Off.

    See

    MatterSpecification.v13.Cluster § 4.3.9.34

  • ReadonlyunoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            cooling: boolean;
            occupancy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyunoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            heating: boolean;
            occupancy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyunoccupiedSetback: WritableAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            occupancy: boolean;
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyunoccupiedSetbackMax: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            occupancy: boolean;
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlyunoccupiedSetbackMin: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            occupancy: boolean;
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

• Readonlycommands: {
      clearWeeklySchedule: Command<void, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              scheduleConfiguration: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      getWeeklySchedule: Command<TypeFromFields<{
          daysToReturn: FieldType<TypeFromPartialBitSchema<{
              away: BitFlag;
              friday: BitFlag;
              monday: BitFlag;
              saturday: BitFlag;
              sunday: BitFlag;
              thursday: BitFlag;
              tuesday: BitFlag;
              wednesday: BitFlag;
          }>>;
          modeToReturn: FieldType<TypeFromPartialBitSchema<{
              coolSetpointPresent: BitFlag;
              heatSetpointPresent: BitFlag;
          }>>;
      }>, TypeFromFields<{
          dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
              away: BitFlag;
              friday: BitFlag;
              monday: BitFlag;
              saturday: BitFlag;
              sunday: BitFlag;
              thursday: BitFlag;
              tuesday: BitFlag;
              wednesday: BitFlag;
          }>>;
          modeForSequence: FieldType<TypeFromPartialBitSchema<{
              coolSetpointPresent: BitFlag;
              heatSetpointPresent: BitFlag;
          }>>;
          numberOfTransitionsForSequence: FieldType<number>;
          transitions: FieldType<TypeFromFields<{
              coolSetpoint: ...;
              heatSetpoint: ...;
              transitionTime: ...;
          }>[]>;
      }>, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              scheduleConfiguration: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
      setpointRaiseLower: Command<TypeFromFields<{
          amount: FieldType<number>;
          mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
      }>, void, any>;
      setWeeklySchedule: Command<TypeFromFields<{
          dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
              away: BitFlag;
              friday: BitFlag;
              monday: BitFlag;
              saturday: BitFlag;
              sunday: BitFlag;
              thursday: BitFlag;
              tuesday: BitFlag;
              wednesday: BitFlag;
          }>>;
          modeForSequence: FieldType<TypeFromPartialBitSchema<{
              coolSetpointPresent: BitFlag;
              heatSetpointPresent: BitFlag;
          }>>;
          numberOfTransitionsForSequence: FieldType<number>;
          transitions: FieldType<TypeFromFields<{
              coolSetpoint: ...;
              heatSetpoint: ...;
              transitionTime: ...;
          }>[]>;
      }>, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              scheduleConfiguration: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      };
  }

  • ReadonlyclearWeeklySchedule: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlygetWeeklySchedule: Command<TypeFromFields<{
        daysToReturn: FieldType<TypeFromPartialBitSchema<{
            away: BitFlag;
            friday: BitFlag;
            monday: BitFlag;
            saturday: BitFlag;
            sunday: BitFlag;
            thursday: BitFlag;
            tuesday: BitFlag;
            wednesday: BitFlag;
        }>>;
        modeToReturn: FieldType<TypeFromPartialBitSchema<{
            coolSetpointPresent: BitFlag;
            heatSetpointPresent: BitFlag;
        }>>;
    }>, TypeFromFields<{
        dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
            away: BitFlag;
            friday: BitFlag;
            monday: BitFlag;
            saturday: BitFlag;
            sunday: BitFlag;
            thursday: BitFlag;
            tuesday: BitFlag;
            wednesday: BitFlag;
        }>>;
        modeForSequence: FieldType<TypeFromPartialBitSchema<{
            coolSetpointPresent: BitFlag;
            heatSetpointPresent: BitFlag;
        }>>;
        numberOfTransitionsForSequence: FieldType<number>;
        transitions: FieldType<TypeFromFields<{
            coolSetpoint: ...;
            heatSetpoint: ...;
            transitionTime: ...;
        }>[]>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

  • ReadonlysetpointRaiseLower: Command<TypeFromFields<{
        amount: FieldType<number>;
        mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
    }>, void, any>

    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

    MatterSpecification.v13.Cluster § 4.3.10.1

  • ReadonlysetWeeklySchedule: Command<TypeFromFields<{
        dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
            away: BitFlag;
            friday: BitFlag;
            monday: BitFlag;
            saturday: BitFlag;
            sunday: BitFlag;
            thursday: BitFlag;
            tuesday: BitFlag;
            wednesday: BitFlag;
        }>>;
        modeForSequence: FieldType<TypeFromPartialBitSchema<{
            coolSetpointPresent: BitFlag;
            heatSetpointPresent: BitFlag;
        }>>;
        numberOfTransitionsForSequence: FieldType<number>;
        transitions: FieldType<TypeFromFields<{
            coolSetpoint: ...;
            heatSetpoint: ...;
            transitionTime: ...;
        }>[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

• Readonlyfeatures: {
      autoMode: BitFlag;
      cooling: BitFlag;
      heating: BitFlag;
      localTemperatureNotExposed: BitFlag;
      occupancy: BitFlag;
      scheduleConfiguration: BitFlag;
      setback: BitFlag;
  }

  • ReadonlyautoMode: BitFlag

    AutoMode

    Supports a System Mode of Auto

  • Readonlycooling: BitFlag

    Cooling

    Thermostat is capable of managing a cooling device

  • Readonlyheating: BitFlag

    Heating

    Thermostat is capable of managing a heating device

  • ReadonlylocalTemperatureNotExposed: BitFlag

    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

    MatterSpecification.v13.Cluster § 4.3.4.1

  • Readonlyoccupancy: BitFlag

    Occupancy

    Supports Occupied and Unoccupied setpoints

  • ReadonlyscheduleConfiguration: BitFlag

    ScheduleConfiguration

    Supports remote configuration of a weekly schedule of setpoint transitions

  • Readonlysetback: BitFlag

    Setback

    Supports configurable setback (or span)

• Readonlyid: 513

• Readonlyname: "Thermostat"

• Readonlyrevision: 6