yoto-nodejs-client 0.0.5 → 0.0.7

package/lib/yoto-device.js

@@ -7,10 +7,11 @@
  */
 
 /**
+ * @import { IConnackPacket } from 'mqtt'
  * @import { YotoClient } from './api-client.js'
  * @import { YotoDevice, YotoDeviceConfig, YotoDeviceShortcuts, YotoDeviceFullStatus, YotoDeviceStatusResponse, YotoDeviceCommand, YotoDeviceCommandResponse } from './api-endpoints/devices.js'
- * @import { YotoMqttClient, YotoMqttStatus, YotoEventsMessage, YotoLegacyStatus } from './mqtt/client.js'
- * @import { MqttClientOptions } from './mqtt/factory.js'
+ * @import { YotoMqttClient, YotoMqttStatus, YotoEventsMessage, YotoLegacyStatus, YotoStatusMessage, YotoStatusLegacyMessage, YotoResponseMessage, YotoMqttClientDisconnectMetadata, YotoMqttClientCloseMetadata, PlaybackStatus } from './mqtt/client.js'
+ * @import { YotoMqttOptions } from './mqtt/factory.js'
  */
 
 import { EventEmitter } from 'events'
@@ -80,6 +81,194 @@ function convertPowerSource (numericSource) {
  * @typedef {'battery' | 'dock' | 'usb-c' | 'wireless'} PowerSource
  */
 
+/**
+ * Normalize "0"/"1" booleans from config to true/false.
+ * @param {string | boolean} value
+ * @returns {boolean}
+ */
+function parseConfigBoolean (value) {
+  if (typeof value === 'boolean') return value
+  return value === '1'
+}
+
+/**
+ * Parse a numeric config field into a number.
+ * @param {string | number} value
+ * @param {number} fallback
+ * @returns {number}
+ */
+function parseConfigNumber (value, fallback) {
+  const parsed = typeof value === 'number' ? value : Number.parseInt(value, 10)
+  return Number.isFinite(parsed) ? parsed : fallback
+}
+
+/**
+ * Parse brightness config values.
+ * @param {string} value
+ * @returns {{ auto: boolean, value: number | null }}
+ */
+function parseConfigBrightness (value) {
+  if (value === 'auto') return { auto: true, value: null }
+  const parsed = Number.parseInt(value, 10)
+  if (Number.isFinite(parsed)) return { auto: false, value: parsed }
+  return { auto: false, value: null }
+}
+
+/**
+ * Parse brightness status values (255 = auto).
+ * @param {number} value
+ * @returns {{ auto: boolean, value: number | null }}
+ */
+function parseStatusBrightness (value) {
+  if (value === 255) return { auto: true, value: null }
+  return { auto: false, value }
+}
+
+/**
+ * Parse "off" sentinel for night Yoto Radio.
+ * @param {string} value
+ * @returns {{ enabled: boolean, value: string | null }}
+ */
+function parseRadioSetting (value) {
+  if (value === '' || value === '0') return { enabled: false, value: null }
+  return { enabled: true, value }
+}
+
+/**
+ * Build a config update payload in API format.
+ * @param {Partial<YotoDeviceModelConfig>} configUpdate
+ * @param {YotoDeviceModelConfig} currentConfig
+ * @returns {Partial<YotoDeviceConfig>}
+ */
+function buildConfigUpdatePayload (configUpdate, currentConfig) {
+  /** @type {Partial<YotoDeviceConfig>} */
+  const update = {}
+  /**
+   * @param {keyof YotoDeviceModelConfig} key
+   * @returns {boolean}
+   */
+  const has = (key) => Object.prototype.hasOwnProperty.call(configUpdate, key)
+
+  if (has('alarms') && configUpdate.alarms !== undefined) update.alarms = configUpdate.alarms
+  if (has('ambientColour') && configUpdate.ambientColour !== undefined) update.ambientColour = configUpdate.ambientColour
+  if (has('bluetoothEnabled') && configUpdate.bluetoothEnabled !== undefined) {
+    update.bluetoothEnabled = configUpdate.bluetoothEnabled ? '1' : '0'
+  }
+  if (has('btHeadphonesEnabled') && configUpdate.btHeadphonesEnabled !== undefined) {
+    update.btHeadphonesEnabled = configUpdate.btHeadphonesEnabled
+  }
+  if (has('clockFace') && configUpdate.clockFace !== undefined) update.clockFace = configUpdate.clockFace
+  if (has('dayTime') && configUpdate.dayTime !== undefined) update.dayTime = configUpdate.dayTime
+  if (has('dayYotoDaily') && configUpdate.dayYotoDaily !== undefined) update.dayYotoDaily = configUpdate.dayYotoDaily
+  if (has('dayYotoRadio') && configUpdate.dayYotoRadio !== undefined) update.dayYotoRadio = configUpdate.dayYotoRadio
+  if (has('daySoundsOff') && configUpdate.daySoundsOff !== undefined) {
+    update.daySoundsOff = configUpdate.daySoundsOff ? '1' : '0'
+  }
+  if (has('displayDimBrightness') && configUpdate.displayDimBrightness !== undefined) {
+    update.displayDimBrightness = String(configUpdate.displayDimBrightness)
+  }
+  if (has('displayDimTimeout') && configUpdate.displayDimTimeout !== undefined) {
+    update.displayDimTimeout = String(configUpdate.displayDimTimeout)
+  }
+  if (has('headphonesVolumeLimited') && configUpdate.headphonesVolumeLimited !== undefined) {
+    update.headphonesVolumeLimited = configUpdate.headphonesVolumeLimited
+  }
+  if (has('hourFormat') && configUpdate.hourFormat !== undefined) {
+    update.hourFormat = String(configUpdate.hourFormat)
+  }
+  if (has('locale') && configUpdate.locale !== undefined) update.locale = configUpdate.locale
+  if (has('logLevel') && configUpdate.logLevel !== undefined) update.logLevel = configUpdate.logLevel
+  if (has('maxVolumeLimit') && configUpdate.maxVolumeLimit !== undefined) {
+    update.maxVolumeLimit = String(configUpdate.maxVolumeLimit)
+  }
+  if (has('nightAmbientColour') && configUpdate.nightAmbientColour !== undefined) {
+    update.nightAmbientColour = configUpdate.nightAmbientColour
+  }
+  if (has('nightMaxVolumeLimit') && configUpdate.nightMaxVolumeLimit !== undefined) {
+    update.nightMaxVolumeLimit = String(configUpdate.nightMaxVolumeLimit)
+  }
+  if (has('nightTime') && configUpdate.nightTime !== undefined) update.nightTime = configUpdate.nightTime
+  if (has('nightYotoDaily') && configUpdate.nightYotoDaily !== undefined) update.nightYotoDaily = configUpdate.nightYotoDaily
+  if (has('nightSoundsOff') && configUpdate.nightSoundsOff !== undefined) {
+    update.nightSoundsOff = configUpdate.nightSoundsOff ? '1' : '0'
+  }
+  if (has('pausePowerButton') && configUpdate.pausePowerButton !== undefined) {
+    update.pausePowerButton = configUpdate.pausePowerButton
+  }
+  if (has('pauseVolumeDown') && configUpdate.pauseVolumeDown !== undefined) {
+    update.pauseVolumeDown = configUpdate.pauseVolumeDown
+  }
+  if (has('repeatAll') && configUpdate.repeatAll !== undefined) update.repeatAll = configUpdate.repeatAll
+  if (has('showDiagnostics') && configUpdate.showDiagnostics !== undefined) {
+    update.showDiagnostics = configUpdate.showDiagnostics
+  }
+  if (has('shutdownTimeout') && configUpdate.shutdownTimeout !== undefined) {
+    update.shutdownTimeout = String(configUpdate.shutdownTimeout)
+  }
+  if (has('systemVolume') && configUpdate.systemVolume !== undefined) {
+    update.systemVolume = String(configUpdate.systemVolume)
+  }
+  if (has('timezone') && configUpdate.timezone !== undefined) update.timezone = configUpdate.timezone
+  if (has('volumeLevel') && configUpdate.volumeLevel !== undefined) update.volumeLevel = configUpdate.volumeLevel
+
+  const hasDayBrightnessValue = has('dayDisplayBrightness')
+  const hasDayBrightnessAuto = has('dayDisplayBrightnessAuto')
+  if (hasDayBrightnessValue || hasDayBrightnessAuto) {
+    const autoValue = hasDayBrightnessAuto ? configUpdate.dayDisplayBrightnessAuto : undefined
+    const auto = autoValue !== undefined
+      ? autoValue
+      : (hasDayBrightnessValue ? false : currentConfig.dayDisplayBrightnessAuto)
+    const value = hasDayBrightnessValue ? configUpdate.dayDisplayBrightness : currentConfig.dayDisplayBrightness
+    if (auto) {
+      update.dayDisplayBrightness = 'auto'
+    } else if (value !== null && value !== undefined) {
+      update.dayDisplayBrightness = String(value)
+    } else {
+      throw new Error('dayDisplayBrightness must be set when dayDisplayBrightnessAuto is false')
+    }
+  }
+
+  const hasNightBrightnessValue = has('nightDisplayBrightness')
+  const hasNightBrightnessAuto = has('nightDisplayBrightnessAuto')
+  if (hasNightBrightnessValue || hasNightBrightnessAuto) {
+    const autoValue = hasNightBrightnessAuto ? configUpdate.nightDisplayBrightnessAuto : undefined
+    const auto = autoValue !== undefined
+      ? autoValue
+      : (hasNightBrightnessValue ? false : currentConfig.nightDisplayBrightnessAuto)
+    const value = hasNightBrightnessValue ? configUpdate.nightDisplayBrightness : currentConfig.nightDisplayBrightness
+    if (auto) {
+      update.nightDisplayBrightness = 'auto'
+    } else if (value !== null && value !== undefined) {
+      update.nightDisplayBrightness = String(value)
+    } else {
+      throw new Error('nightDisplayBrightness must be set when nightDisplayBrightnessAuto is false')
+    }
+  }
+
+  const hasNightRadioValue = has('nightYotoRadio')
+  const hasNightRadioEnabled = has('nightYotoRadioEnabled')
+  if (hasNightRadioValue || hasNightRadioEnabled) {
+    const enabledValue = hasNightRadioEnabled ? configUpdate.nightYotoRadioEnabled : undefined
+    const enabled = enabledValue !== undefined
+      ? enabledValue
+      : (hasNightRadioValue
+          ? configUpdate.nightYotoRadio !== null && configUpdate.nightYotoRadio !== undefined
+          : currentConfig.nightYotoRadioEnabled)
+    const radioValue = hasNightRadioValue ? configUpdate.nightYotoRadio : currentConfig.nightYotoRadio
+    if (enabled) {
+      if (radioValue && radioValue !== '0') {
+        update.nightYotoRadio = radioValue
+      } else {
+        throw new Error('nightYotoRadio must be set when nightYotoRadioEnabled is true')
+      }
+    } else {
+      update.nightYotoRadio = '0'
+    }
+  }
+
+  return update
+}
+
 /**
  * Official Yoto nightlight colors
  *
@@ -120,7 +309,7 @@ export function getNightlightColorName (colorValue) {
  * @property {boolean} isCharging - Whether device is currently charging
  * @property {boolean} isOnline - Whether device is currently online
  * @property {number} volume - User volume level (0-16 scale)
- * @property {number} maxVolume - Maximum volume limit (0-16 scale)
+ * @property {number} maxVolume - Active Maximum volume (depending on day or night) limit (0-16 scale)
  * @property {CardInsertionState} cardInsertionState - Card insertion state
  * @property {DayMode} dayMode - Day mode status
  * @property {PowerSource} powerSource - Power source
@@ -141,12 +330,57 @@ export function getNightlightColorName (colorValue) {
  */
 export const YotoDeviceStatusType = {}
 
+/**
+ * Canonical device config - normalized format for HTTP config payloads
+ *
+ * String booleans and numeric strings are normalized. Brightness "auto" values
+ * are split into value + boolean flag.
+ *
+ * @typedef {Object} YotoDeviceModelConfig
+ * @property {string[]} alarms - Alarm list entries
+ * @property {string} ambientColour - Ambient light color (hex code)
+ * @property {boolean} bluetoothEnabled - Bluetooth enabled state
+ * @property {boolean} btHeadphonesEnabled - Bluetooth headphones enabled
+ * @property {string} clockFace - Clock face style
+ * @property {number | null} dayDisplayBrightness - Day brightness (0-100), null when auto
+ * @property {boolean} dayDisplayBrightnessAuto - Whether day brightness is auto
+ * @property {string} dayTime - Day mode start time
+ * @property {string} dayYotoDaily - Day mode Yoto Daily card path
+ * @property {string} dayYotoRadio - Day mode Yoto Radio card path
+ * @property {boolean} daySoundsOff - Day sounds off
+ * @property {number} displayDimBrightness - Display dim brightness (0-100)
+ * @property {number} displayDimTimeout - Display dim timeout in seconds
+ * @property {boolean} headphonesVolumeLimited - Whether headphones volume is limited
+ * @property {12 | 24} hourFormat - Hour format
+ * @property {string} locale - Device locale
+ * @property {string} logLevel - Log level
+ * @property {number} maxVolumeLimit - Max volume limit (0-16)
+ * @property {string} nightAmbientColour - Night ambient light color (hex code)
+ * @property {number | null} nightDisplayBrightness - Night brightness (0-100), null when auto
+ * @property {boolean} nightDisplayBrightnessAuto - Whether night brightness is auto
+ * @property {number} nightMaxVolumeLimit - Night max volume limit (0-16)
+ * @property {string} nightTime - Night mode start time
+ * @property {string} nightYotoDaily - Night mode Yoto Daily card path
+ * @property {string | null} nightYotoRadio - Night mode Yoto Radio card path
+ * @property {boolean} nightYotoRadioEnabled - Whether night Yoto Radio is enabled
+ * @property {boolean} nightSoundsOff - Night sounds off
+ * @property {boolean} pausePowerButton - Pause on power button press
+ * @property {boolean} pauseVolumeDown - Pause on volume down press
+ * @property {boolean} repeatAll - Repeat all tracks
+ * @property {boolean} showDiagnostics - Show diagnostics
+ * @property {number} shutdownTimeout - Shutdown timeout in seconds
+ * @property {number} systemVolume - System volume level (0-100 percent)
+ * @property {string} timezone - Timezone setting (empty string if not set)
+ * @property {string} volumeLevel - Volume level preset
+ */
+export const YotoDeviceModelConfigType = {}
+
 /**
  * Playback state from MQTT events
  * @typedef {Object} YotoPlaybackState
  * @property {string | null} cardId - Currently playing card ID TODO: Figure out name of card
  * @property {string | null} source - Playback source (e.g., 'card', 'remote', 'MQTT') TODO: Figure out what 'mqtt' source means. Card means card, remote means remotly played card.
- * @property {'playing' | 'paused' | 'stopped' | 'loading' | string | null} playbackStatus - Playback status
+ * @property {PlaybackStatus | null} playbackStatus - Playback status
  * @property {string | null} trackTitle - Current track title
  * @property {string | null} trackKey - Current track key
  * @property {string | null} chapterTitle - Current chapter title
@@ -168,7 +402,7 @@ export const YotoPlaybackStateType = {}
  * Complete device client state
  * @typedef {Object} YotoDeviceClientState
  * @property {YotoDevice} device - Basic device information
- * @property {YotoDeviceConfig} config - Device configuration (always initialized)
+ * @property {YotoDeviceModelConfig} config - Device configuration (always initialized)
  * @property {YotoDeviceShortcuts} shortcuts - Button shortcuts (always initialized)
  * @property {YotoDeviceStatus} status - Current device status (always initialized)
  * @property {YotoPlaybackState} playback - Current playback state (always initialized)
@@ -201,7 +435,7 @@ export const YotoPlaybackStateType = {}
 /**
  * Device client initialization options
  * @typedef {Object} YotoDeviceModelOptions
- * @property {MqttClientOptions} [mqttOptions] - MQTT.js client options to pass through to factory
+ * @property {Omit<YotoMqttOptions, 'deviceId' | 'token' >} [yotoDeviceMqttOptions] - MQTT.js client options to pass through to factory
  * @property {number} [httpPollIntervalMs=600000] - Background HTTP polling interval for config+status sync (default: 10 minutes)
  */
 
@@ -221,11 +455,26 @@ export const YotoPlaybackStateType = {}
  * @property {string} [source] - Source of status update (only present for 'http-status' reason)
  */
 
+/**
+ * MQTT disconnect event metadata (from MQTT disconnect packet)
+ * @typedef {YotoMqttClientDisconnectMetadata} YotoMqttDisconnectMetadata
+ */
+
+/**
+ * MQTT connect event metadata (from MQTT CONNACK)
+ * @typedef {IConnackPacket} YotoMqttConnectMetadata
+ */
+
+/**
+ * MQTT close event metadata (from connection close)
+ * @typedef {YotoMqttClientCloseMetadata} YotoMqttCloseMetadata
+ */
+
 /**
  * Started event metadata
  * @typedef {Object} YotoDeviceStartedMetadata
  * @property {YotoDevice} device - Device information
- * @property {YotoDeviceConfig} config - Device configuration
+ * @property {YotoDeviceModelConfig} config - Device configuration
  * @property {YotoDeviceShortcuts} shortcuts - Device shortcuts
  * @property {YotoDeviceStatus} status - Device status
  * @property {YotoPlaybackState} playback - Playback state
@@ -239,12 +488,21 @@ export const YotoPlaybackStateType = {}
  *   'started': [YotoDeviceStartedMetadata],
  *   'stopped': [],
  *   'statusUpdate': [YotoDeviceStatus, string, Set<keyof YotoDeviceStatus>],
- *   'configUpdate': [YotoDeviceConfig, Set<keyof YotoDeviceConfig>],
+ *   'configUpdate': [YotoDeviceModelConfig, Set<keyof YotoDeviceModelConfig>],
  *   'playbackUpdate': [YotoPlaybackState, Set<keyof YotoPlaybackState>],
  *   'online': [YotoDeviceOnlineMetadata],
  *   'offline': [YotoDeviceOfflineMetadata],
- *   'mqttConnected': [],
- *   'mqttDisconnected': [],
+ *   'mqttConnect': [YotoMqttConnectMetadata],
+ *   'mqttDisconnect': [YotoMqttDisconnectMetadata],
+ *   'mqttClose': [YotoMqttCloseMetadata],
+ *   'mqttReconnect': [],
+ *   'mqttOffline': [],
+ *   'mqttEnd': [],
+ *   'mqttStatus': [string, YotoStatusMessage],
+ *   'mqttEvents': [string, YotoEventsMessage],
+ *   'mqttStatusLegacy': [string, YotoStatusLegacyMessage],
+ *   'mqttResponse': [string, YotoResponseMessage],
+ *   'mqttUnknown': [string, unknown],
  *   'error': [Error]
  * }} YotoDeviceModelEventMap
  */
@@ -271,8 +529,17 @@ export const YotoPlaybackStateType = {}
  * - 'playbackUpdate' - Emitted when playback state changes, passes (playback, changedFields)
  * - 'online' - Emitted when device comes online, passes metadata with reason and optional upTime
  * - 'offline' - Emitted when device goes offline, passes metadata with reason and optional shutDownReason or timeSinceLastSeen
- * - 'mqttConnected' - Emitted when MQTT client connects
- * - 'mqttDisconnected' - Emitted when MQTT client disconnects
+ * - 'mqttConnect' - Emitted when MQTT client connects, passes CONNACK metadata
+ * - 'mqttDisconnect' - Emitted when MQTT disconnect packet received, passes metadata with disconnect packet
+ * - 'mqttClose' - Emitted when MQTT connection closes, passes metadata with close reason
+ * - 'mqttReconnect' - Emitted when MQTT client is reconnecting
+ * - 'mqttOffline' - Emitted when MQTT client goes offline
+ * - 'mqttEnd' - Emitted when MQTT client end is called
+ * - 'mqttStatus' - Emitted with raw MQTT status messages, passes (topic, message)
+ * - 'mqttEvents' - Emitted with raw MQTT events messages, passes (topic, message)
+ * - 'mqttStatusLegacy' - Emitted with raw legacy MQTT status messages, passes (topic, message)
+ * - 'mqttResponse' - Emitted with raw MQTT response messages, passes (topic, message)
+ * - 'mqttUnknown' - Emitted with unknown MQTT messages, passes (topic, message)
  * - 'error' - Emitted when an error occurs, passes error
  *
  * @extends {EventEmitter<YotoDeviceModelEventMap>}
@@ -304,8 +571,8 @@ export class YotoDeviceModel extends EventEmitter {
     }
 
     // Only set mqttOptions if provided (exactOptionalPropertyTypes compatibility)
-    if (options.mqttOptions !== undefined) {
-      this.#options.mqttOptions = options.mqttOptions
+    if (options.yotoDeviceMqttOptions !== undefined) {
+      this.#options.yotoDeviceMqttOptions = options.yotoDeviceMqttOptions
     }
 
     // Initialize state
@@ -372,7 +639,7 @@ export class YotoDeviceModel extends EventEmitter {
 
   /**
    * Get device configuration
-   * @returns {YotoDeviceConfig}
+   * @returns {YotoDeviceModelConfig}
    */
   get config () { return this.#state.config }
 
@@ -500,10 +767,12 @@ export class YotoDeviceModel extends EventEmitter {
       })
 
       // Update state with config data
-      this.#state.config = configResponse.device.config
-      this.#state.shortcuts = configResponse.device.shortcuts
+      this.#updateConfigFromHttp(
+        configResponse.device.config,
+        configResponse.device.shortcuts
+      )
 
-      // Update device info with additional details from config
+      // Update device info with additional detai ls from config
       this.#state.device = {
         ...this.#state.device,
         name: configResponse.device.name,
@@ -600,6 +869,197 @@ export class YotoDeviceModel extends EventEmitter {
     return this.#mqttClient
   }
 
+  // ==========================================================================
+  // Public API - MQTT Commands
+  // ==========================================================================
+
+  /**
+   * Request current events from device over MQTT
+   * @param {string} [body=''] - Optional request body for tracking/identification
+   * @returns {Promise<void>}
+   */
+  async requestEvents (body = '') {
+    return await this.#mqttClient?.requestEvents(body)
+  }
+
+  /**
+   * Request current status from device over MQTT
+   * @param {string} [body=''] - Optional request body for tracking/identification
+   * @returns {Promise<void>}
+   */
+  async requestStatus (body = '') {
+    return await this.#mqttClient?.requestStatus(body)
+  }
+
+  /**
+   * Set device volume over MQTT
+   * @param {number} volume - Volume level integer [0-16]
+   * @returns {Promise<void>}
+   */
+  async setVolume (volume) {
+    const normalizedVolume = Math.min(16, Math.max(0, Math.round(volume)))
+    const volumePercentage = Math.round((normalizedVolume / 16) * 100)
+    return await this.#mqttClient?.setVolume(volumePercentage)
+  }
+
+  /**
+   * Set ambient light color over MQTT
+   * @param {number} r - Red intensity [0-255]
+   * @param {number} g - Green intensity [0-255]
+   * @param {number} b - Blue intensity [0-255]
+   * @returns {Promise<void>}
+   */
+  async setAmbient (r, g, b) {
+    return await this.#mqttClient?.setAmbient(r, g, b)
+  }
+
+  /**
+   * Set ambient light color from hex over MQTT
+   * @param {string} hexColor - Hex color string (e.g., "#FF0000")
+   * @returns {Promise<void>}
+   */
+  async setAmbientHex (hexColor) {
+    return await this.#mqttClient?.setAmbientHex(hexColor)
+  }
+
+  /**
+   * Set sleep timer over MQTT
+   * @param {number} seconds - Timer duration in seconds (0 to disable)
+   * @returns {Promise<void>}
+   */
+  async setSleepTimer (seconds) {
+    return await this.#mqttClient?.setSleepTimer(seconds)
+  }
+
+  /**
+   * Reboot device over MQTT
+   * @returns {Promise<void>}
+   */
+  async reboot () {
+    return await this.#mqttClient?.reboot()
+  }
+
+  /**
+   * Start card playback over MQTT
+   * @param {Object} options - Card start options
+   * @param {string} options.uri - Card URI (e.g., "https://yoto.io/<cardID>")
+   * @param {string} [options.chapterKey] - Chapter to start from
+   * @param {string} [options.trackKey] - Track to start from
+   * @param {number} [options.secondsIn] - Playback start offset in seconds
+   * @param {number} [options.cutOff] - Playback stop offset in seconds
+   * @param {boolean} [options.anyButtonStop] - Whether button press stops playback
+   * @returns {Promise<void>}
+   */
+  async startCard (options) {
+    return await this.#mqttClient?.startCard(options)
+  }
+
+  /**
+   * Stop card playback over MQTT
+   * @returns {Promise<void>}
+   */
+  async stopCard () {
+    return await this.#mqttClient?.stopCard()
+  }
+
+  /**
+   * Pause card playback over MQTT
+   * @returns {Promise<void>}
+   */
+  async pauseCard () {
+    return await this.#mqttClient?.pauseCard()
+  }
+
+  /**
+   * Resume card playback over MQTT
+   * @returns {Promise<void>}
+   */
+  async resumeCard () {
+    return await this.#mqttClient?.resumeCard()
+  }
+
+  /**
+   * Turn Bluetooth on over MQTT
+   * @param {Object} [options] - Bluetooth options
+   * @param {string} [options.action] - Bluetooth action
+   * @param {boolean | string} [options.mode] - Bluetooth mode
+   * @param {number} [options.rssi] - RSSI threshold
+   * @param {string} [options.name] - Target device name
+   * @param {string} [options.mac] - Target device MAC
+   * @returns {Promise<void>}
+   */
+  async bluetoothOn (options) {
+    return await this.#mqttClient?.bluetoothOn(options)
+  }
+
+  /**
+   * Turn Bluetooth off over MQTT
+   * @returns {Promise<void>}
+   */
+  async bluetoothOff () {
+    return await this.#mqttClient?.bluetoothOff()
+  }
+
+  /**
+   * Enable Bluetooth speaker mode over MQTT
+   * @returns {Promise<void>}
+   */
+  async bluetoothSpeakerMode () {
+    return await this.#mqttClient?.bluetoothSpeakerMode()
+  }
+
+  /**
+   * Enable Bluetooth audio source mode over MQTT
+   * @returns {Promise<void>}
+   */
+  async bluetoothAudioSourceMode () {
+    return await this.#mqttClient?.bluetoothAudioSourceMode()
+  }
+
+  /**
+   * Delete all Bluetooth bonds over MQTT
+   * @returns {Promise<void>}
+   */
+  async bluetoothDeleteBonds () {
+    return await this.#mqttClient?.bluetoothDeleteBonds()
+  }
+
+  /**
+   * Connect to Bluetooth device over MQTT
+   * @returns {Promise<void>}
+   */
+  async bluetoothConnect () {
+    return await this.#mqttClient?.bluetoothConnect()
+  }
+
+  /**
+   * Disconnect Bluetooth device over MQTT
+   * @returns {Promise<void>}
+   */
+  async bluetoothDisconnect () {
+    return await this.#mqttClient?.bluetoothDisconnect()
+  }
+
+  /**
+   * Get Bluetooth state over MQTT
+   * @returns {Promise<void>}
+   */
+  async bluetoothGetState () {
+    return await this.#mqttClient?.bluetoothGetState()
+  }
+
+  /**
+   * Preview display icon over MQTT
+   * @param {Object} options - Display preview options
+   * @param {string} options.uri - Icon URI
+   * @param {number} options.timeout - Display duration in seconds
+   * @param {boolean} options.animated - Whether icon is animated
+   * @returns {Promise<void>}
+   */
+  async displayPreview (options) {
+    return await this.#mqttClient?.displayPreview(options)
+  }
+
   // ==========================================================================
   // Public API - Device Control
   // ==========================================================================
@@ -611,7 +1071,7 @@ export class YotoDeviceModel extends EventEmitter {
    */
   /**
    * Refresh device config from HTTP API
-   * @returns {Promise<YotoDeviceConfig>}
+   * @returns {Promise<YotoDeviceModelConfig>}
    */
   async refreshConfig () {
     const configResponse = await this.#client.getDeviceConfig({
@@ -636,14 +1096,17 @@ export class YotoDeviceModel extends EventEmitter {
 
   /**
    * Update device configuration
-   * @param {Partial<YotoDeviceConfig>} configUpdate - Configuration changes
+   * @param {Partial<YotoDeviceModelConfig>} configUpdate - Configuration changes
    * @returns {Promise<void>}
    */
   async updateConfig (configUpdate) {
+    const payload = buildConfigUpdatePayload(configUpdate, this.#state.config)
+    if (Object.keys(payload).length === 0) return
+
     await this.#client.updateDeviceConfig({
       deviceId: this.#state.device.deviceId,
       configUpdate: {
-        config: configUpdate
+        config: payload
       }
     })
 
@@ -675,7 +1138,7 @@ export class YotoDeviceModel extends EventEmitter {
       // Create MQTT client
       this.#mqttClient = await this.#client.createMqttClient({
         deviceId: this.#state.device.deviceId,
-        mqttOptions: this.#options.mqttOptions
+        ...this.#options.yotoDeviceMqttOptions
       })
 
       // Set up MQTT event handlers
@@ -697,23 +1160,41 @@ export class YotoDeviceModel extends EventEmitter {
     if (!this.#mqttClient) return
 
     // Connection events
-    this.#mqttClient.on('connected', () => {
-      this.emit('mqttConnected')
+    this.#mqttClient.on('connect', (metadata) => {
+      this.emit('mqttConnect', metadata)
 
       // Request status and events after settling period
       this.#scheduleMqttRequests()
     })
 
-    this.#mqttClient.on('disconnected', () => {
-      this.#clearAllTimers()
-      this.emit('mqttDisconnected')
+    this.#mqttClient.on('disconnect', (metadata) => {
+      this.#clearMqttRequestTimers()
+      this.emit('mqttDisconnect', metadata)
 
       // Don't immediately mark as offline - MQTT may reconnect
       // Offline detection is based on lack of status updates, not connection state
     })
 
-    this.#mqttClient.on('reconnecting', () => {
-      // MQTT client is attempting to reconnect
+    this.#mqttClient.on('close', (metadata) => {
+      this.#clearMqttRequestTimers()
+      this.emit('mqttClose', metadata)
+
+      // Don't immediately mark as offline - MQTT may reconnect
+      // Offline detection is based on lack of status updates, not connection state
+    })
+
+    this.#mqttClient.on('reconnect', () => {
+      this.emit('mqttReconnect')
+    })
+
+    this.#mqttClient.on('offline', () => {
+      this.#clearMqttRequestTimers()
+      this.emit('mqttOffline')
+    })
+
+    this.#mqttClient.on('end', () => {
+      this.#clearMqttRequestTimers()
+      this.emit('mqttEnd')
     })
 
     this.#mqttClient.on('error', (error) => {
@@ -721,8 +1202,9 @@ export class YotoDeviceModel extends EventEmitter {
     })
 
     // Status updates - PRIMARY source for status after initialization
-    this.#mqttClient.on('status', (_topic, message) => {
+    this.#mqttClient.on('status', (topic, message) => {
       this.#recordDeviceActivity()
+      this.emit('mqttStatus', topic, message)
       this.#updateStatusFromDocumentedMqtt(message.status)
     })
 
@@ -730,20 +1212,25 @@ export class YotoDeviceModel extends EventEmitter {
     // This does NOT respond to requestStatus() - only emits on real-time events or 5-minute periodic updates
     // NOTE: Don't call #recordDeviceActivity() here - #handleLegacyStatus handles online/offline transitions
     // based on actual power state (shutdown/startup) which is more reliable than just "activity"
-    this.#mqttClient.on('status-legacy', (_topic, message) => {
+    this.#mqttClient.on('status-legacy', (topic, message) => {
+      this.emit('mqttStatusLegacy', topic, message)
       this.#handleLegacyStatus(message.status)
     })
 
     // Events updates (playback, volume, etc.)
-    this.#mqttClient.on('events', (_topic, message) => {
+    this.#mqttClient.on('events', (topic, message) => {
       this.#recordDeviceActivity()
+      this.emit('mqttEvents', topic, message)
       this.#handleEventMessage(message)
     })
 
     // Response messages (for debugging/logging)
-    this.#mqttClient.on('response', (_topic, _message) => {
-      // Could emit these for command confirmation
-      // For now just log internally
+    this.#mqttClient.on('response', (topic, message) => {
+      this.emit('mqttResponse', topic, message)
+    })
+
+    this.#mqttClient.on('unknown', (topic, message) => {
+      this.emit('mqttUnknown', topic, message)
     })
   }
 
@@ -752,7 +1239,7 @@ export class YotoDeviceModel extends EventEmitter {
    */
   #scheduleMqttRequests () {
     // Clear any existing timers
-    this.#clearAllTimers()
+    this.#clearMqttRequestTimers()
 
     // Request status after settling delay
     this.#statusRequestTimer = setTimeout(async () => {
@@ -780,9 +1267,9 @@ export class YotoDeviceModel extends EventEmitter {
   }
 
   /**
-   * Clear all timers
+   * Clear MQTT request timers (status/events) after connect
    */
-  #clearAllTimers () {
+  #clearMqttRequestTimers () {
     if (this.#statusRequestTimer) {
       clearTimeout(this.#statusRequestTimer)
       this.#statusRequestTimer = null
@@ -792,13 +1279,26 @@ export class YotoDeviceModel extends EventEmitter {
       clearTimeout(this.#eventsRequestTimer)
       this.#eventsRequestTimer = null
     }
+  }
 
+  /**
+   * Stop background HTTP polling
+   */
+  #stopBackgroundPolling () {
     if (this.#backgroundPollTimer) {
       clearInterval(this.#backgroundPollTimer)
       this.#backgroundPollTimer = null
     }
   }
 
+  /**
+   * Clear all timers
+   */
+  #clearAllTimers () {
+    this.#clearMqttRequestTimers()
+    this.#stopBackgroundPolling()
+  }
+
   // ==========================================================================
   // Private - Online/Offline Tracking
   // ==========================================================================
@@ -896,7 +1396,7 @@ export class YotoDeviceModel extends EventEmitter {
     const { status, config } = this.#state
     /** @type {Set<keyof YotoDeviceStatus>} */
     const changedFields = new Set()
-    /** @type {Set<keyof YotoDeviceConfig>} */
+    /** @type {Set<keyof YotoDeviceModelConfig>} */
     const configChangedFields = new Set()
 
     /**
@@ -1001,9 +1501,15 @@ export class YotoDeviceModel extends EventEmitter {
         }
         case 'dayBright': {
           if (fullStatus.dayBright !== null) {
-            const brightnessValue = String(fullStatus.dayBright)
-            if (config.dayDisplayBrightness !== brightnessValue) {
-              config.dayDisplayBrightness = brightnessValue
+            // HTTP fullStatus represents 'auto' brightness as 255
+            const brightness = parseStatusBrightness(fullStatus.dayBright)
+            if (config.dayDisplayBrightnessAuto !== brightness.auto) {
+              config.dayDisplayBrightnessAuto = brightness.auto
+              configChangedFields.add('dayDisplayBrightnessAuto')
+              configChanged = true
+            }
+            if (config.dayDisplayBrightness !== brightness.value) {
+              config.dayDisplayBrightness = brightness.value
               configChangedFields.add('dayDisplayBrightness')
               configChanged = true
             }
@@ -1093,9 +1599,15 @@ export class YotoDeviceModel extends EventEmitter {
         }
         case 'nightBright': {
           if (fullStatus.nightBright !== null) {
-            const brightnessValue = String(fullStatus.nightBright)
-            if (config.nightDisplayBrightness !== brightnessValue) {
-              config.nightDisplayBrightness = brightnessValue
+            // HTTP fullStatus represents 'auto' brightness as 255
+            const brightness = parseStatusBrightness(fullStatus.nightBright)
+            if (config.nightDisplayBrightnessAuto !== brightness.auto) {
+              config.nightDisplayBrightnessAuto = brightness.auto
+              configChangedFields.add('nightDisplayBrightnessAuto')
+              configChanged = true
+            }
+            if (config.nightDisplayBrightness !== brightness.value) {
+              config.nightDisplayBrightness = brightness.value
               configChangedFields.add('nightDisplayBrightness')
               configChanged = true
             }
@@ -1555,7 +2067,7 @@ export class YotoDeviceModel extends EventEmitter {
     let configChanged = false
 
     const { config } = this.#state
-    /** @type {Set<keyof YotoDeviceConfig>} */
+    /** @type {Set<keyof YotoDeviceModelConfig>} */
     const changedFields = new Set()
 
     /**
@@ -1582,8 +2094,9 @@ export class YotoDeviceModel extends EventEmitter {
           break
         }
         case 'bluetoothEnabled': {
-          if (config.bluetoothEnabled !== configData.bluetoothEnabled) {
-            config.bluetoothEnabled = configData.bluetoothEnabled
+          const bluetoothEnabled = parseConfigBoolean(configData.bluetoothEnabled)
+          if (config.bluetoothEnabled !== bluetoothEnabled) {
+            config.bluetoothEnabled = bluetoothEnabled
             changedFields.add('bluetoothEnabled')
             configChanged = true
           }
@@ -1606,8 +2119,14 @@ export class YotoDeviceModel extends EventEmitter {
           break
         }
         case 'dayDisplayBrightness': {
-          if (config.dayDisplayBrightness !== configData.dayDisplayBrightness) {
-            config.dayDisplayBrightness = configData.dayDisplayBrightness
+          const brightness = parseConfigBrightness(configData.dayDisplayBrightness)
+          if (config.dayDisplayBrightnessAuto !== brightness.auto) {
+            config.dayDisplayBrightnessAuto = brightness.auto
+            changedFields.add('dayDisplayBrightnessAuto')
+            configChanged = true
+          }
+          if (config.dayDisplayBrightness !== brightness.value) {
+            config.dayDisplayBrightness = brightness.value
             changedFields.add('dayDisplayBrightness')
             configChanged = true
           }
@@ -1638,24 +2157,27 @@ export class YotoDeviceModel extends EventEmitter {
           break
         }
         case 'daySoundsOff': {
-          if (config.daySoundsOff !== configData.daySoundsOff) {
-            config.daySoundsOff = configData.daySoundsOff
+          const daySoundsOff = parseConfigBoolean(configData.daySoundsOff)
+          if (config.daySoundsOff !== daySoundsOff) {
+            config.daySoundsOff = daySoundsOff
             changedFields.add('daySoundsOff')
             configChanged = true
           }
           break
         }
         case 'displayDimBrightness': {
-          if (config.displayDimBrightness !== configData.displayDimBrightness) {
-            config.displayDimBrightness = configData.displayDimBrightness
+          const displayDimBrightness = parseConfigNumber(configData.displayDimBrightness, config.displayDimBrightness)
+          if (config.displayDimBrightness !== displayDimBrightness) {
+            config.displayDimBrightness = displayDimBrightness
             changedFields.add('displayDimBrightness')
             configChanged = true
           }
           break
         }
         case 'displayDimTimeout': {
-          if (config.displayDimTimeout !== configData.displayDimTimeout) {
-            config.displayDimTimeout = configData.displayDimTimeout
+          const displayDimTimeout = parseConfigNumber(configData.displayDimTimeout, config.displayDimTimeout)
+          if (config.displayDimTimeout !== displayDimTimeout) {
+            config.displayDimTimeout = displayDimTimeout
             changedFields.add('displayDimTimeout')
             configChanged = true
           }
@@ -1670,8 +2192,9 @@ export class YotoDeviceModel extends EventEmitter {
           break
         }
         case 'hourFormat': {
-          if (config.hourFormat !== configData.hourFormat) {
-            config.hourFormat = configData.hourFormat
+          const hourFormat = parseConfigNumber(configData.hourFormat, config.hourFormat)
+          if (config.hourFormat !== hourFormat) {
+            config.hourFormat = /** @type {12 | 24} */ (hourFormat)
             changedFields.add('hourFormat')
             configChanged = true
           }
@@ -1694,8 +2217,9 @@ export class YotoDeviceModel extends EventEmitter {
           break
         }
         case 'maxVolumeLimit': {
-          if (config.maxVolumeLimit !== configData.maxVolumeLimit) {
-            config.maxVolumeLimit = configData.maxVolumeLimit
+          const maxVolumeLimit = parseConfigNumber(configData.maxVolumeLimit, config.maxVolumeLimit)
+          if (config.maxVolumeLimit !== maxVolumeLimit) {
+            config.maxVolumeLimit = maxVolumeLimit
             changedFields.add('maxVolumeLimit')
             configChanged = true
           }
@@ -1710,16 +2234,23 @@ export class YotoDeviceModel extends EventEmitter {
           break
         }
         case 'nightDisplayBrightness': {
-          if (config.nightDisplayBrightness !== configData.nightDisplayBrightness) {
-            config.nightDisplayBrightness = configData.nightDisplayBrightness
+          const brightness = parseConfigBrightness(configData.nightDisplayBrightness)
+          if (config.nightDisplayBrightnessAuto !== brightness.auto) {
+            config.nightDisplayBrightnessAuto = brightness.auto
+            changedFields.add('nightDisplayBrightnessAuto')
+            configChanged = true
+          }
+          if (config.nightDisplayBrightness !== brightness.value) {
+            config.nightDisplayBrightness = brightness.value
             changedFields.add('nightDisplayBrightness')
             configChanged = true
           }
           break
         }
         case 'nightMaxVolumeLimit': {
-          if (config.nightMaxVolumeLimit !== configData.nightMaxVolumeLimit) {
-            config.nightMaxVolumeLimit = configData.nightMaxVolumeLimit
+          const nightMaxVolumeLimit = parseConfigNumber(configData.nightMaxVolumeLimit, config.nightMaxVolumeLimit)
+          if (config.nightMaxVolumeLimit !== nightMaxVolumeLimit) {
+            config.nightMaxVolumeLimit = nightMaxVolumeLimit
             changedFields.add('nightMaxVolumeLimit')
             configChanged = true
           }
@@ -1742,16 +2273,23 @@ export class YotoDeviceModel extends EventEmitter {
           break
         }
         case 'nightYotoRadio': {
-          if (config.nightYotoRadio !== configData.nightYotoRadio) {
-            config.nightYotoRadio = configData.nightYotoRadio
+          const radio = parseRadioSetting(configData.nightYotoRadio)
+          if (config.nightYotoRadioEnabled !== radio.enabled) {
+            config.nightYotoRadioEnabled = radio.enabled
+            changedFields.add('nightYotoRadioEnabled')
+            configChanged = true
+          }
+          if (config.nightYotoRadio !== radio.value) {
+            config.nightYotoRadio = radio.value
             changedFields.add('nightYotoRadio')
             configChanged = true
           }
           break
         }
         case 'nightSoundsOff': {
-          if (config.nightSoundsOff !== configData.nightSoundsOff) {
-            config.nightSoundsOff = configData.nightSoundsOff
+          const nightSoundsOff = parseConfigBoolean(configData.nightSoundsOff)
+          if (config.nightSoundsOff !== nightSoundsOff) {
+            config.nightSoundsOff = nightSoundsOff
             changedFields.add('nightSoundsOff')
             configChanged = true
           }
@@ -1790,16 +2328,18 @@ export class YotoDeviceModel extends EventEmitter {
           break
         }
         case 'shutdownTimeout': {
-          if (config.shutdownTimeout !== configData.shutdownTimeout) {
-            config.shutdownTimeout = configData.shutdownTimeout
+          const shutdownTimeout = parseConfigNumber(configData.shutdownTimeout, config.shutdownTimeout)
+          if (config.shutdownTimeout !== shutdownTimeout) {
+            config.shutdownTimeout = shutdownTimeout
             changedFields.add('shutdownTimeout')
             configChanged = true
           }
           break
         }
         case 'systemVolume': {
-          if (config.systemVolume !== configData.systemVolume) {
-            config.systemVolume = configData.systemVolume
+          const systemVolume = parseConfigNumber(configData.systemVolume, config.systemVolume)
+          if (config.systemVolume !== systemVolume) {
+            config.systemVolume = systemVolume
             changedFields.add('systemVolume')
             configChanged = true
           }
@@ -1889,7 +2429,7 @@ export class YotoDeviceModel extends EventEmitter {
     const { status, config } = this.#state
     /** @type {Set<keyof YotoDeviceStatus>} */
     const changedFields = new Set()
-    /** @type {Set<keyof YotoDeviceConfig>} */
+    /** @type {Set<keyof YotoDeviceModelConfig>} */
     const configChangedFields = new Set()
 
     /**
@@ -1996,18 +2536,30 @@ export class YotoDeviceModel extends EventEmitter {
           break
         }
         case 'dayBright': {
-          const brightnessValue = String(mqttStatus.dayBright)
-          if (config.dayDisplayBrightness !== brightnessValue) {
-            config.dayDisplayBrightness = brightnessValue
+          // MQTT represents 'auto' brightness as 255
+          const brightness = parseStatusBrightness(mqttStatus.dayBright)
+          if (config.dayDisplayBrightnessAuto !== brightness.auto) {
+            config.dayDisplayBrightnessAuto = brightness.auto
+            configChangedFields.add('dayDisplayBrightnessAuto')
+            configChanged = true
+          }
+          if (config.dayDisplayBrightness !== brightness.value) {
+            config.dayDisplayBrightness = brightness.value
             configChangedFields.add('dayDisplayBrightness')
             configChanged = true
           }
           break
         }
         case 'nightBright': {
-          const brightnessValue = String(mqttStatus.nightBright)
-          if (config.nightDisplayBrightness !== brightnessValue) {
-            config.nightDisplayBrightness = brightnessValue
+          // MQTT represents 'auto' brightness as 255
+          const brightness = parseStatusBrightness(mqttStatus.nightBright)
+          if (config.nightDisplayBrightnessAuto !== brightness.auto) {
+            config.nightDisplayBrightnessAuto = brightness.auto
+            configChangedFields.add('nightDisplayBrightnessAuto')
+            configChanged = true
+          }
+          if (config.nightDisplayBrightness !== brightness.value) {
+            config.nightDisplayBrightness = brightness.value
             configChangedFields.add('nightDisplayBrightness')
             configChanged = true
           }
@@ -2125,7 +2677,7 @@ export class YotoDeviceModel extends EventEmitter {
     const { status, config } = this.#state
     /** @type {Set<keyof YotoDeviceStatus>} */
     const changedFields = new Set()
-    /** @type {Set<keyof YotoDeviceConfig>} */
+    /** @type {Set<keyof YotoDeviceModelConfig>} */
     const configChangedFields = new Set()
 
     /**
@@ -2361,18 +2913,30 @@ export class YotoDeviceModel extends EventEmitter {
           break
         }
         case 'dayBright': {
-          const brightnessValue = String(legacyStatus.dayBright)
-          if (config.dayDisplayBrightness !== brightnessValue) {
-            config.dayDisplayBrightness = brightnessValue
+          // MQTT represents 'auto' brightness as 255
+          const brightness = parseStatusBrightness(legacyStatus.dayBright)
+          if (config.dayDisplayBrightnessAuto !== brightness.auto) {
+            config.dayDisplayBrightnessAuto = brightness.auto
+            configChangedFields.add('dayDisplayBrightnessAuto')
+            configChanged = true
+          }
+          if (config.dayDisplayBrightness !== brightness.value) {
+            config.dayDisplayBrightness = brightness.value
             configChangedFields.add('dayDisplayBrightness')
             configChanged = true
           }
           break
         }
         case 'nightBright': {
-          const brightnessValue = String(legacyStatus.nightBright)
-          if (config.nightDisplayBrightness !== brightnessValue) {
-            config.nightDisplayBrightness = brightnessValue
+          // MQTT represents 'auto' brightness as 255
+          const brightness = parseStatusBrightness(legacyStatus.nightBright)
+          if (config.nightDisplayBrightnessAuto !== brightness.auto) {
+            config.nightDisplayBrightnessAuto = brightness.auto
+            configChangedFields.add('nightDisplayBrightnessAuto')
+            configChanged = true
+          }
+          if (config.nightDisplayBrightness !== brightness.value) {
+            config.nightDisplayBrightness = brightness.value
             configChangedFields.add('nightDisplayBrightness')
             configChanged = true
           }
@@ -2523,8 +3087,8 @@ export class YotoDeviceModel extends EventEmitter {
    * Uses exhaustive switch statement pattern to ensure all YotoEventsMessage fields are handled.
    *
    * Event fields are categorized as:
-   * - STATUS: volume
-   * - CONFIG: repeatAll, volumeMax
+   * - STATUS: volume, volumeMax
+   * - CONFIG: repeatAll
    * - PLAYBACK: streaming, sleepTimerActive, sleepTimerSeconds, trackLength,
    *             position, cardId, source, playbackStatus, chapterTitle, chapterKey,
    *             trackTitle, trackKey
@@ -2540,7 +3104,7 @@ export class YotoDeviceModel extends EventEmitter {
     const { status, config, playback } = this.#state
     /** @type {Set<keyof YotoDeviceStatus>} */
     const statusChangedFields = new Set()
-    /** @type {Set<keyof YotoDeviceConfig>} */
+    /** @type {Set<keyof YotoDeviceModelConfig>} */
     const configChangedFields = new Set()
     /** @type {Set<keyof YotoPlaybackState>} */
     const playbackChangedFields = new Set()
@@ -2571,7 +3135,6 @@ export class YotoDeviceModel extends EventEmitter {
         }
         case 'volumeMax': {
           // volumeMax is the current effective max volume limit (config-derived)
-          // Store as string to match config type (maxVolumeLimit is string)
           if (eventsMessage.volumeMax !== undefined && status.maxVolume !== eventsMessage.volumeMax) {
             status.maxVolume = eventsMessage.volumeMax
             statusChangedFields.add('maxVolume')
@@ -2750,40 +3313,43 @@ function createEmptyPlaybackState () {
 
 /**
  * Create an empty device config object
- * @returns {YotoDeviceConfig}
+ * @returns {YotoDeviceModelConfig}
  */
 function createEmptyDeviceConfig () {
   return {
     alarms: [],
     ambientColour: '#000000',
-    bluetoothEnabled: '0',
+    bluetoothEnabled: false,
     btHeadphonesEnabled: false,
     clockFace: 'digital-sun',
-    dayDisplayBrightness: 'auto',
+    dayDisplayBrightness: null,
+    dayDisplayBrightnessAuto: true,
     dayTime: '07:00',
     dayYotoDaily: '',
     dayYotoRadio: '',
-    daySoundsOff: '0',
-    displayDimBrightness: '0',
-    displayDimTimeout: '30',
+    daySoundsOff: false,
+    displayDimBrightness: 0,
+    displayDimTimeout: 30,
     headphonesVolumeLimited: false,
-    hourFormat: '12',
+    hourFormat: 12,
     locale: 'en',
     logLevel: 'none',
-    maxVolumeLimit: '16',
+    maxVolumeLimit: 16,
     nightAmbientColour: '#000000',
-    nightDisplayBrightness: 'auto',
-    nightMaxVolumeLimit: '10',
+    nightDisplayBrightness: null,
+    nightDisplayBrightnessAuto: true,
+    nightMaxVolumeLimit: 10,
     nightTime: '19:00',
     nightYotoDaily: '',
-    nightYotoRadio: '',
-    nightSoundsOff: '0',
+    nightYotoRadio: null,
+    nightYotoRadioEnabled: false,
+    nightSoundsOff: false,
     pausePowerButton: false,
     pauseVolumeDown: false,
     repeatAll: false,
     showDiagnostics: false,
-    shutdownTimeout: '900',
-    systemVolume: '100',
+    shutdownTimeout: 900,
+    systemVolume: 100,
     timezone: '',
     volumeLevel: 'safe'
   }