@switchbot/homebridge-switchbot 4.3.2-beta.8 → 5.0.0-beta.0

package/src/devices-matter/RoboticVacuumAccessory.ts

@@ -0,0 +1,484 @@
+/* global NodeJS */
+
+/**
+ * Robotic Vacuum Cleaner Accessory Class
+ *
+ * This is a comprehensive example demonstrating all available features
+ * of the RoboticVacuumCleaner device type including:
+ * - Multiple run modes (Idle, Cleaning, Mapping)
+ * - Multiple clean modes (Vacuum, Mop, Vacuum & Mop, Deep Clean)
+ * - Operational state management with realistic transitions
+ * - Service area (room) support
+ *
+ * IMPORTANT: Platform Matter accessories
+ * =======================================
+ * This vacuum is registered as a platform accessory using
+ * api.matter.registerPlatformAccessories(), which works the same as HAP.
+ * Platform accessories are registered synchronously and are immediately ready for use.
+ *
+ * Demo behavior:
+ * - Start/Resume: Sets run mode to "Cleaning", runs for 15/10 seconds, then returns to dock
+ * - Return to dock: Immediately sets "Idle" mode, then Seeking (5s) → Charging (3s) → Docked
+ * - Stop: Immediately stops and resets to "Idle" mode
+ * - Pause: Cancels automatic completion timer, keeps "Cleaning" mode
+ */
+
+import type { API, Logger, MatterRequests } from 'homebridge'
+
+import { BaseMatterAccessory } from './BaseMatterAccessory.js'
+
+export class RoboticVacuumAccessory extends BaseMatterAccessory {
+  private activeTimers: NodeJS.Timeout[] = []
+
+  constructor(api: API, log: Logger) {
+    const serialNumber = 'VACUUM-001'
+    super(api, log, {
+      uuid: api.matter.uuid.generate(serialNumber),
+      displayName: 'Robot Vacuum',
+      deviceType: api.matter.deviceTypes.RoboticVacuumCleaner,
+      serialNumber,
+      manufacturer: 'Homebridge Matter',
+      model: 'HB-MATTER-VACUUM-ROBOTIC',
+      firmwareRevision: '2.0.0',
+      hardwareRevision: '1.0.0',
+
+      clusters: {
+        // Power Source: Battery status and percentage
+        powerSource: {
+          status: 0, // 0 = Active
+          order: 0, // Primary power source
+          description: 'Battery',
+          batPercentRemaining: 100, // 0-200, where 200 = 100% (0.5% increments)
+          batChargeLevel: 2, // 0 = Ok, 1 = Warning, 2 = Critical
+          batReplaceability: 1, // 0 = Unspecified, 1 = Not replaceable, 2 = User replaceable, 3 = Factory replaceable
+        },
+
+        // Run Mode: Controls what the vacuum is doing (Idle, Cleaning, Mapping)
+        rvcRunMode: {
+          supportedModes: [
+            { label: 'Idle', mode: 0, modeTags: [{ value: 16384 }] }, // RvcRunMode.ModeTag.Idle
+            { label: 'Cleaning', mode: 1, modeTags: [{ value: 16385 }] }, // RvcRunMode.ModeTag.Cleaning
+            { label: 'Mapping', mode: 2, modeTags: [{ value: 16386 }] }, // RvcRunMode.ModeTag.Mapping
+          ],
+          currentMode: 0,
+        },
+
+        // Clean Mode: Controls HOW the vacuum cleans
+        // You can combine semantic tags (0-9) with functional tags (16384-16386)
+        // Available semantic tags: Auto, Quick, Quiet, LowNoise, LowEnergy, Vacation, Min, Max, Night, Day
+        // Available functional tags: DeepClean, Vacuum, Mop
+        rvcCleanMode: {
+          supportedModes: [
+            // Basic functional modes
+            { label: 'Vacuum', mode: 0, modeTags: [{ value: 16385 }] }, // Vacuum
+            { label: 'Mop', mode: 1, modeTags: [{ value: 16386 }] }, // Mop
+            { label: 'Vacuum & Mop', mode: 2, modeTags: [{ value: 16385 }, { value: 16386 }] }, // Both
+
+            // Deep clean modes
+            { label: 'Deep Clean', mode: 3, modeTags: [{ value: 16384 }] }, // DeepClean
+            { label: 'Deep Vacuum', mode: 4, modeTags: [{ value: 16384 }, { value: 16385 }] }, // DeepClean + Vacuum
+            { label: 'Deep Mop', mode: 5, modeTags: [{ value: 16384 }, { value: 16386 }] }, // DeepClean + Mop
+
+            // Intensity modes
+            { label: 'Quick Clean', mode: 6, modeTags: [{ value: 1 }, { value: 16385 }] }, // Quick + Vacuum
+            { label: 'Max Clean', mode: 7, modeTags: [{ value: 7 }, { value: 16385 }] }, // Max + Vacuum
+            { label: 'Min Clean', mode: 8, modeTags: [{ value: 6 }, { value: 16385 }] }, // Min + Vacuum
+
+            // Quiet modes
+            { label: 'Quiet Vacuum', mode: 9, modeTags: [{ value: 2 }, { value: 16385 }] }, // Quiet + Vacuum
+            { label: 'Quiet Mop', mode: 10, modeTags: [{ value: 2 }, { value: 16386 }] }, // Quiet + Mop
+            { label: 'Night Mode', mode: 11, modeTags: [{ value: 8 }, { value: 16385 }] }, // Night + Vacuum
+
+            // Energy efficient
+            { label: 'Eco Vacuum', mode: 12, modeTags: [{ value: 4 }, { value: 16385 }] }, // LowEnergy + Vacuum
+            { label: 'Eco Mop', mode: 13, modeTags: [{ value: 4 }, { value: 16386 }] }, // LowEnergy + Mop
+
+            // Auto mode
+            { label: 'Auto', mode: 14, modeTags: [{ value: 0 }, { value: 16385 }] }, // Auto + Vacuum
+          ],
+          currentMode: 0, // start with basic Vacuum
+        },
+
+        // Operational State: Current state (Stopped, Running, Paused, Error, etc.)
+        rvcOperationalState: {
+          operationalStateList: [
+            { operationalStateId: 0 }, // stopped (standard label from Matter spec)
+            { operationalStateId: 1 }, // running
+            { operationalStateId: 2 }, // paused
+            { operationalStateId: 3 }, // error
+            { operationalStateId: 64 }, // seeking charger
+            { operationalStateId: 65 }, // charging
+            { operationalStateId: 66 }, // docked
+          ],
+          operationalState: 66, // start docked
+        },
+
+        // Service Area: Room/zone selection for targeted cleaning
+        serviceArea: {
+          supportedMaps: [], // empty array - we don't use map features
+          supportedAreas: [
+            {
+              areaId: 0,
+              mapId: null, // required: must be null when supportedMaps is empty
+              areaInfo: {
+                locationInfo: {
+                  locationName: 'Living Room',
+                  floorNumber: 0,
+                  areaType: 7, // AreaNamespaceTag.LivingRoom
+                },
+                landmarkInfo: null,
+              },
+            },
+            {
+              areaId: 1,
+              mapId: null,
+              areaInfo: {
+                locationInfo: {
+                  locationName: 'Kitchen',
+                  floorNumber: 0,
+                  areaType: 10, // AreaNamespaceTag.Kitchen
+                },
+                landmarkInfo: null,
+              },
+            },
+            {
+              areaId: 2,
+              mapId: null,
+              areaInfo: {
+                locationInfo: {
+                  locationName: 'Bedroom',
+                  floorNumber: 0,
+                  areaType: 2, // AreaNamespaceTag.Bedroom
+                },
+                landmarkInfo: null,
+              },
+            },
+            {
+              areaId: 3,
+              mapId: null,
+              areaInfo: {
+                locationInfo: {
+                  locationName: 'Bathroom',
+                  floorNumber: 0,
+                  areaType: 6, // AreaNamespaceTag.Bathroom
+                },
+                landmarkInfo: null,
+              },
+            },
+          ],
+          selectedAreas: [0, 1, 2, 3], // all areas selected by default
+        },
+      },
+
+      handlers: {
+        rvcRunMode: {
+          changeToMode: async (request: MatterRequests.ChangeToMode) => this.handleChangeRunMode(request),
+        },
+        rvcCleanMode: {
+          changeToMode: async (request: MatterRequests.ChangeToMode) => this.handleChangeCleanMode(request),
+        },
+        rvcOperationalState: {
+          pause: async () => this.handlePause(),
+          stop: async () => this.handleStop(),
+          start: async () => this.handleStart(),
+          resume: async () => this.handleResume(),
+          goHome: async () => this.handleGoHome(),
+        },
+        serviceArea: {
+          selectAreas: async (request: MatterRequests.SelectAreas) => this.handleSelectAreas(request),
+          skipArea: async (request: MatterRequests.SkipArea) => this.handleSkipArea(request),
+        },
+      },
+    })
+
+    this.logInfo('initialized and ready.')
+  }
+
+  private async handleChangeRunMode(request: MatterRequests.ChangeToMode): Promise<void> {
+    this.logInfo(`ChangeToMode (run) request received: ${JSON.stringify(request)}`)
+    const { newMode } = request
+    const modeStr = ['Idle', 'Cleaning', 'Mapping'][newMode] || `Unknown (mode=${newMode})`
+    this.logInfo(`changing run mode to: ${modeStr}`)
+    // TODO: await myVacuumAPI.setRunMode(newMode)
+
+    // Clear any existing timers
+    this.clearTimers()
+
+    if (newMode === 1) {
+      // Switching to Cleaning mode - start the vacuum
+      this.updateOperationalState(1) // Running
+
+      // Simulate cleaning completion after 15 seconds
+      const completionTimer = setTimeout(() => {
+        this.logInfo('cleaning completed, returning to dock.')
+        this.updateRunMode(0) // Set to Idle - cleaning session ending
+        this.returnToDock()
+      }, 15000)
+
+      this.activeTimers.push(completionTimer)
+    } else if (newMode === 0) {
+      // Switching to Idle mode - return to dock
+      this.returnToDock()
+    } else if (newMode === 2) {
+      // Switching to Mapping mode - start mapping
+      this.updateOperationalState(1) // Running
+
+      // Simulate mapping completion after 20 seconds
+      const completionTimer = setTimeout(() => {
+        this.logInfo('mapping completed, returning to dock.')
+        this.returnToDock()
+      }, 20000)
+
+      this.activeTimers.push(completionTimer)
+    }
+  }
+
+  private async handleChangeCleanMode(request: MatterRequests.ChangeToMode): Promise<void> {
+    this.logInfo(`ChangeToMode (clean) request received: ${JSON.stringify(request)}`)
+    const { newMode } = request
+    const modes = [
+      'Vacuum',
+      'Mop',
+      'Vacuum & Mop',
+      'Deep Clean',
+      'Deep Vacuum',
+      'Deep Mop',
+      'Quick Clean',
+      'Max Clean',
+      'Min Clean',
+      'Quiet Vacuum',
+      'Quiet Mop',
+      'Night Mode',
+      'Eco Vacuum',
+      'Eco Mop',
+      'Auto',
+    ]
+    const modeStr = modes[newMode] || `Unknown (mode=${newMode})`
+    this.logInfo(`changing clean mode to: ${modeStr}`)
+    // TODO: await myVacuumAPI.setCleanMode(newMode)
+  }
+
+  private async handlePause(): Promise<void> {
+    this.logInfo('pausing.')
+    // TODO: await myVacuumAPI.pause()
+    this.clearTimers() // Clear cleaning completion timer
+    this.updateOperationalState(2) // Paused
+  }
+
+  private async handleStop(): Promise<void> {
+    this.logInfo('stopping.')
+    // TODO: await myVacuumAPI.stop()
+    this.clearTimers()
+    this.updateRunMode(0) // Reset to Idle
+    this.updateOperationalState(0) // Stopped
+  }
+
+  private async handleStart(): Promise<void> {
+    this.logInfo('starting (via start command).')
+    // TODO: await myVacuumAPI.start()
+
+    // Clear any existing timers
+    this.clearTimers()
+
+    this.updateRunMode(1) // Set to Cleaning mode - this will trigger the run mode handler logic
+    this.updateOperationalState(1) // Running
+
+    // Simulate cleaning completion after 15 seconds
+    const completionTimer = setTimeout(() => {
+      this.logInfo('cleaning completed, returning to dock.')
+      this.updateRunMode(0) // Set to Idle - cleaning session ending
+      this.returnToDock()
+    }, 15000)
+
+    this.activeTimers.push(completionTimer)
+  }
+
+  private async handleResume(): Promise<void> {
+    this.logInfo('resuming.')
+    // TODO: await myVacuumAPI.resume()
+
+    // Clear any existing timers
+    this.clearTimers()
+
+    this.updateRunMode(1) // Set to Cleaning mode
+    this.updateOperationalState(1) // Running
+
+    // Simulate cleaning completion after 10 seconds (shorter since resuming)
+    const completionTimer = setTimeout(() => {
+      this.logInfo('cleaning completed, returning to dock.')
+      this.updateRunMode(0) // Set to Idle - cleaning session ending
+      this.returnToDock()
+    }, 10000)
+
+    this.activeTimers.push(completionTimer)
+  }
+
+  private async handleGoHome(): Promise<void> {
+    this.logInfo('goHome command received.')
+    // TODO: await myVacuumAPI.goHome()
+
+    // Clear any existing timers
+    this.clearTimers()
+
+    // Defer state updates to ensure handler completes first
+    setImmediate(() => {
+      // Set to Idle mode since we're ending the cleaning session
+      this.updateRunMode(0)
+
+      // Initiate return to dock sequence
+      this.returnToDock()
+    })
+  }
+
+  private async handleSelectAreas(request: MatterRequests.SelectAreas): Promise<void> {
+    this.logInfo(`SelectAreas request received: ${JSON.stringify(request)}`)
+    const { newAreas } = request
+    const areaNames = newAreas.map((id: number) =>
+      ['Living Room', 'Kitchen', 'Bedroom', 'Bathroom'][id] || `Area ${id}`,
+    )
+    this.logInfo(`selecting areas: ${areaNames.join(', ')}`)
+    // TODO: await myVacuumAPI.selectAreas(newAreas)
+  }
+
+  private async handleSkipArea(request: MatterRequests.SkipArea): Promise<void> {
+    this.logInfo(`SkipArea request received: ${JSON.stringify(request)}`)
+    const { skippedArea } = request
+    const areaName = ['Living Room', 'Kitchen', 'Bedroom', 'Bathroom'][skippedArea] || `Area ${skippedArea}`
+    this.logInfo(`skipping area: ${areaName}`)
+    // TODO: await myVacuumAPI.skipArea(skippedArea)
+  }
+
+  /**
+   * Helper method to clear all active timers
+   */
+  private clearTimers(): void {
+    this.activeTimers.forEach(timer => clearTimeout(timer))
+    this.activeTimers = []
+  }
+
+  /**
+   * Helper method to initiate return to dock sequence
+   * Can be called synchronously from other handlers
+   */
+  private returnToDock(): void {
+    this.logInfo('initiating return to dock sequence.')
+
+    // Defer ALL state updates to ensure handler completes first
+    setImmediate(() => {
+      // Start seeking charger directly (skip intermediate Stopped state)
+      this.updateOperationalState(64) // Seeking Charger
+
+      // After 5 seconds, start charging
+      const chargingTimer = setTimeout(() => {
+        this.logInfo('reached dock, now charging.')
+        this.updateOperationalState(65) // Charging
+
+        // After 3 more seconds, fully docked
+        const dockedTimer = setTimeout(() => {
+          this.logInfo('fully charged and docked.')
+          this.updateOperationalState(66) // Docked
+        }, 3000)
+
+        this.activeTimers.push(dockedTimer)
+      }, 5000)
+
+      this.activeTimers.push(chargingTimer)
+    })
+  }
+
+  /**
+   * Update Methods - Use these to update the vacuum state from your API/device
+   *
+   * Since this is a platform accessory, state updates work immediately after registration.
+   */
+
+  public updateOperationalState(state: number): void {
+    this.updateState('rvcOperationalState', { operationalState: state })
+    const states = [
+      'Stopped',
+      'Running',
+      'Paused',
+      'Error',
+      null,
+      null,
+      null,
+      null,
+      ...Array.from({ length: 56 }).fill(null),
+      'Seeking Charger',
+      'Charging',
+      'Docked',
+    ]
+    this.logInfo(`operational state updated to: ${states[state] || `Unknown (${state})`}`)
+  }
+
+  public updateRunMode(mode: number): void {
+    this.updateState('rvcRunMode', { currentMode: mode })
+    const modes = ['Idle', 'Cleaning', 'Mapping']
+    this.logInfo(`run mode updated to: ${modes[mode] || `Unknown (${mode})`}`)
+  }
+
+  public updateCleanMode(mode: number): void {
+    this.updateState('rvcCleanMode', { currentMode: mode })
+    const modes = [
+      'Vacuum',
+      'Mop',
+      'Vacuum & Mop',
+      'Deep Clean',
+      'Deep Vacuum',
+      'Deep Mop',
+      'Quick Clean',
+      'Max Clean',
+      'Min Clean',
+      'Quiet Vacuum',
+      'Quiet Mop',
+      'Night Mode',
+      'Eco Vacuum',
+      'Eco Mop',
+      'Auto',
+    ]
+    this.logInfo(`clean mode updated to: ${modes[mode] || `Unknown (${mode})`}`)
+  }
+
+  public updateSelectedAreas(areaIds: number[]): void {
+    this.updateState('serviceArea', { selectedAreas: areaIds })
+    const areaNames = areaIds.map(id =>
+      ['Living Room', 'Kitchen', 'Bedroom', 'Bathroom'][id] || `Area ${id}`,
+    )
+    this.logInfo(`selected areas updated to: ${areaNames.join(', ') || 'All Areas'}`)
+  }
+
+  public updateCurrentArea(areaId: number | null): void {
+    this.updateState('serviceArea', { currentArea: areaId })
+    if (areaId !== null) {
+      const areaName = ['Living Room', 'Kitchen', 'Bedroom', 'Bathroom'][areaId] || `Area ${areaId}`
+      this.logInfo(`current area updated to: ${areaName}`)
+    } else {
+      this.logInfo('current area cleared')
+    }
+  }
+
+  public updateProgress(progress: Array<{ areaId: number, status: number }>): void {
+    this.updateState('serviceArea', { progress })
+    this.logInfo(`progress updated: ${progress.length} areas`)
+  }
+
+  /**
+   * Update battery percentage
+   * @param percentage - Battery percentage (0-100)
+   */
+  public async updateBatteryPercentage(percentage: number): Promise<void> {
+    // Convert percentage to Matter format (0-200, where 200 = 100%)
+    const batPercentRemaining = Math.max(0, Math.min(200, Math.round(percentage * 2)))
+
+    // Determine charge level based on percentage
+    let batChargeLevel = 0 // Ok
+    if (percentage < 20) {
+      batChargeLevel = 2 // Critical
+    } else if (percentage < 40) {
+      batChargeLevel = 1 // Warning
+    }
+
+    await this.updateState('powerSource', { batPercentRemaining, batChargeLevel })
+    this.logInfo(`battery updated to: ${percentage}% (${batChargeLevel === 0 ? 'Ok' : batChargeLevel === 1 ? 'Warning' : 'Critical'})`)
+  }
+}

package/src/devices-matter/SmokeCOAlarmAccessory.ts

@@ -0,0 +1,59 @@
+/**
+ * Smoke/CO Alarm Accessory Class
+ */
+
+import type { API, Logger } from 'homebridge'
+
+import { BaseMatterAccessory } from './BaseMatterAccessory.js'
+
+export class SmokeCOAlarmAccessory extends BaseMatterAccessory {
+  constructor(api: API, log: Logger) {
+    const serialNumber = 'SENSOR-006'
+    const SmokeCoAlarmServer = api.matter.deviceTypes.SmokeSensor.requirements.SmokeCoAlarmServer
+    const SmokeSensorWithBoth = api.matter.deviceTypes.SmokeSensor.with(
+      SmokeCoAlarmServer.with('SmokeAlarm', 'CoAlarm'),
+    )
+
+    super(api, log, {
+      uuid: api.matter.uuid.generate(serialNumber),
+      displayName: 'Smoke Sensor',
+      deviceType: SmokeSensorWithBoth,
+      serialNumber,
+      manufacturer: 'Homebridge Matter',
+      model: 'HB-MATTER-SENSOR-SMOKE-CO',
+      firmwareRevision: '2.0.0',
+      hardwareRevision: '1.0.0',
+
+      clusters: {
+        smokeCoAlarm: {
+          smokeState: 0, // 0 = normal, 1 = warning, 2 = critical
+          coState: 0,
+          batteryAlert: 0,
+          deviceMuted: 0,
+          testInProgress: false,
+          hardwareFaultAlert: false,
+          endOfServiceAlert: 0,
+          interconnectSmokeAlarm: 0,
+          interconnectCoAlarm: 0,
+          contaminationState: 0,
+          smokeSensitivityLevel: 1,
+          expressedState: 0,
+        },
+      },
+    })
+
+    this.logInfo('initialized.')
+  }
+
+  public updateSmokeState(state: 0 | 1 | 2): void {
+    this.updateState('smokeCoAlarm', { smokeState: state })
+    const stateStr = ['Normal', 'Warning', 'Critical'][state]
+    this.logInfo(`smoke state: ${stateStr}.`)
+  }
+
+  public updateCOState(state: 0 | 1 | 2): void {
+    this.updateState('smokeCoAlarm', { coState: state })
+    const stateStr = ['Normal', 'Warning', 'Critical'][state]
+    this.logInfo(`co state: ${stateStr}.`)
+  }
+}

package/src/devices-matter/TemperatureSensorAccessory.ts

@@ -0,0 +1,39 @@
+/**
+ * Temperature Sensor Accessory Class
+ */
+
+import type { API, Logger } from 'homebridge'
+
+import { BaseMatterAccessory } from './BaseMatterAccessory.js'
+
+export class TemperatureSensorAccessory extends BaseMatterAccessory {
+  constructor(api: API, log: Logger) {
+    const serialNumber = 'SENSOR-004'
+    super(api, log, {
+      uuid: api.matter.uuid.generate(serialNumber),
+      displayName: 'Temperature Sensor',
+      deviceType: api.matter.deviceTypes.TemperatureSensor,
+      serialNumber,
+      manufacturer: 'Homebridge Matter',
+      model: 'HB-MATTER-SENSOR-TEMPERATURE',
+      firmwareRevision: '2.0.0',
+      hardwareRevision: '1.0.0',
+
+      clusters: {
+        temperatureMeasurement: {
+          measuredValue: 2100, // 21.00°C (in hundredths)
+          minMeasuredValue: -5000,
+          maxMeasuredValue: 10000,
+        },
+      },
+    })
+
+    this.logInfo('initialized.')
+  }
+
+  public updateTemperature(celsius: number): void {
+    const value = Math.round(celsius * 100) // convert to hundredths
+    this.updateState('temperatureMeasurement', { measuredValue: value })
+    this.logInfo(`temperature: ${celsius}°C.`)
+  }
+}

package/src/devices-matter/ThermostatAccessory.ts

@@ -0,0 +1,105 @@
+/**
+ * Thermostat Accessory Class
+ */
+
+import type { API, Logger, MatterRequests } from 'homebridge'
+
+import { BaseMatterAccessory } from './BaseMatterAccessory.js'
+
+export class ThermostatAccessory extends BaseMatterAccessory {
+  constructor(api: API, log: Logger) {
+    const serialNumber = 'THERMOSTAT-001'
+    super(api, log, {
+      uuid: api.matter.uuid.generate(serialNumber),
+      displayName: 'Thermostat',
+      deviceType: api.matter.deviceTypes.Thermostat,
+      serialNumber,
+      manufacturer: 'Homebridge Matter',
+      model: 'HB-MATTER-THERMOSTAT',
+      firmwareRevision: '2.0.0',
+      hardwareRevision: '1.0.0',
+
+      clusters: {
+        thermostat: {
+          localTemperature: 2100, // 21.00°C
+          occupiedHeatingSetpoint: 2000,
+          occupiedCoolingSetpoint: 2400,
+          minHeatSetpointLimit: 700,
+          maxHeatSetpointLimit: 3000,
+          minCoolSetpointLimit: 1600,
+          maxCoolSetpointLimit: 3200,
+          controlSequenceOfOperation: 4, // cooling and heating
+          systemMode: 0, // off
+        },
+      },
+
+      handlers: {
+        thermostat: {
+          setpointRaiseLower: async (request: MatterRequests.SetpointRaiseLower) =>
+            this.handleSetpointRaiseLower(request),
+          systemModeChange: async (request: { systemMode: number, oldSystemMode: number }) =>
+            this.handleSystemModeChange(request),
+          occupiedHeatingSetpointChange: async (request: { occupiedHeatingSetpoint: number, oldOccupiedHeatingSetpoint: number }) =>
+            this.handleOccupiedHeatingSetpointChange(request),
+          occupiedCoolingSetpointChange: async (request: { occupiedCoolingSetpoint: number, oldOccupiedCoolingSetpoint: number }) =>
+            this.handleOccupiedCoolingSetpointChange(request),
+        },
+      },
+    })
+
+    this.logInfo('initialized.')
+  }
+
+  private async handleSetpointRaiseLower(request: MatterRequests.SetpointRaiseLower): Promise<void> {
+    this.logInfo(`SetpointRaiseLower request: ${JSON.stringify(request)}`)
+    const { mode, amount } = request
+    const tempChange = amount / 10 // convert from tenths to degrees
+    this.logInfo(`adjusting setpoint by ${tempChange}°C (mode: ${mode}).`)
+    // TODO: await myThermostatAPI.adjustSetpoint(mode, tempChange)
+  }
+
+  private async handleSystemModeChange(request: { systemMode: number, oldSystemMode: number }): Promise<void> {
+    this.logInfo(`SystemMode change: ${JSON.stringify(request)}`)
+    // Matter Thermostat SystemMode enum: 0=Off, 1=Auto, 3=Cool, 4=Heat, 5=EmergencyHeat, 6=Precooling, 7=FanOnly
+    const modeNames = ['Off', 'Auto', 'Reserved', 'Cool', 'Heat', 'Emergency Heating', 'Precooling', 'Fan Only']
+    const modeName = modeNames[request.systemMode] || `Unknown (${request.systemMode})`
+    this.logInfo(`system mode changed to: ${modeName}.`)
+    // TODO: await myThermostatAPI.setSystemMode(request.systemMode)
+  }
+
+  private async handleOccupiedHeatingSetpointChange(request: { occupiedHeatingSetpoint: number, oldOccupiedHeatingSetpoint: number }): Promise<void> {
+    this.logInfo(`OccupiedHeatingSetpoint change: ${JSON.stringify(request)}`)
+    const celsius = request.occupiedHeatingSetpoint / 100 // convert from hundredths to degrees
+    this.logInfo(`heating setpoint changed to: ${celsius}°C.`)
+    // TODO: await myThermostatAPI.setHeatingSetpoint(celsius)
+  }
+
+  private async handleOccupiedCoolingSetpointChange(request: { occupiedCoolingSetpoint: number, oldOccupiedCoolingSetpoint: number }): Promise<void> {
+    this.logInfo(`OccupiedCoolingSetpoint change: ${JSON.stringify(request)}`)
+    const celsius = request.occupiedCoolingSetpoint / 100 // convert from hundredths to degrees
+    this.logInfo(`cooling setpoint changed to: ${celsius}°C.`)
+    // TODO: await myThermostatAPI.setCoolingSetpoint(celsius)
+  }
+
+  public updateCurrentTemperature(celsius: number): void {
+    const value = Math.round(celsius * 100)
+    this.updateState('thermostat', { localTemperature: value })
+    this.logInfo(`current temperature: ${celsius}°C.`)
+  }
+
+  public updateHeatingSetpoint(celsius: number): void {
+    const value = Math.round(celsius * 100)
+    this.updateState('thermostat', { occupiedHeatingSetpoint: value })
+    this.logInfo(`heating setpoint: ${celsius}°C.`)
+  }
+
+  public updateCoolingSetpoint(celsius: number): void {
+    const value = Math.round(celsius * 100)
+    this.updateState('thermostat', { occupiedCoolingSetpoint: value })
+    this.logInfo(`cooling setpoint: ${celsius}°C.`)
+  }
+
+  public updateSystemMode(mode: number): void {
+    this.updateState('thermostat', { systemMode: mode })
+  }
+}