homebridge-nest-accfactory 0.3.1 → 0.3.2

package/dist/plugins/thermostat.js

@@ -7,25 +7,32 @@
 // Define nodejs module requirements
 import path from 'node:path';
 import fs from 'node:fs';
-import { fileURLToPath } from 'node:url';
 
 // Define our modules
 import HomeKitDevice from '../HomeKitDevice.js';
+import { processCommonData, scaleValue, adjustTemperature } from '../utils.js';
 
 // Define constants
-const LOW_BATTERY_LEVEL = 10; // Low battery level percentage
-const MIN_TEMPERATURE = 9; // Minimum temperature for Nest Thermostat
-const MAX_TEMPERATURE = 32; // Maximum temperature for Nest Thermostat
-const __dirname = path.dirname(fileURLToPath(import.meta.url)); // Make a defined for JS __dirname
+import {
+  DATA_SOURCE,
+  THERMOSTAT_MIN_TEMPERATURE,
+  THERMOSTAT_MAX_TEMPERATURE,
+  LOW_BATTERY_LEVEL,
+  PROTOBUF_RESOURCES,
+  DAYS_OF_WEEK_FULL,
+  DAYS_OF_WEEK_SHORT,
+  __dirname,
+  DEVICE_TYPE,
+} from '../consts.js';
 
 export default class NestThermostat extends HomeKitDevice {
   static TYPE = 'Thermostat';
-  static VERSION = '2025.06.15';
+  static VERSION = '2025.08.07'; // Code version
 
+  thermostatService = undefined;
   batteryService = undefined;
   occupancyService = undefined;
   humidityService = undefined;
-  switchService = undefined; // Hotwater heating boost control
   fanService = undefined; // Fan control
   dehumidifierService = undefined; // dehumidifier (only) control
   externalCool = undefined; // External module function
@@ -33,18 +40,25 @@ export default class NestThermostat extends HomeKitDevice {
   externalFan = undefined; // External module function
   externalDehumidifier = undefined; // External module function
 
-  constructor(accessory, api, log, eventEmitter, deviceData) {
-    super(accessory, api, log, eventEmitter, deviceData);
-  }
-
   // Class functions
-  async setupDevice() {
-    // Setup the thermostat service if not already present on the accessory
-    this.thermostatService = this.addHKService(this.hap.Service.Thermostat, '', 1);
+  async onAdd() {
+    // Setup the thermostat service if not already present on the accessory, and link it to the Eve app if configured to do so
+    this.thermostatService = this.addHKService(this.hap.Service.Thermostat, '', 1, { messages: this.message.bind(this) });
     this.thermostatService.setPrimaryService();
 
     // Setup set characteristics
 
+    // Patch to avoid characteristic errors when setting initial property ranges
+    this.hap.Characteristic.TargetTemperature.prototype.getDefaultValue = () => {
+      return THERMOSTAT_MIN_TEMPERATURE; // start at minimum target temperature
+    };
+    this.hap.Characteristic.HeatingThresholdTemperature.prototype.getDefaultValue = () => {
+      return THERMOSTAT_MIN_TEMPERATURE; // start at minimum heating threshold
+    };
+    this.hap.Characteristic.CoolingThresholdTemperature.prototype.getDefaultValue = () => {
+      return THERMOSTAT_MAX_TEMPERATURE; // start at maximum cooling threshold
+    };
+
     // Used to indicate active temperature if the thermostat is using its temperature sensor data
     // or an external temperature sensor ie: Nest Temperature Sensor
     this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.StatusActive);
@@ -73,7 +87,7 @@ export default class NestThermostat extends HomeKitDevice {
         this.setDisplayUnit(value);
       },
       onGet: () => {
-        return this.deviceData.temperature_scale === 'C'
+        return this.deviceData.temperature_scale.toUpperCase() === 'C'
           ? this.hap.Characteristic.TemperatureDisplayUnits.CELSIUS
           : this.hap.Characteristic.TemperatureDisplayUnits.FAHRENHEIT;
       },
@@ -87,6 +101,11 @@ export default class NestThermostat extends HomeKitDevice {
     });
 
     this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.TargetTemperature, {
+      props: {
+        minStep: 0.5,
+        minValue: THERMOSTAT_MIN_TEMPERATURE,
+        maxValue: THERMOSTAT_MAX_TEMPERATURE,
+      },
       onSet: (value) => {
         this.setTemperature(this.hap.Characteristic.TargetTemperature, value);
       },
@@ -98,8 +117,8 @@ export default class NestThermostat extends HomeKitDevice {
     this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.CoolingThresholdTemperature, {
       props: {
         minStep: 0.5,
-        minValue: MIN_TEMPERATURE,
-        maxValue: MAX_TEMPERATURE,
+        minValue: THERMOSTAT_MIN_TEMPERATURE,
+        maxValue: THERMOSTAT_MAX_TEMPERATURE,
       },
       onSet: (value) => {
         this.setTemperature(this.hap.Characteristic.CoolingThresholdTemperature, value);
@@ -112,8 +131,8 @@ export default class NestThermostat extends HomeKitDevice {
     this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.HeatingThresholdTemperature, {
       props: {
         minStep: 0.5,
-        minValue: MIN_TEMPERATURE,
-        maxValue: MAX_TEMPERATURE,
+        minValue: THERMOSTAT_MIN_TEMPERATURE,
+        maxValue: THERMOSTAT_MAX_TEMPERATURE,
       },
       onSet: (value) => {
         this.setTemperature(this.hap.Characteristic.HeatingThresholdTemperature, value);
@@ -128,11 +147,11 @@ export default class NestThermostat extends HomeKitDevice {
         validValues:
           this.deviceData?.can_cool === true && this.deviceData?.can_heat === true
             ? [
-              this.hap.Characteristic.TargetHeatingCoolingState.OFF,
-              this.hap.Characteristic.TargetHeatingCoolingState.HEAT,
-              this.hap.Characteristic.TargetHeatingCoolingState.COOL,
-              this.hap.Characteristic.TargetHeatingCoolingState.AUTO,
-            ]
+                this.hap.Characteristic.TargetHeatingCoolingState.OFF,
+                this.hap.Characteristic.TargetHeatingCoolingState.HEAT,
+                this.hap.Characteristic.TargetHeatingCoolingState.COOL,
+                this.hap.Characteristic.TargetHeatingCoolingState.AUTO,
+              ]
             : this.deviceData?.can_heat === true
               ? [this.hap.Characteristic.TargetHeatingCoolingState.OFF, this.hap.Characteristic.TargetHeatingCoolingState.HEAT]
               : this.deviceData?.can_cool === true
@@ -211,32 +230,6 @@ export default class NestThermostat extends HomeKitDevice {
       this.humidityService = undefined;
     }
 
-    // Setup hotwater heating boost service if supported by the thermostat and not already present on the accessory
-    if (this.deviceData?.has_hot_water_control === true) {
-      this.#setupHotwaterBoost();
-    }
-    if (this.deviceData?.has_hot_water_control === false) {
-      // No longer have hotwater heating boost configured and service present, so removed it
-      this.switchService = this.accessory.getService(this.hap.Service.Switch);
-      if (this.switchService !== undefined) {
-        this.accessory.removeService(this.switchService);
-      }
-      this.switchService = undefined;
-    }
-
-    // Setup linkage to EveHome app if configured todo so
-    if (
-      this.deviceData?.eveHistory === true &&
-      this.thermostatService !== undefined &&
-      typeof this.historyService?.linkToEveHome === 'function'
-    ) {
-      this.historyService.linkToEveHome(this.thermostatService, {
-        description: this.deviceData.description,
-        getcommand: this.#EveHomeGetcommand.bind(this),
-        setcommand: this.#EveHomeSetcommand.bind(this),
-      });
-    }
-
     // Attempt to load any external modules for this thermostat
     // We support external cool/heat/fan/dehumidifier module functions
     // This is all undocumented on how to use, as its for my specific use case :-)
@@ -253,263 +246,26 @@ export default class NestThermostat extends HomeKitDevice {
     this.externalDehumidifier !== undefined && this.postSetupDetail('Using external dehumidification module');
   }
 
-  setFan(fanState, speed) {
-    if (
-      fanState !== this.fanService.getCharacteristic(this.hap.Characteristic.Active).value ||
-      speed !== this.fanService.getCharacteristic(this.hap.Characteristic.RotationSpeed).value
-    ) {
-      this.set({
-        uuid: this.deviceData.nest_google_uuid,
-        fan_state: fanState === this.hap.Characteristic.Active.ACTIVE ? true : false,
-        fan_timer_speed: Math.round((speed / 100) * this.deviceData.fan_max_speed),
-      });
-      this.fanService.updateCharacteristic(this.hap.Characteristic.Active, fanState);
-      this.fanService.updateCharacteristic(this.hap.Characteristic.RotationSpeed, speed);
-
-      this?.log?.info?.(
-        'Set fan on thermostat "%s" to "%s"',
-        this.deviceData.description,
-        fanState === this.hap.Characteristic.Active.ACTIVE ? 'On with fan speed of ' + speed + '%' : 'Off',
-      );
-    }
+  onRemove() {
+    this.accessory.removeService(this.thermostatService);
+    this.accessory.removeService(this.batteryService);
+    this.accessory.removeService(this.occupancyService);
+    this.accessory.removeService(this.humidityService);
+    this.accessory.removeService(this.fanService);
+    this.accessory.removeService(this.dehumidifierService);
+    this.thermostatService = undefined;
+    this.batteryService = undefined;
+    this.occupancyService = undefined;
+    this.humidityService = undefined;
+    this.fanService = undefined;
+    this.dehumidifierService = undefined;
+    this.externalCool = undefined;
+    this.externalHeat = undefined;
+    this.externalFan = undefined;
+    this.externalDehumidifier = undefined;
   }
 
-  setDehumidifier(dehumidiferState) {
-    this.set({
-      uuid: this.deviceData.nest_google_uuid,
-      dehumidifier_state: dehumidiferState === this.hap.Characteristic.Active.ACTIVE ? true : false,
-    });
-    this.dehumidifierService.updateCharacteristic(this.hap.Characteristic.Active, dehumidiferState);
-
-    this?.log?.info?.(
-      'Set dehumidifer on thermostat "%s" to "%s"',
-      this.deviceData.description,
-      dehumidiferState === this.hap.Characteristic.Active.ACTIVE
-        ? 'On with target humidity level of ' + this.deviceData.target_humidity + '%'
-        : 'Off',
-    );
-  }
-
-  setHotwaterBoost(hotwaterState) {
-    this.set({
-      uuid: this.deviceData.nest_google_uuid,
-      hot_water_boost_active: { state: hotwaterState === true, time: this.deviceData.hotWaterBoostTime },
-    });
-    this.switchService.updateCharacteristic(this.hap.Characteristic.On, hotwaterState);
-
-    this?.log?.info?.(
-      'Set hotwater boost heating on thermostat "%s" to "%s"',
-      this.deviceData.description,
-      hotwaterState === true ? 'On for ' + formatDuration(this.deviceData.hotWaterBoostTime) : 'Off',
-    );
-  }
-
-  setDisplayUnit(temperatureUnit) {
-    this.set({
-      uuid: this.deviceData.nest_google_uuid,
-      temperature_scale: temperatureUnit === this.hap.Characteristic.TemperatureDisplayUnits.CELSIUS ? 'C' : 'F',
-    });
-    this.thermostatService.updateCharacteristic(this.hap.Characteristic.TemperatureDisplayUnits, temperatureUnit);
-
-    this?.log?.info?.(
-      'Set temperature units on thermostat "%s" to "%s"',
-      this.deviceData.description,
-      temperatureUnit === this.hap.Characteristic.TemperatureDisplayUnits.CELSIUS ? '°C' : '°F',
-    );
-  }
-
-  setMode(thermostatMode) {
-    if (thermostatMode !== this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).value) {
-      // Work out based on the HomeKit requested mode, what can the thermostat really switch too
-      // We may over-ride the requested HomeKit mode
-      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.HEAT && this.deviceData.can_heat === false) {
-        thermostatMode = this.hap.Characteristic.TargetHeatingCoolingState.OFF;
-      }
-      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.COOL && this.deviceData.can_cool === false) {
-        thermostatMode = this.hap.Characteristic.TargetHeatingCoolingState.OFF;
-      }
-      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.AUTO) {
-        // Workaround for 'Hey Siri, turn on my thermostat'
-        // Appears to automatically request mode as 'auto', but we need to see what Nest device supports
-        if (this.deviceData.can_cool === true && this.deviceData.can_heat === false) {
-          thermostatMode = this.hap.Characteristic.TargetHeatingCoolingState.COOL;
-        }
-        if (this.deviceData.can_cool === false && this.deviceData.can_heat === true) {
-          thermostatMode = this.hap.Characteristic.TargetHeatingCoolingState.HEAT;
-        }
-        if (this.deviceData.can_cool === false && this.deviceData.can_heat === false) {
-          thermostatMode = this.hap.Characteristic.TargetHeatingCoolingState.OFF;
-        }
-      }
-
-      let mode = '';
-      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.OFF) {
-        this.thermostatService.updateCharacteristic(this.hap.Characteristic.TargetTemperature, this.deviceData.target_temperature);
-        this.thermostatService.updateCharacteristic(
-          this.hap.Characteristic.TargetHeatingCoolingState,
-          this.hap.Characteristic.TargetHeatingCoolingState.OFF,
-        );
-        mode = 'off';
-      }
-      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.COOL) {
-        this.thermostatService.updateCharacteristic(this.hap.Characteristic.TargetTemperature, this.deviceData.target_temperature_high);
-        this.thermostatService.updateCharacteristic(
-          this.hap.Characteristic.TargetHeatingCoolingState,
-          this.hap.Characteristic.TargetHeatingCoolingState.COOL,
-        );
-        mode = 'cool';
-      }
-      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.HEAT) {
-        this.thermostatService.updateCharacteristic(this.hap.Characteristic.TargetTemperature, this.deviceData.target_temperature_low);
-        this.thermostatService.updateCharacteristic(
-          this.hap.Characteristic.TargetHeatingCoolingState,
-          this.hap.Characteristic.TargetHeatingCoolingState.HEAT,
-        );
-        mode = 'heat';
-      }
-      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.AUTO) {
-        this.thermostatService.updateCharacteristic(
-          this.hap.Characteristic.TargetTemperature,
-          (this.deviceData.target_temperature_low + this.deviceData.target_temperature_high) * 0.5,
-        );
-        this.thermostatService.updateCharacteristic(
-          this.hap.Characteristic.TargetHeatingCoolingState,
-          this.hap.Characteristic.TargetHeatingCoolingState.AUTO,
-        );
-        mode = 'range';
-      }
-
-      this.set({ uuid: this.deviceData.nest_google_uuid, hvac_mode: mode });
-
-      this?.log?.info?.('Set mode on "%s" to "%s"', this.deviceData.description, mode);
-    }
-  }
-
-  getMode() {
-    let currentMode = null;
-
-    if (this.deviceData.hvac_mode.toUpperCase() === 'HEAT' || this.deviceData.hvac_mode.toUpperCase() === 'ECOHEAT') {
-      // heating mode, either eco or normal;
-      currentMode = this.hap.Characteristic.TargetHeatingCoolingState.HEAT;
-    }
-    if (this.deviceData.hvac_mode.toUpperCase() === 'COOL' || this.deviceData.hvac_mode.toUpperCase() === 'ECOCOOL') {
-      // cooling mode, either eco or normal
-      currentMode = this.hap.Characteristic.TargetHeatingCoolingState.COOL;
-    }
-    if (this.deviceData.hvac_mode.toUpperCase() === 'RANGE' || this.deviceData.hvac_mode.toUpperCase() === 'ECORANGE') {
-      // range mode, either eco or normal
-      currentMode = this.hap.Characteristic.TargetHeatingCoolingState.AUTO;
-    }
-    if (this.deviceData.hvac_mode.toUpperCase() === 'OFF' || (this.deviceData.can_cool === false && this.deviceData.can_heat === false)) {
-      // off mode or no heating or cooling capability
-      currentMode = this.hap.Characteristic.TargetHeatingCoolingState.OFF;
-    }
-
-    return currentMode;
-  }
-
-  setTemperature(characteristic, temperature) {
-    if (typeof characteristic === 'function' && typeof characteristic?.UUID === 'string') {
-      if (
-        characteristic.UUID === this.hap.Characteristic.TargetTemperature.UUID &&
-        this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).value !==
-          this.hap.Characteristic.TargetHeatingCoolingState.AUTO
-      ) {
-        this.set({ uuid: this.deviceData.nest_google_uuid, target_temperature: temperature });
-
-        this?.log?.info?.(
-          'Set %s%s temperature on "%s" to "%s °C"',
-          this.deviceData.hvac_mode.toUpperCase().includes('ECO') ? 'eco mode ' : '',
-          this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).value ===
-            this.hap.Characteristic.TargetHeatingCoolingState.HEAT
-            ? 'heating'
-            : 'cooling',
-          this.deviceData.description,
-          temperature,
-        );
-      }
-      if (
-        characteristic.UUID === this.hap.Characteristic.HeatingThresholdTemperature.UUID &&
-        this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).value ===
-          this.hap.Characteristic.TargetHeatingCoolingState.AUTO
-      ) {
-        this.set({ uuid: this.deviceData.nest_google_uuid, target_temperature_low: temperature });
-
-        this?.log?.info?.(
-          'Set %sheating temperature on "%s" to "%s °C"',
-          this.deviceData.hvac_mode.toUpperCase().includes('ECO') ? 'eco mode ' : '',
-          this.deviceData.description,
-          temperature,
-        );
-      }
-      if (
-        characteristic.UUID === this.hap.Characteristic.CoolingThresholdTemperature.UUID &&
-        this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).value ===
-          this.hap.Characteristic.TargetHeatingCoolingState.AUTO
-      ) {
-        this.set({ uuid: this.deviceData.nest_google_uuid, target_temperature_high: temperature });
-
-        this?.log?.info?.(
-          'Set %scooling temperature on "%s" to "%s °C"',
-          this.deviceData.hvac_mode.toUpperCase().includes('ECO') ? 'eco mode ' : '',
-          this.deviceData.description,
-          temperature,
-        );
-      }
-
-      this.thermostatService.updateCharacteristic(characteristic, temperature); // Update HomeKit with value
-    }
-  }
-
-  getTemperature(characteristic) {
-    let currentTemperature = null;
-
-    if (typeof characteristic === 'function' && typeof characteristic?.UUID === 'string') {
-      if (characteristic.UUID === this.hap.Characteristic.TargetTemperature.UUID) {
-        currentTemperature = this.deviceData.target_temperature;
-      }
-      if (characteristic.UUID === this.hap.Characteristic.HeatingThresholdTemperature.UUID) {
-        currentTemperature = this.deviceData.target_temperature_low;
-      }
-      if (characteristic.UUID === this.hap.Characteristic.CoolingThresholdTemperature.UUID) {
-        currentTemperature = this.deviceData.target_temperature_high;
-      }
-      if (currentTemperature < MIN_TEMPERATURE) {
-        currentTemperature = MIN_TEMPERATURE;
-      }
-      if (currentTemperature > MAX_TEMPERATURE) {
-        currentTemperature = MAX_TEMPERATURE;
-      }
-    }
-
-    return currentTemperature;
-  }
-
-  setChildlock(pin, value) {
-    // TODO - pincode setting when turning on.
-    // On REST API, writes to device.xxxxxxxx.temperature_lock_pin_hash. How is the hash calculated???
-    // Do we set temperature range limits when child lock on??
-
-    this.thermostatService.updateCharacteristic(this.hap.Characteristic.LockPhysicalControls, value); // Update HomeKit with value
-    if (value === this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_ENABLED) {
-      // Set pin hash????
-    }
-    if (value === this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_DISABLED) {
-      // Clear pin hash????
-    }
-    this.set({
-      uuid: this.deviceData.nest_google_uuid,
-      temperature_lock: value === this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_ENABLED ? true : false,
-    });
-
-    this?.log?.info?.(
-      'Setting Childlock on "%s" to "%s"',
-      this.deviceData.description,
-      value === this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_ENABLED ? 'Enabled' : 'Disabled',
-    );
-  }
-
-  updateDevice(deviceData) {
+  onUpdate(deviceData) {
     if (
       typeof deviceData !== 'object' ||
       this.thermostatService === undefined ||
@@ -545,7 +301,7 @@ export default class NestThermostat extends HomeKitDevice {
         : this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_DISABLED,
     );
 
-    // Update air filter sttaus if has been added
+    // Update air filter status if has been added
     if (this.thermostatService.testCharacteristic(this.hap.Characteristic.FilterChangeIndication) === true) {
       this.thermostatService.updateCharacteristic(
         this.hap.Characteristic.FilterChangeIndication,
@@ -629,36 +385,6 @@ export default class NestThermostat extends HomeKitDevice {
       );
     }
 
-    // Check for hotwater heating boost setup change on thermostat
-    if (deviceData.has_hot_water_control !== this.deviceData.has_hot_water_control) {
-      if (
-        deviceData.has_hot_water_control === true &&
-        this.deviceData.has_hot_water_control === false &&
-        this.switchService === undefined
-      ) {
-        // hotwater heating boost has been added
-        this.switchService = this.accessory.getService(this.hap.Service.Switch);
-        if (this.deviceData.has_hot_water_control === true) {
-          this.#setupHotwaterBoost();
-        }
-        if (
-          deviceData.has_hot_water_control === false &&
-          this.deviceData.has_hot_water_control === true &&
-          this.switchService !== undefined
-        ) {
-          // hotwater heating boost has been removed
-          this.accessory.removeService(this.switchService);
-          this.switchService = undefined;
-        }
-      }
-
-      this?.log?.info?.(
-        'hotwater heating boost setup on thermostat "%s" has changed. Hotwater heating boost was',
-        deviceData.description,
-        this.switchService === undefined ? 'removed' : 'added',
-      );
-    }
-
     if (deviceData.can_cool !== this.deviceData.can_cool || deviceData.can_heat !== this.deviceData.can_heat) {
       // Heating and/cooling setup has changed on thermostat
 
@@ -787,7 +513,7 @@ export default class NestThermostat extends HomeKitDevice {
         this.hap.Characteristic.CurrentHeatingCoolingState,
         this.hap.Characteristic.CurrentHeatingCoolingState.COOL,
       );
-      historyEntry.status = 3; // cooling
+      historyEntry.status = 1; // cooling
     }
     if (deviceData.hvac_state.toUpperCase() === 'OFF') {
       if (this.deviceData.hvac_state.toUpperCase() === 'COOLING' && typeof this.externalCool?.off === 'function') {
@@ -825,7 +551,12 @@ export default class NestThermostat extends HomeKitDevice {
         this.hap.Characteristic.Active,
         deviceData.fan_state === true ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE,
       );
-      historyEntry.status = 1; // fan
+
+      this.history(this.fanService, {
+        status: deviceData.fan_state === true ? 1 : 0,
+        temperature: deviceData.current_temperature,
+        humidity: deviceData.current_humidity,
+      });
     }
 
     if (this.dehumidifierService !== undefined) {
@@ -853,128 +584,336 @@ export default class NestThermostat extends HomeKitDevice {
         this.hap.Characteristic.Active,
         deviceData.dehumidifier_state === true ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE,
       );
-      historyEntry.status = 4; // dehumidifier
-    }
 
-    if (this.switchService !== undefined) {
-      // Hotwater boost status on or off
-      this.switchService.updateCharacteristic(this.hap.Characteristic.On, deviceData.hot_water_boost_active === true);
+      this.history(this.dehumidifierService, {
+        status: deviceData.dehumidifier_state === true ? 1 : 0,
+        temperature: deviceData.current_temperature,
+        humidity: deviceData.current_humidity,
+      });
     }
 
     // Log thermostat metrics to history only if changed to previous recording
-    if (this.thermostatService !== undefined && typeof this.historyService?.addHistory === 'function') {
-      let tempEntry = this.historyService.lastHistory(this.thermostatService);
-      if (
-        tempEntry === undefined ||
-        (typeof tempEntry === 'object' && tempEntry.status !== historyEntry.status) ||
-        tempEntry.temperature !== deviceData.current_temperature ||
-        JSON.stringify(tempEntry.target) !== JSON.stringify(historyEntry.target) ||
-        tempEntry.humidity !== deviceData.current_humidity
-      ) {
-        this.historyService.addHistory(this.thermostatService, {
-          time: Math.floor(Date.now() / 1000),
-          status: historyEntry.status,
-          temperature: deviceData.current_temperature,
-          target: historyEntry.target,
-          humidity: deviceData.current_humidity,
-        });
-      }
-    }
+    this.history(this.thermostatService, {
+      status: historyEntry.status,
+      temperature: deviceData.current_temperature,
+      target: historyEntry.target,
+      humidity: deviceData.current_humidity,
+    });
 
-    // Notify Eve App of device status changes if linked
-    if (
-      this.deviceData.eveHistory === true &&
-      this.thermostatService !== undefined &&
-      typeof this.historyService?.updateEveHome === 'function'
-    ) {
-      // Update our internal data with properties Eve will need to process
-      this.deviceData.online = deviceData.online;
-      this.deviceData.removed_from_base = deviceData.removed_from_base;
-      this.deviceData.vacation_mode = deviceData.vacation_mode;
-      this.deviceData.hvac_mode = deviceData.hvac_mode;
-      this.deviceData.schedules = deviceData.schedules;
-      this.deviceData.schedule_mode = deviceData.schedule_mode;
-      this.historyService.updateEveHome(this.thermostatService, this.#EveHomeGetcommand.bind(this));
-    }
+    // Update our internal data with properties Eve will need to process then Notify Eve App of device status changes if linked
+    this.deviceData.online = deviceData.online;
+    this.deviceData.removed_from_base = deviceData.removed_from_base;
+    this.deviceData.vacation_mode = deviceData.vacation_mode;
+    this.deviceData.hvac_mode = deviceData.hvac_mode;
+    this.deviceData.schedules = deviceData.schedules;
+    this.deviceData.schedule_mode = deviceData.schedule_mode;
+    this.historyService?.updateEveHome?.(this.thermostatService);
   }
 
-  #EveHomeGetcommand(EveHomeGetData) {
-    // Pass back extra data for Eve Thermo onGet() to process command
-    // Data will already be an object, our only job is to add/modify it
-    if (typeof EveHomeGetData === 'object') {
-      EveHomeGetData.enableschedule = this.deviceData.schedule_mode === 'heat'; // Schedules on/off
-      EveHomeGetData.attached = this.deviceData.online === true && this.deviceData.removed_from_base === false;
-      EveHomeGetData.vacation = this.deviceData.vacation_mode === true; //   Vaction mode on/off
-      EveHomeGetData.vacationtemp = this.deviceData.vacation_mode === true ? EveHomeGetData.vacationtemp : null;
-      EveHomeGetData.programs = []; // No programs yet, we'll process this below
-      if (this.deviceData.schedule_mode.toUpperCase() === 'HEAT' || this.deviceData.schedule_mode.toUpperCase() === 'RANGE') {
-        const DAYSOFWEEK = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
-
-        Object.entries(this.deviceData.schedules).forEach(([day, schedules]) => {
+  onMessage(type, message) {
+    if (typeof type !== 'string' || type === '' || message === null || typeof message !== 'object' || message?.constructor !== Object) {
+      return;
+    }
+
+    if (type === HomeKitDevice?.EVEHOME?.GET) {
+      // Extend Eve Thermo GET payload with device state
+      message.enableschedule = this.deviceData.schedule_mode === 'heat';
+      message.attached = this.deviceData.online === true && this.deviceData.removed_from_base === false;
+      message.vacation = this.deviceData.vacation_mode === true;
+      message.programs = [];
+
+      if (['HEAT', 'RANGE'].includes(this.deviceData.schedule_mode?.toUpperCase?.()) === true) {
+        Object.entries(this.deviceData.schedules || {}).forEach(([day, entries]) => {
           let tempSchedule = [];
           let tempTemperatures = [];
-          Object.values(schedules)
-            .reverse()
-            .forEach((schedule) => {
-              if (schedule.entry_type === 'setpoint' && (schedule.type === 'HEAT' || schedule.type === 'RANGE')) {
-                tempSchedule.push({
-                  start: schedule.time,
-                  duration: 0,
-                  temperature: typeof schedule['temp-min'] === 'number' ? schedule['temp-min'] : schedule.temp,
-                });
-                tempTemperatures.push(typeof schedule['temp-min'] === 'number' ? schedule['temp-min'] : schedule.temp);
-              }
-            });
 
-          // Sort the schedule array by start time
-          tempSchedule = tempSchedule.sort((a, b) => {
-            if (a.start < b.start) {
-              return -1;
+          Object.values(entries || {}).forEach((schedule) => {
+            if (schedule.entry_type === 'setpoint' && ['HEAT', 'RANGE'].includes(schedule.type)) {
+              let temp = typeof schedule['temp-min'] === 'number' ? schedule['temp-min'] : schedule.temp;
+              tempSchedule.push({ start: schedule.time, duration: 0, temperature: temp });
+              tempTemperatures.push(temp);
             }
           });
 
+          tempSchedule.sort((a, b) => a.start - b.start);
+
           let ecoTemp = tempTemperatures.length === 0 ? 0 : Math.min(...tempTemperatures);
           let comfortTemp = tempTemperatures.length === 0 ? 0 : Math.max(...tempTemperatures);
-          let program = {};
-          program.id = parseInt(day) + 1;
-          program.days = DAYSOFWEEK[day];
-          program.schedule = [];
-          let lastTime = 86400; // seconds in a day
-          Object.values(tempSchedule)
-            .reverse()
-            .forEach((schedule) => {
-              if (schedule.temperature === comfortTemp) {
-                // We only want to add the schedule time if its using the 'max' temperature
-                program.schedule.push({
-                  start: schedule.start,
-                  duration: lastTime - schedule.start,
-                  ecotemp: ecoTemp,
-                  comforttemp: comfortTemp,
-                });
-              }
-              lastTime = schedule.start;
-            });
-          EveHomeGetData.programs.push(program);
+
+          let program = {
+            id: parseInt(day),
+            days: isNaN(day) === false && DAYS_OF_WEEK_SHORT?.[day] !== undefined ? DAYS_OF_WEEK_SHORT[day].toLowerCase() : 'mon',
+            schedule: [],
+          };
+
+          let lastTime = 86400;
+          [...tempSchedule].reverse().forEach((entry) => {
+            if (entry.temperature === comfortTemp) {
+              program.schedule.push({
+                start: entry.start,
+                duration: lastTime - entry.start,
+                ecotemp: ecoTemp,
+                comforttemp: comfortTemp,
+              });
+            }
+            lastTime = entry.start;
+          });
+
+          message.programs.push(program);
         });
       }
+
+      return message;
+    }
+
+    if (type === HomeKitDevice?.EVEHOME?.SET) {
+      if (typeof message?.vacation?.status === 'boolean') {
+        this.message(HomeKitDevice.SET, { uuid: this.deviceData.nest_google_uuid, vacation_mode: message.vacation.status });
+      }
+
+      if (typeof message?.programs === 'object') {
+        // Future: convert to Nest format and apply via .set()
+        // this.message(HomeKitDevice.SET, { uuid: ..., days: { ... } });
+      }
     }
-    return EveHomeGetData;
   }
 
-  #EveHomeSetcommand(EveHomeSetData) {
-    if (typeof EveHomeSetData !== 'object') {
+  setFan(fanState, speed) {
+    let currentState = this.fanService.getCharacteristic(this.hap.Characteristic.Active).value;
+    let currentSpeed = this.fanService.getCharacteristic(this.hap.Characteristic.RotationSpeed).value;
+
+    if (fanState !== currentState || speed !== currentSpeed) {
+      let isActive = fanState === this.hap.Characteristic.Active.ACTIVE;
+      let scaledSpeed = Math.round((speed / 100) * this.deviceData.fan_max_speed);
+
+      this.message(HomeKitDevice.SET, {
+        uuid: this.deviceData.nest_google_uuid,
+        fan_state: isActive,
+        fan_timer_speed: scaledSpeed,
+      });
+
+      this.fanService.updateCharacteristic(this.hap.Characteristic.Active, fanState);
+      this.fanService.updateCharacteristic(this.hap.Characteristic.RotationSpeed, speed);
+
+      this?.log?.info?.(
+        'Set fan on thermostat "%s" to "%s"',
+        this.deviceData.description,
+        isActive ? 'On with fan speed of ' + speed + '%' : 'Off',
+      );
+    }
+  }
+
+  setDehumidifier(dehumidiferState) {
+    let isActive = dehumidiferState === this.hap.Characteristic.Active.ACTIVE;
+
+    this.message(HomeKitDevice.SET, {
+      uuid: this.deviceData.nest_google_uuid,
+      dehumidifier_state: isActive,
+    });
+
+    this.dehumidifierService.updateCharacteristic(this.hap.Characteristic.Active, dehumidiferState);
+
+    this?.log?.info?.(
+      'Set dehumidifer on thermostat "%s" to "%s"',
+      this.deviceData.description,
+      isActive ? 'On with target humidity level of ' + this.deviceData.target_humidity + '%' : 'Off',
+    );
+  }
+
+  setDisplayUnit(temperatureUnit) {
+    let unit = temperatureUnit === this.hap.Characteristic.TemperatureDisplayUnits.CELSIUS ? 'C' : 'F';
+
+    this.message(HomeKitDevice.SET, {
+      uuid: this.deviceData.nest_google_uuid,
+      temperature_scale: unit,
+    });
+
+    this.thermostatService.updateCharacteristic(this.hap.Characteristic.TemperatureDisplayUnits, temperatureUnit);
+
+    this?.log?.info?.('Set temperature units on thermostat "%s" to "%s"', this.deviceData.description, unit === 'C' ? '°C' : '°F');
+  }
+
+  setMode(thermostatMode) {
+    if (thermostatMode !== this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).value) {
+      // Work out based on the HomeKit requested mode, what can the thermostat really switch too
+      // We may over-ride the requested HomeKit mode
+      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.HEAT && this.deviceData.can_heat === false) {
+        thermostatMode = this.hap.Characteristic.TargetHeatingCoolingState.OFF;
+      }
+      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.COOL && this.deviceData.can_cool === false) {
+        thermostatMode = this.hap.Characteristic.TargetHeatingCoolingState.OFF;
+      }
+      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.AUTO) {
+        // Workaround for 'Hey Siri, turn on my thermostat'
+        // Appears to automatically request mode as 'auto', but we need to see what Nest device supports
+        if (this.deviceData.can_cool === true && this.deviceData.can_heat === false) {
+          thermostatMode = this.hap.Characteristic.TargetHeatingCoolingState.COOL;
+        }
+        if (this.deviceData.can_cool === false && this.deviceData.can_heat === true) {
+          thermostatMode = this.hap.Characteristic.TargetHeatingCoolingState.HEAT;
+        }
+        if (this.deviceData.can_cool === false && this.deviceData.can_heat === false) {
+          thermostatMode = this.hap.Characteristic.TargetHeatingCoolingState.OFF;
+        }
+      }
+
+      let mode = '';
+      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.OFF) {
+        this.thermostatService.updateCharacteristic(this.hap.Characteristic.TargetTemperature, this.deviceData.target_temperature);
+        this.thermostatService.updateCharacteristic(
+          this.hap.Characteristic.TargetHeatingCoolingState,
+          this.hap.Characteristic.TargetHeatingCoolingState.OFF,
+        );
+        mode = 'off';
+      }
+      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.COOL) {
+        this.thermostatService.updateCharacteristic(this.hap.Characteristic.TargetTemperature, this.deviceData.target_temperature_high);
+        this.thermostatService.updateCharacteristic(
+          this.hap.Characteristic.TargetHeatingCoolingState,
+          this.hap.Characteristic.TargetHeatingCoolingState.COOL,
+        );
+        mode = 'cool';
+      }
+      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.HEAT) {
+        this.thermostatService.updateCharacteristic(this.hap.Characteristic.TargetTemperature, this.deviceData.target_temperature_low);
+        this.thermostatService.updateCharacteristic(
+          this.hap.Characteristic.TargetHeatingCoolingState,
+          this.hap.Characteristic.TargetHeatingCoolingState.HEAT,
+        );
+        mode = 'heat';
+      }
+      if (thermostatMode === this.hap.Characteristic.TargetHeatingCoolingState.AUTO) {
+        this.thermostatService.updateCharacteristic(
+          this.hap.Characteristic.TargetTemperature,
+          (this.deviceData.target_temperature_low + this.deviceData.target_temperature_high) * 0.5,
+        );
+        this.thermostatService.updateCharacteristic(
+          this.hap.Characteristic.TargetHeatingCoolingState,
+          this.hap.Characteristic.TargetHeatingCoolingState.AUTO,
+        );
+        mode = 'range';
+      }
+
+      this.message(HomeKitDevice.SET, { uuid: this.deviceData.nest_google_uuid, hvac_mode: mode });
+
+      this?.log?.info?.('Set mode on "%s" to "%s"', this.deviceData.description, mode);
+    }
+  }
+
+  getMode() {
+    let currentMode = null;
+    let mode = this.deviceData.hvac_mode.toUpperCase();
+
+    if (mode === 'HEAT' || mode === 'ECOHEAT') {
+      // heating mode, either eco or normal
+      currentMode = this.hap.Characteristic.TargetHeatingCoolingState.HEAT;
+    }
+    if (mode === 'COOL' || mode === 'ECOCOOL') {
+      // cooling mode, either eco or normal
+      currentMode = this.hap.Characteristic.TargetHeatingCoolingState.COOL;
+    }
+    if (mode === 'RANGE' || mode === 'ECORANGE') {
+      // range mode, either eco or normal
+      currentMode = this.hap.Characteristic.TargetHeatingCoolingState.AUTO;
+    }
+    if (mode === 'OFF' || (this.deviceData.can_cool === false && this.deviceData.can_heat === false)) {
+      // off mode or no heating or cooling capability
+      currentMode = this.hap.Characteristic.TargetHeatingCoolingState.OFF;
+    }
+
+    return currentMode;
+  }
+
+  setTemperature(characteristic, temperature) {
+    if (typeof characteristic !== 'function' || typeof characteristic?.UUID !== 'string') {
       return;
     }
 
-    if (typeof EveHomeSetData?.vacation === 'boolean') {
-      this.set({ uuid: this.deviceData.nest_google_uuid, vacation_mode: EveHomeSetData.vacation.status });
+    let mode = this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).value;
+    let isEco = this.deviceData.hvac_mode?.toUpperCase?.().includes('ECO') === true;
+    let scale = this.deviceData.temperature_scale?.toUpperCase?.() === 'F' ? 'F' : 'C';
+    let tempDisplay = (scale === 'F' ? (temperature * 9) / 5 + 32 : temperature).toFixed(1);
+    let tempUnit = scale === 'F' ? '°F' : '°C';
+    let ecoPrefix = isEco ? 'eco mode ' : '';
+
+    let targetKey = undefined;
+    let modeLabel = '';
+
+    if (
+      characteristic.UUID === this.hap.Characteristic.TargetTemperature.UUID &&
+      mode !== this.hap.Characteristic.TargetHeatingCoolingState.AUTO
+    ) {
+      targetKey = 'target_temperature';
+      modeLabel = mode === this.hap.Characteristic.TargetHeatingCoolingState.HEAT ? 'heating' : 'cooling';
+    } else if (
+      characteristic.UUID === this.hap.Characteristic.HeatingThresholdTemperature.UUID &&
+      mode === this.hap.Characteristic.TargetHeatingCoolingState.AUTO
+    ) {
+      targetKey = 'target_temperature_low';
+      modeLabel = 'heating';
+    } else if (
+      characteristic.UUID === this.hap.Characteristic.CoolingThresholdTemperature.UUID &&
+      mode === this.hap.Characteristic.TargetHeatingCoolingState.AUTO
+    ) {
+      targetKey = 'target_temperature_high';
+      modeLabel = 'cooling';
     }
-    if (typeof EveHomeSetData?.programs === 'object') {
-      //EveHomeSetData.programs.forEach((day) => {
-      // Convert into Nest thermostat schedule format and set. Need to work this out
-      //  this.set({ uuid: this.deviceData.nest_google_uuid, days: { 6: { temp: 17, time: 13400, touched_at: Date.now() } } });
-      //});
+
+    if (targetKey !== undefined) {
+      this.message(HomeKitDevice.SET, { uuid: this.deviceData.nest_google_uuid, [targetKey]: temperature });
+      this?.log?.info?.(
+        'Set %s%s temperature on "%s" to "%s %s"',
+        ecoPrefix,
+        modeLabel,
+        this.deviceData.description,
+        tempDisplay,
+        tempUnit,
+      );
     }
+
+    this.thermostatService.updateCharacteristic(characteristic, temperature);
+  }
+
+  getTemperature(characteristic) {
+    if (typeof characteristic !== 'function' || typeof characteristic?.UUID !== 'string') {
+      return null;
+    }
+
+    let currentTemperature = {
+      [this.hap.Characteristic.TargetTemperature.UUID]: this.deviceData.target_temperature,
+      [this.hap.Characteristic.HeatingThresholdTemperature.UUID]: this.deviceData.target_temperature_low,
+      [this.hap.Characteristic.CoolingThresholdTemperature.UUID]: this.deviceData.target_temperature_high,
+    }[characteristic.UUID];
+
+    if (isNaN(currentTemperature) === false) {
+      currentTemperature = Math.min(Math.max(currentTemperature, THERMOSTAT_MIN_TEMPERATURE), THERMOSTAT_MAX_TEMPERATURE);
+    }
+
+    return currentTemperature;
+  }
+
+  setChildlock(pin, value) {
+    // TODO - pincode setting when turning on.
+    // On REST API, writes to device.xxxxxxxx.temperature_lock_pin_hash. How is the hash calculated???
+    // Do we set temperature range limits when child lock on??
+
+    this.thermostatService.updateCharacteristic(this.hap.Characteristic.LockPhysicalControls, value); // Update HomeKit with value
+    if (value === this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_ENABLED) {
+      // Set pin hash????
+    }
+    if (value === this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_DISABLED) {
+      // Clear pin hash????
+    }
+    this.message(HomeKitDevice.SET, {
+      uuid: this.deviceData.nest_google_uuid,
+      temperature_lock: value === this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_ENABLED ? true : false,
+    });
+
+    this?.log?.info?.(
+      'Setting Childlock on "%s" to "%s"',
+      this.deviceData.description,
+      value === this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_ENABLED ? 'Enabled' : 'Disabled',
+    );
   }
 
   #setupFan() {
@@ -1020,18 +959,6 @@ export default class NestThermostat extends HomeKitDevice {
     });
   }
 
-  #setupHotwaterBoost() {
-    this.switchService = this.addHKService(this.hap.Service.Switch, '', 1);
-    this.thermostatService.addLinkedService(this.switchService);
-
-    this.addHKCharacteristic(this.switchService, this.hap.Characteristic.On, {
-      onSet: (value) => this.setHotwaterBoost(value),
-      onGet: () => {
-        return this.deviceData?.hot_water_boost_active === true;
-      },
-    });
-  }
-
   async #loadExternalModule(module, expectedFunctions = []) {
     if (typeof module !== 'string' || module === '' || Array.isArray(expectedFunctions) === false) {
       return undefined;
@@ -1084,9 +1011,9 @@ export default class NestThermostat extends HomeKitDevice {
       let shortName =
         typeof module === 'string'
           ? module
-            .trim()
-            .match(/'[^']*'|[^\s]+/)?.[0]
-            ?.replace(/^'(.*)'$/, '$1')
+              .trim()
+              .match(/'[^']*'|[^\s]+/)?.[0]
+              ?.replace(/^'(.*)'$/, '$1')
           : '';
       this?.log?.warn?.('Failed to load external module "%s" for thermostat "%s"', shortName, this.deviceData.description);
     }
@@ -1095,8 +1022,517 @@ export default class NestThermostat extends HomeKitDevice {
   }
 }
 
-function formatDuration(seconds) {
-  return `${
-    seconds >= 3600 ? `${Math.floor(seconds / 3600)} hr${Math.floor(seconds / 3600) > 1 ? 's' : ''} ` : ''
-  }${Math.floor((seconds % 3600) / 60)} min${Math.floor((seconds % 3600) / 60) !== 1 ? 's' : ''}`;
+// Function to process our RAW Nest or Google for this device type
+export function processRawData(log, rawData, config, deviceType = undefined) {
+  if (
+    rawData === null ||
+    typeof rawData !== 'object' ||
+    rawData?.constructor !== Object ||
+    typeof config !== 'object' ||
+    config?.constructor !== Object
+  ) {
+    return;
+  }
+
+  const process_thermostat_data = (object_key, data) => {
+    let processed = {};
+    try {
+      // Fix up data we need to
+
+      // If we have hot water control, it should be a 'UK/EU' model, so add that after the 'gen' tag in the model name
+      data.model = data.has_hot_water_control === true ? data.model.replace(/\bgen\)/, 'gen, EU)') : data.model;
+
+      data = processCommonData(object_key, data, config);
+      data.target_temperature_high = adjustTemperature(data.target_temperature_high, 'C', 'C', true);
+      data.target_temperature_low = adjustTemperature(data.target_temperature_low, 'C', 'C', true);
+      data.target_temperature = adjustTemperature(data.target_temperature, 'C', 'C', true);
+      data.backplate_temperature = adjustTemperature(data.backplate_temperature, 'C', 'C', true);
+      data.current_temperature = adjustTemperature(data.current_temperature, 'C', 'C', true);
+      data.battery_level = scaleValue(data.battery_level, 3.6, 3.9, 0, 100);
+
+      processed = data;
+      // eslint-disable-next-line no-unused-vars
+    } catch (error) {
+      // Empty
+    }
+    return processed;
+  };
+
+  // Process data for any thermostat(s) we have in the raw data
+  let devices = {};
+  Object.entries(rawData)
+    .filter(
+      ([key, value]) =>
+        key.startsWith('device.') === true ||
+        (key.startsWith('DEVICE_') === true && PROTOBUF_RESOURCES.THERMOSTAT.includes(value.value?.device_info?.typeName) === true),
+    )
+    .forEach(([object_key, value]) => {
+      let tempDevice = {};
+      try {
+        if (
+          value?.source === DATA_SOURCE.GOOGLE &&
+          value.value?.configuration_done?.deviceReady === true &&
+          rawData?.[value.value?.device_info?.pairerId?.resourceId] !== undefined
+        ) {
+          let RESTTypeData = {};
+          RESTTypeData.type = DEVICE_TYPE.THERMOSTAT;
+          RESTTypeData.model = 'Thermostat (unknown)';
+          if (value.value.device_info.typeName === 'nest.resource.NestLearningThermostat1Resource') {
+            RESTTypeData.model = 'Learning Thermostat (1st gen)';
+          }
+          if (
+            value.value.device_info.typeName === 'nest.resource.NestLearningThermostat2Resource' ||
+            value.value.device_info.typeName === 'nest.resource.NestAmber1DisplayResource'
+          ) {
+            RESTTypeData.model = 'Learning Thermostat (2nd gen)';
+          }
+          if (
+            value.value.device_info.typeName === 'nest.resource.NestLearningThermostat3Resource' ||
+            value.value.device_info.typeName === 'nest.resource.NestAmber2DisplayResource'
+          ) {
+            RESTTypeData.model = 'Learning Thermostat (3rd gen)';
+          }
+          if (value.value.device_info.typeName === 'google.resource.GoogleBismuth1Resource') {
+            RESTTypeData.model = 'Learning Thermostat (4th gen)';
+          }
+          if (
+            value.value.device_info.typeName === 'nest.resource.NestOnyxResource' ||
+            value.value.device_info.typeName === 'nest.resource.NestAgateDisplayResource'
+          ) {
+            RESTTypeData.model = 'Thermostat E (1st gen)';
+          }
+          if (value.value.device_info.typeName === 'google.resource.GoogleZirconium1Resource') {
+            RESTTypeData.model = 'Thermostat (2020)';
+          }
+          RESTTypeData.softwareVersion = value.value.device_identity.softwareVersion;
+          RESTTypeData.serialNumber = value.value.device_identity.serialNumber;
+          RESTTypeData.description = String(value.value?.label?.label ?? '');
+          RESTTypeData.location = String(
+            [
+              ...Object.values(
+                rawData?.[value.value?.device_info?.pairerId?.resourceId]?.value?.located_annotations?.predefinedWheres || {},
+              ),
+              ...Object.values(rawData?.[value.value?.device_info?.pairerId?.resourceId]?.value?.located_annotations?.customWheres || {}),
+            ].find((where) => where?.whereId?.resourceId === value.value?.device_located_settings?.whereAnnotationRid?.resourceId)?.label
+              ?.literal ?? '',
+          );
+          RESTTypeData.current_humidity =
+            isNaN(value.value?.current_humidity?.humidityValue?.humidity?.value) === false
+              ? Number(value.value.current_humidity.humidityValue.humidity.value)
+              : 0.0;
+          RESTTypeData.temperature_scale = value.value?.display_settings?.temperatureScale === 'TEMPERATURE_SCALE_F' ? 'F' : 'C';
+          RESTTypeData.removed_from_base =
+            Array.isArray(value.value?.display?.thermostatState) === true && value.value.display.thermostatState.includes('bpd') === true;
+          RESTTypeData.backplate_temperature = parseFloat(value.value.backplate_temperature.temperatureValue.temperature.value);
+          RESTTypeData.current_temperature = parseFloat(value.value.current_temperature.temperatureValue.temperature.value);
+          RESTTypeData.battery_level = parseFloat(value.value.battery_voltage.batteryValue.batteryVoltage.value);
+          RESTTypeData.online = value.value?.liveness?.status === 'LIVENESS_DEVICE_STATUS_ONLINE';
+          RESTTypeData.leaf = value.value?.leaf?.active === true;
+          RESTTypeData.can_cool =
+            value.value?.hvac_equipment_capabilities?.hasStage1Cool === true ||
+            value.value?.hvac_equipment_capabilities?.hasStage2Cool === true ||
+            value.value?.hvac_equipment_capabilities?.hasStage3Cool === true;
+          RESTTypeData.can_heat =
+            value.value?.hvac_equipment_capabilities?.hasStage1Heat === true ||
+            value.value?.hvac_equipment_capabilities?.hasStage2Heat === true ||
+            value.value?.hvac_equipment_capabilities?.hasStage3Heat === true;
+          RESTTypeData.temperature_lock = value.value?.temperature_lock_settings?.enabled === true;
+          RESTTypeData.temperature_lock_pin_hash =
+            value.value?.temperature_lock_settings?.enabled === true ? value.value.temperature_lock_settings.pinHash : '';
+          RESTTypeData.away = value.value?.structure_mode?.structureMode === 'STRUCTURE_MODE_AWAY';
+          RESTTypeData.occupancy = value.value?.structure_mode?.structureMode === 'STRUCTURE_MODE_HOME';
+          //RESTTypeData.occupancy = (value.value.structure_mode.occupancy.activity === 'ACTIVITY_ACTIVE');
+          RESTTypeData.vacation_mode = value.value?.structure_mode?.structureMode === 'STRUCTURE_MODE_VACATION';
+
+          // Work out current mode. ie: off, cool, heat, range and get temperature low/high and target
+          RESTTypeData.hvac_mode =
+            value.value?.target_temperature_settings?.enabled?.value === true &&
+            value.value?.target_temperature_settings?.targetTemperature?.setpointType !== undefined
+              ? value.value.target_temperature_settings.targetTemperature.setpointType.split('SET_POINT_TYPE_')[1].toLowerCase()
+              : 'off';
+          RESTTypeData.target_temperature_low =
+            isNaN(value.value?.target_temperature_settings?.targetTemperature?.heatingTarget?.value) === false
+              ? Number(value.value.target_temperature_settings.targetTemperature.heatingTarget.value)
+              : 0.0;
+          RESTTypeData.target_temperature_high =
+            isNaN(value.value?.target_temperature_settings?.targetTemperature?.coolingTarget?.value) === false
+              ? Number(value.value.target_temperature_settings.targetTemperature.coolingTarget.value)
+              : 0.0;
+          RESTTypeData.target_temperature =
+            value.value?.target_temperature_settings?.targetTemperature?.setpointType === 'SET_POINT_TYPE_COOL' &&
+            isNaN(value.value?.target_temperature_settings?.targetTemperature?.coolingTarget?.value) === false
+              ? Number(value.value.target_temperature_settings.targetTemperature.coolingTarget.value)
+              : value.value?.target_temperature_settings?.targetTemperature?.setpointType === 'SET_POINT_TYPE_HEAT' &&
+                  isNaN(value.value?.target_temperature_settings?.targetTemperature?.heatingTarget?.value) === false
+                ? Number(value.value.target_temperature_settings.targetTemperature.heatingTarget.value)
+                : value.value?.target_temperature_settings?.targetTemperature?.setpointType === 'SET_POINT_TYPE_RANGE' &&
+                    isNaN(value.value?.target_temperature_settings?.targetTemperature?.coolingTarget?.value) === false &&
+                    isNaN(value.value?.target_temperature_settings?.targetTemperature?.heatingTarget?.value) === false
+                  ? (Number(value.value.target_temperature_settings.targetTemperature.coolingTarget.value) +
+                      Number(value.value.target_temperature_settings.targetTemperature.heatingTarget.value)) *
+                    0.5
+                  : 0.0;
+
+          // Work out if eco mode is active and adjust temperature low/high and target
+          if (value.value?.eco_mode_state?.ecoMode !== 'ECO_MODE_INACTIVE') {
+            RESTTypeData.target_temperature_low = value.value.eco_mode_settings.ecoTemperatureHeat.value.value;
+            RESTTypeData.target_temperature_high = value.value.eco_mode_settings.ecoTemperatureCool.value.value;
+            if (
+              value.value.eco_mode_settings.ecoTemperatureHeat.enabled === true &&
+              value.value.eco_mode_settings.ecoTemperatureCool.enabled === false
+            ) {
+              RESTTypeData.target_temperature = value.value.eco_mode_settings.ecoTemperatureHeat.value.value;
+              RESTTypeData.hvac_mode = 'ecoheat';
+            }
+            if (
+              value.value.eco_mode_settings.ecoTemperatureHeat.enabled === false &&
+              value.value.eco_mode_settings.ecoTemperatureCool.enabled === true
+            ) {
+              RESTTypeData.target_temperature = value.value.eco_mode_settings.ecoTemperatureCool.value.value;
+              RESTTypeData.hvac_mode = 'ecocool';
+            }
+            if (
+              value.value.eco_mode_settings.ecoTemperatureHeat.enabled === true &&
+              value.value.eco_mode_settings.ecoTemperatureCool.enabled === true
+            ) {
+              RESTTypeData.target_temperature =
+                (value.value.eco_mode_settings.ecoTemperatureCool.value.value +
+                  value.value.eco_mode_settings.ecoTemperatureHeat.value.value) *
+                0.5;
+              RESTTypeData.hvac_mode = 'ecorange';
+            }
+          }
+
+          // Work out current state ie: heating, cooling etc
+          RESTTypeData.hvac_state = 'off'; // By default, we're not heating or cooling
+          if (
+            value.value?.hvac_control?.hvacState?.coolStage1Active === true ||
+            value.value?.hvac_control?.hvacState?.coolStage2Active === true ||
+            value.value?.hvac_control?.hvacState?.coolStage2Active === true
+          ) {
+            // A cooling source is on, so we're in cooling mode
+            RESTTypeData.hvac_state = 'cooling';
+          }
+          if (
+            value.value?.hvac_control?.hvacState?.heatStage1Active === true ||
+            value.value?.hvac_control?.hvacState?.heatStage2Active === true ||
+            value.value?.hvac_control?.hvacState?.heatStage3Active === true ||
+            value.value?.hvac_control?.hvacState?.alternateHeatStage1Active === true ||
+            value.value?.hvac_control?.hvacState?.alternateHeatStage2Active === true ||
+            value.value?.hvac_control?.hvacState?.auxiliaryHeatActive === true ||
+            value.value?.hvac_control?.hvacState?.emergencyHeatActive === true
+          ) {
+            // A heating source is on, so we're in heating mode
+            RESTTypeData.hvac_state = 'heating';
+          }
+
+          // Fan details, on or off and max number of speeds supported
+          RESTTypeData.has_fan =
+            typeof value.value?.fan_control_capabilities?.maxAvailableSpeed === 'string' &&
+            value.value.fan_control_capabilities.maxAvailableSpeed !== 'FAN_SPEED_SETTING_OFF';
+          RESTTypeData.fan_state =
+            isNaN(value.value?.fan_control_settings?.timerEnd?.seconds) === false &&
+            Number(value.value.fan_control_settings.timerEnd.seconds) > 0;
+          RESTTypeData.fan_timer_speed =
+            value.value?.fan_control_settings?.timerSpeed?.includes?.('FAN_SPEED_SETTING_STAGE') === true &&
+            isNaN(value.value.fan_control_settings.timerSpeed.split('FAN_SPEED_SETTING_STAGE')[1]) === false
+              ? Number(value.value.fan_control_settings.timerSpeed.split('FAN_SPEED_SETTING_STAGE')[1])
+              : 0;
+          RESTTypeData.fan_max_speed =
+            value.value?.fan_control_capabilities?.maxAvailableSpeed?.includes?.('FAN_SPEED_SETTING_STAGE') === true &&
+            isNaN(value.value.fan_control_capabilities.maxAvailableSpeed.split('FAN_SPEED_SETTING_STAGE')[1]) === false
+              ? Number(value.value.fan_control_capabilities.maxAvailableSpeed.split('FAN_SPEED_SETTING_STAGE')[1])
+              : 0;
+
+          // Humidifier/dehumidifier details
+          RESTTypeData.has_humidifier = value.value?.hvac_equipment_capabilities?.hasHumidifier === true;
+          RESTTypeData.has_dehumidifier = value.value?.hvac_equipment_capabilities?.hasDehumidifier === true;
+          RESTTypeData.target_humidity =
+            isNaN(value.value?.humidity_control_settings?.targetHumidity?.value) === false
+              ? Number(value.value.humidity_control_settings.targetHumidity.value)
+              : 0.0;
+          RESTTypeData.humidifier_state = value.value?.hvac_control?.hvacState?.humidifierActive === true;
+          RESTTypeData.dehumidifier_state = value.value?.hvac_control?.hvacState?.dehumidifierActive === true;
+
+          // Air filter details
+          RESTTypeData.has_air_filter = value.value?.hvac_equipment_capabilities?.hasAirFilter === true;
+          RESTTypeData.filter_replacement_needed = value.value?.filter_reminder?.filterReplacementNeeded?.value === true;
+
+          // Process any temperature sensors associated with this thermostat
+          RESTTypeData.active_rcs_sensor =
+            value.value?.remote_comfort_sensing_settings?.activeRcsSelection?.activeRcsSensor !== undefined
+              ? value.value.remote_comfort_sensing_settings.activeRcsSelection.activeRcsSensor.resourceId
+              : '';
+          RESTTypeData.linked_rcs_sensors = [];
+          if (Array.isArray(value.value?.remote_comfort_sensing_settings?.associatedRcsSensors) === true) {
+            value.value.remote_comfort_sensing_settings.associatedRcsSensors.forEach((sensor) => {
+              if (typeof rawData?.[sensor?.deviceId?.resourceId]?.value === 'object') {
+                rawData[sensor.deviceId.resourceId].value.associated_thermostat = object_key; // Sensor is linked to this thermostat
+              }
+
+              RESTTypeData.linked_rcs_sensors.push(sensor.deviceId.resourceId);
+            });
+          }
+
+          RESTTypeData.schedule_mode =
+            typeof value.value?.target_temperature_settings?.targetTemperature?.setpointType === 'string' &&
+            value.value.target_temperature_settings.targetTemperature.setpointType.split('SET_POINT_TYPE_')[1].toLowerCase() !== 'off'
+              ? value.value.target_temperature_settings.targetTemperature.setpointType.split('SET_POINT_TYPE_')[1].toLowerCase()
+              : '';
+          RESTTypeData.schedules = {};
+          if (
+            value.value[RESTTypeData.schedule_mode + '_schedule_settings']?.setpoints !== undefined &&
+            value.value[RESTTypeData.schedule_mode + '_schedule_settings']?.type ===
+              'SET_POINT_SCHEDULE_TYPE_' + RESTTypeData.schedule_mode.toUpperCase()
+          ) {
+            Object.values(value.value[RESTTypeData.schedule_mode + '_schedule_settings'].setpoints).forEach((schedule) => {
+              // Create Nest API schedule entries
+              if (schedule?.dayOfWeek !== undefined) {
+                let dayofWeekIndex = DAYS_OF_WEEK_FULL.indexOf(schedule.dayOfWeek.split('DAY_OF_WEEK_')[1]);
+
+                if (RESTTypeData.schedules?.[dayofWeekIndex] === undefined) {
+                  RESTTypeData.schedules[dayofWeekIndex] = {};
+                }
+
+                RESTTypeData.schedules[dayofWeekIndex][Object.entries(RESTTypeData.schedules[dayofWeekIndex]).length] = {
+                  'temp-min': adjustTemperature(schedule.heatingTarget.value, 'C', 'C', true),
+                  'temp-max': adjustTemperature(schedule.coolingTarget.value, 'C', 'C', true),
+                  time: isNaN(schedule?.secondsInDay) === false ? Number(schedule.secondsInDay) : 0,
+                  type: RESTTypeData.schedule_mode.toUpperCase(),
+                  entry_type: 'setpoint',
+                };
+              }
+            });
+          }
+
+          tempDevice = process_thermostat_data(object_key, RESTTypeData);
+        }
+
+        if (
+          value?.source === DATA_SOURCE.NEST &&
+          rawData?.['track.' + value.value?.serial_number] !== undefined &&
+          rawData?.['link.' + value.value?.serial_number] !== undefined &&
+          rawData?.['shared.' + value.value?.serial_number] !== undefined &&
+          rawData?.['where.' + rawData?.['link.' + value.value?.serial_number]?.value?.structure?.split?.('.')[1]] !== undefined
+        ) {
+          let RESTTypeData = {};
+          RESTTypeData.type = DEVICE_TYPE.THERMOSTAT;
+          RESTTypeData.model = 'Thermostat (unknown)';
+          if (value.value.serial_number.substring(0, 2) === '15') {
+            RESTTypeData.model = 'Thermostat E (1st gen)'; // Nest Thermostat E
+          }
+          if (value.value.serial_number.substring(0, 2) === '09' || value.value.serial_number.substring(0, 2) === '10') {
+            RESTTypeData.model = 'Learning Thermostat (3rd gen)'; // Nest Thermostat 3rd gen
+          }
+          if (value.value.serial_number.substring(0, 2) === '02') {
+            RESTTypeData.model = 'Learning Thermostat (2nd gen)'; // Nest Thermostat 2nd gen
+          }
+          if (value.value.serial_number.substring(0, 2) === '01') {
+            RESTTypeData.model = 'Learning Thermostat (1st gen)'; // Nest Thermostat 1st gen
+          }
+          RESTTypeData.softwareVersion = value.value.current_version;
+          RESTTypeData.serialNumber = value.value.serial_number;
+          RESTTypeData.description = String(rawData?.['shared.' + value.value.serial_number]?.value?.name ?? '');
+          RESTTypeData.location = String(
+            rawData?.['where.' + rawData?.['link.' + value.value.serial_number]?.value?.structure?.split?.('.')[1]]?.value?.wheres?.find(
+              (where) => where?.where_id === value.value.where_id,
+            )?.name ?? '',
+          );
+          RESTTypeData.current_humidity = value.value.current_humidity;
+          RESTTypeData.temperature_scale = value.value.temperature_scale.toUpperCase() === 'F' ? 'F' : 'C';
+          RESTTypeData.removed_from_base = value.value.nlclient_state.toUpperCase() === 'BPD';
+          RESTTypeData.backplate_temperature = value.value.backplate_temperature;
+          RESTTypeData.current_temperature = value.value.backplate_temperature;
+          RESTTypeData.battery_level = value.value.battery_level;
+          RESTTypeData.online = rawData?.['track.' + value.value.serial_number]?.value?.online === true;
+          RESTTypeData.leaf = value.value.leaf === true;
+          RESTTypeData.has_humidifier = value.value.has_humidifier === true;
+          RESTTypeData.has_dehumidifier = value.value.has_dehumidifier === true;
+          RESTTypeData.has_fan = value.value.has_fan === true;
+          RESTTypeData.can_cool = rawData?.['shared.' + value.value.serial_number]?.value?.can_cool === true;
+          RESTTypeData.can_heat = rawData?.['shared.' + value.value.serial_number]?.value?.can_heat === true;
+          RESTTypeData.temperature_lock = value.value.temperature_lock === true;
+          RESTTypeData.temperature_lock_pin_hash = value.value.temperature_lock_pin_hash;
+          RESTTypeData.away = rawData?.[rawData?.['link.' + value.value.serial_number]?.value?.structure]?.value?.away === true;
+          RESTTypeData.occupancy = RESTTypeData.away === false; // Occupancy is opposite of away status ie: away is false, then occupied
+          RESTTypeData.vacation_mode =
+            rawData[rawData?.['link.' + value.value.serial_number]?.value?.structure]?.value?.vacation_mode === true;
+
+          // Work out current mode. ie: off, cool, heat, range and get temperature low (heat) and high (cool)
+          RESTTypeData.hvac_mode =
+            rawData?.['shared.' + value.value.serial_number]?.value?.target_temperature_type !== undefined
+              ? rawData?.['shared.' + value.value.serial_number].value.target_temperature_type
+              : 'off';
+          RESTTypeData.target_temperature =
+            isNaN(rawData?.['shared.' + value.value.serial_number]?.value?.target_temperature) === false
+              ? Number(rawData['shared.' + value.value.serial_number].value.target_temperature)
+              : 0.0;
+          RESTTypeData.target_temperature_low =
+            isNaN(rawData?.['shared.' + value.value.serial_number]?.value?.target_temperature_low) === false
+              ? Number(rawData['shared.' + value.value.serial_number].value.target_temperature_low)
+              : 0.0;
+          RESTTypeData.target_temperature_high =
+            isNaN(rawData?.['shared.' + value.value.serial_number]?.value?.target_temperature_high) === false
+              ? Number(rawData['shared.' + value.value.serial_number].value.target_temperature_high)
+              : 0.0;
+          if (rawData?.['shared.' + value.value.serial_number]?.value?.target_temperature_type.toUpperCase() === 'COOL') {
+            // Target temperature is the cooling point
+            RESTTypeData.target_temperature =
+              isNaN(rawData?.['shared.' + value.value.serial_number]?.value?.target_temperature_high) === false
+                ? Number(rawData['shared.' + value.value.serial_number].value.target_temperature_high)
+                : 0.0;
+          }
+          if (rawData?.['shared.' + value.value.serial_number]?.value?.target_temperature_type.toUpperCase() === 'HEAT') {
+            // Target temperature is the heating point
+            RESTTypeData.target_temperature =
+              isNaN(rawData?.['shared.' + value.value.serial_number]?.value?.target_temperature_low) === false
+                ? Number(rawData['shared.' + value.value.serial_number].value.target_temperature_low)
+                : 0.0;
+          }
+          if (rawData?.['shared.' + value.value.serial_number]?.value?.target_temperature_type.toUpperCase() === 'RANGE') {
+            // Target temperature is in between the heating and cooling point
+            RESTTypeData.target_temperature =
+              isNaN(rawData?.['shared.' + value.value.serial_number]?.value?.target_temperature_low) === false &&
+              isNaN(rawData?.['shared.' + value.value.serial_number]?.value?.target_temperature_high) === false
+                ? (Number(rawData['shared.' + value.value.serial_number].value.target_temperature_low) +
+                    Number(rawData['shared.' + value.value.serial_number].value.target_temperature_high)) *
+                  0.5
+                : 0.0;
+          }
+
+          // Work out if eco mode is active and adjust temperature low/high and target
+          if (value.value.eco.mode.toUpperCase() === 'AUTO-ECO' || value.value.eco.mode.toUpperCase() === 'MANUAL-ECO') {
+            RESTTypeData.target_temperature_low = value.value.away_temperature_low;
+            RESTTypeData.target_temperature_high = value.value.away_temperature_high;
+            if (value.value.away_temperature_high_enabled === true && value.value.away_temperature_low_enabled === false) {
+              RESTTypeData.target_temperature = value.value.away_temperature_low;
+              RESTTypeData.hvac_mode = 'ecoheat';
+            }
+            if (value.value.away_temperature_high_enabled === true && value.value.away_temperature_low_enabled === false) {
+              RESTTypeData.target_temperature = value.value.away_temperature_high;
+              RESTTypeData.hvac_mode = 'ecocool';
+            }
+            if (value.value.away_temperature_high_enabled === true && value.value.away_temperature_low_enabled === true) {
+              RESTTypeData.target_temperature = (value.value.away_temperature_low + value.value.away_temperature_high) * 0.5;
+              RESTTypeData.hvac_mode = 'ecorange';
+            }
+          }
+
+          // Work out current state ie: heating, cooling etc
+          RESTTypeData.hvac_state = 'off'; // By default, we're not heating or cooling
+          if (
+            rawData?.['shared.' + value.value.serial_number]?.value?.hvac_heater_state === true ||
+            rawData?.['shared.' + value.value.serial_number]?.value?.hvac_heat_x2_state === true ||
+            rawData?.['shared.' + value.value.serial_number]?.value?.hvac_heat_x3_state === true ||
+            rawData?.['shared.' + value.value.serial_number]?.value?.hvac_aux_heater_state === true ||
+            rawData?.['shared.' + value.value.serial_number]?.value?.hvac_alt_heat_x2_state === true ||
+            rawData?.['shared.' + value.value.serial_number]?.value?.hvac_emer_heat_state === true ||
+            rawData?.['shared.' + value.value.serial_number]?.value?.hvac_alt_heat_state === true
+          ) {
+            // A heating source is on, so we're in heating mode
+            RESTTypeData.hvac_state = 'heating';
+          }
+          if (
+            rawData?.['shared.' + value.value.serial_number]?.value?.hvac_ac_state === true ||
+            rawData?.['shared.' + value.value.serial_number]?.value?.hvac_cool_x2_state === true ||
+            rawData?.['shared.' + value.value.serial_number]?.value?.hvac_cool_x3_state === true
+          ) {
+            // A cooling source is on, so we're in cooling mode
+            RESTTypeData.hvac_state = 'cooling';
+          }
+
+          // Update fan status, on or off
+          RESTTypeData.fan_state = isNaN(value.value?.fan_timer_timeout) === false && Number(value.value.fan_timer_timeout) > 0;
+          RESTTypeData.fan_timer_speed =
+            value.value?.fan_timer_speed?.includes?.('stage') === true && isNaN(value.value.fan_timer_speed.split('stage')[1]) === false
+              ? Number(value.value.fan_timer_speed.split('stage')[1])
+              : 0;
+          RESTTypeData.fan_max_speed =
+            value.value?.fan_capabilities?.includes?.('stage') === true && isNaN(value.value.fan_capabilities.split('stage')[1]) === false
+              ? Number(value.value.fan_capabilities.split('stage')[1])
+              : 0;
+
+          // Humidifier/dehumidifier details
+          RESTTypeData.target_humidity = isNaN(value.value?.target_humidity) === false ? Number(value.value.target_humidity) : 0.0;
+          RESTTypeData.humidifier_state = value.value.humidifier_state === true;
+          RESTTypeData.dehumidifier_state = value.value.dehumidifier_state === true;
+
+          // Air filter details
+          RESTTypeData.has_air_filter = value.value.has_air_filter === true;
+          RESTTypeData.filter_replacement_needed = value.value.filter_replacement_needed === true;
+
+          // Process any temperature sensors associated with this thermostat
+          RESTTypeData.active_rcs_sensor = '';
+          RESTTypeData.linked_rcs_sensors = [];
+          if (rawData?.['rcs_settings.' + value.value.serial_number]?.value?.associated_rcs_sensors !== undefined) {
+            rawData?.['rcs_settings.' + value.value.serial_number].value.associated_rcs_sensors.forEach((sensor) => {
+              if (typeof rawData[sensor]?.value === 'object') {
+                rawData[sensor].value.associated_thermostat = object_key; // Sensor is linked to this thermostat
+
+                // Is this sensor the active one? If so, get some details about it
+                if (
+                  rawData?.['rcs_settings.' + value.value.serial_number]?.value?.active_rcs_sensors !== undefined &&
+                  rawData?.['rcs_settings.' + value.value.serial_number]?.value?.active_rcs_sensors.includes(sensor)
+                ) {
+                  RESTTypeData.active_rcs_sensor = rawData[sensor].value.serial_number.toUpperCase();
+                  RESTTypeData.current_temperature = rawData[sensor].value.current_temperature;
+                }
+                RESTTypeData.linked_rcs_sensors.push(rawData[sensor].value.serial_number.toUpperCase());
+              }
+            });
+          }
+
+          // Get associated schedules
+          if (rawData?.['schedule.' + value.value.serial_number] !== undefined) {
+            Object.values(rawData['schedule.' + value.value.serial_number].value.days).forEach((schedules) => {
+              Object.values(schedules).forEach((schedule) => {
+                // Fix up temperatures in the schedule
+                if (isNaN(schedule['temp']) === false) {
+                  schedule.temp = adjustTemperature(Number(schedule.temp), 'C', 'C', true);
+                }
+                if (isNaN(schedule['temp-min']) === false) {
+                  schedule['temp-min'] = adjustTemperature(Number(schedule['temp-min']), 'C', 'C', true);
+                }
+                if (isNaN(schedule['temp-max']) === false) {
+                  schedule['temp-max'] = adjustTemperature(Number(schedule['temp-max']), 'C', 'C', true);
+                }
+              });
+            });
+            RESTTypeData.schedules = rawData['schedule.' + value.value.serial_number].value.days;
+            RESTTypeData.schedule_mode = rawData['schedule.' + value.value.serial_number].value.schedule_mode;
+          }
+
+          tempDevice = process_thermostat_data(object_key, RESTTypeData);
+        }
+        // eslint-disable-next-line no-unused-vars
+      } catch (error) {
+        log?.debug?.('Error processing thermostat data for "%s"', object_key);
+      }
+
+      if (
+        Object.entries(tempDevice).length !== 0 &&
+        typeof devices[tempDevice.serialNumber] === 'undefined' &&
+        (deviceType === undefined || (typeof deviceType === 'string' && deviceType !== '' && tempDevice.type === deviceType))
+      ) {
+        let deviceOptions = config?.devices?.find(
+          (device) => device?.serialNumber?.toUpperCase?.() === tempDevice?.serialNumber?.toUpperCase?.(),
+        );
+        // Insert any extra options we've read in from configuration file for this device
+        tempDevice.eveHistory = config.options.eveHistory === true || deviceOptions?.eveHistory === true;
+        tempDevice.humiditySensor = deviceOptions?.humiditySensor === true;
+        tempDevice.externalCool =
+          typeof deviceOptions?.externalCool === 'string' && deviceOptions.externalCool !== '' ? deviceOptions.externalCool : undefined; // Config option for external cooling source
+        tempDevice.externalHeat =
+          typeof deviceOptions?.externalHeat === 'string' && deviceOptions.externalHeat !== '' ? deviceOptions.externalHeat : undefined; // Config option for external heating source
+        tempDevice.externalFan =
+          typeof deviceOptions?.externalFan === 'string' && deviceOptions.externalFan !== '' ? deviceOptions.externalFan : undefined; // Config option for external fan source
+        tempDevice.externalDehumidifier =
+          typeof deviceOptions?.externalDehumidifier === 'string' && deviceOptions.externalDehumidifier !== ''
+            ? deviceOptions.externalDehumidifier
+            : undefined; // Config option for external dehumidifier source
+        devices[tempDevice.serialNumber] = tempDevice; // Store processed device
+      }
+    });
+
+  return devices;
 }