@switchbot/homebridge-switchbot 3.5.1-beta.9 → 3.5.1

package/dist/platform.js

@@ -38,8 +38,9 @@ import fakegato from 'fakegato-history';
 import crypto, { randomUUID } from 'crypto';
 import { readFileSync, writeFileSync } from 'fs';
 import { EveHomeKitTypes } from 'homebridge-lib/EveHomeKitTypes';
+import { PLATFORM_NAME, PLUGIN_NAME, Devices, deleteWebhook, queryWebhook, setupWebhook, updateWebhook } from './settings.js';
 import { isBlindTiltDevice, isCurtainDevice, sleep } from './utils.js';
-import { PLATFORM_NAME, PLUGIN_NAME, Devices, setupWebhook, updateWebhook, deleteWebhook, queryWebhook } from './settings.js';
+import { SwitchBotModel } from 'node-switchbot';
 /**
  * HomebridgePlatform
  * This class is the main constructor for your plugin, this is where you should
@@ -57,10 +58,10 @@ export class SwitchBotPlatform {
     platformConfig;
     platformLogging;
     config;
-    webhookEventListener = null;
     mqttClient = null;
-    fakegatoAPI;
+    webhookEventListener = null;
     eve;
+    fakegatoAPI;
     webhookEventHandler = {};
     constructor(log, config, api) {
         // initialize
@@ -117,7 +118,7 @@ export class SwitchBotPlatform {
             }
             catch (e) {
                 this.errorLog(`Failed to Discover, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
-                this.debugErrorLog(`Failed to Discover, Error: ${e}`);
+                await this.debugErrorLog(`Failed to Discover, Error: ${e}`);
             }
         });
         this.setupMqtt();
@@ -138,7 +139,7 @@ export class SwitchBotPlatform {
                     this.mqttClient.subscribe('homebridge-switchbot/webhook/+');
                     this.mqttClient.on('message', async (topic, message) => {
                         try {
-                            await this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
+                            await await this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
                             const context = JSON.parse(message.toString());
                             this.webhookEventHandler[context.deviceMac]?.(context);
                         }
@@ -168,7 +169,7 @@ export class SwitchBotPlatform {
                             request.on('data', async (data) => {
                                 try {
                                     const body = JSON.parse(data);
-                                    this.debugLog(`Received Webhook: ${JSON.stringify(body)}`);
+                                    await this.debugLog(`Received Webhook: ${JSON.stringify(body)}`);
                                     if (this.config.options?.mqttURL) {
                                         const mac = body.context.deviceMac
                                             ?.toLowerCase()
@@ -211,9 +212,9 @@ export class SwitchBotPlatform {
                     }),
                 });
                 const response = await body.json();
-                this.debugLog(`setupWebhook: url:${url}`);
-                this.debugLog(`setupWebhook: body:${JSON.stringify(response)}`);
-                this.debugLog(`setupWebhook: statusCode:${statusCode}`);
+                await this.debugLog(`setupWebhook: url:${url}`);
+                await this.debugLog(`setupWebhook: body:${JSON.stringify(response)}`);
+                await this.debugLog(`setupWebhook: statusCode:${statusCode}`);
                 if (statusCode !== 200 || response?.statusCode !== 100) {
                     this.errorLog(`Failed to configure webhook. Existing webhook well be overridden. HTTP:${statusCode} API:${response?.statusCode} `
                         + `message:${response?.message}`);
@@ -233,9 +234,9 @@ export class SwitchBotPlatform {
                     }),
                 });
                 const response = await body.json();
-                this.debugLog(`updateWebhook: url:${url}`);
-                this.debugLog(`updateWebhook: body:${JSON.stringify(response)}`);
-                this.debugLog(`updateWebhook: statusCode:${statusCode}`);
+                await this.debugLog(`updateWebhook: url:${url}`);
+                await this.debugLog(`updateWebhook: body:${JSON.stringify(response)}`);
+                await this.debugLog(`updateWebhook: statusCode:${statusCode}`);
                 if (statusCode !== 200 || response?.statusCode !== 100) {
                     this.errorLog(`Failed to update webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                 }
@@ -252,8 +253,8 @@ export class SwitchBotPlatform {
                     }),
                 });
                 const response = await body.json();
-                this.debugLog(`queryWebhook: body:${JSON.stringify(response)}`);
-                this.debugLog(`queryWebhook: statusCode:${statusCode}`);
+                await this.debugLog(`queryWebhook: body:${JSON.stringify(response)}`);
+                await this.debugLog(`queryWebhook: statusCode:${statusCode}`);
                 if (statusCode !== 200 || response?.statusCode !== 100) {
                     this.errorLog(`Failed to query webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                 }
@@ -275,7 +276,7 @@ export class SwitchBotPlatform {
                         }),
                     });
                     const response = await body.json();
-                    this.debugLog(`deleteWebhook: url:${url}, body:${JSON.stringify(response)}, statusCode:${statusCode}`);
+                    await this.debugLog(`deleteWebhook: url:${url}, body:${JSON.stringify(response)}, statusCode:${statusCode}`);
                     if (statusCode !== 200 || response?.statusCode !== 100) {
                         this.errorLog(`Failed to delete webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                     }
@@ -293,8 +294,8 @@ export class SwitchBotPlatform {
      * This function is invoked when homebridge restores cached accessories from disk at startup.
      * It should be used to setup event handlers for characteristics and update respective values.
      */
-    configureAccessory(accessory) {
-        this.debugLog(`Loading accessory from cache: ${accessory.displayName}`);
+    async configureAccessory(accessory) {
+        await this.debugLog(`Loading accessory from cache: ${accessory.displayName}`);
         // add the restored accessory to the accessories cache so we can track if it has already been registered
         this.accessories.push(accessory);
     }
@@ -316,7 +317,7 @@ export class SwitchBotPlatform {
             platformConfig['pushRate'] = this.config.options.pushRate;
         }
         if (Object.entries(platformConfig).length !== 0) {
-            this.debugWarnLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
+            await this.debugWarnLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
         }
         if (this.config.options) {
             // Device Config
@@ -431,7 +432,7 @@ export class SwitchBotPlatform {
             if (pluginConfig.credentials.token) {
                 pluginConfig.credentials.openToken = undefined;
             }
-            this.debugWarnLog(`token: ${pluginConfig.credentials.token}`);
+            await this.debugWarnLog(`token: ${pluginConfig.credentials.token}`);
             // save the config, ensuring we maintain pretty json
             writeFileSync(this.api.user.configPath(), JSON.stringify(currentConfig, null, 4));
             this.verifyConfig();
@@ -471,29 +472,29 @@ export class SwitchBotPlatform {
             let retryCount = 0;
             const maxRetries = this.maxRetries; // Maximum number of retries
             const delayBetweenRetries = this.delayBetweenRetries; // Delay between retries in milliseconds
-            this.debugWarnLog(`Retry Count: ${retryCount}`);
-            this.debugWarnLog(`Max Retries: ${maxRetries}`);
-            this.debugWarnLog(`Delay Between Retries: ${delayBetweenRetries}`);
+            await this.debugWarnLog(`Retry Count: ${retryCount}`);
+            await this.debugWarnLog(`Max Retries: ${maxRetries}`);
+            await this.debugWarnLog(`Delay Between Retries: ${delayBetweenRetries}`);
             while (retryCount < maxRetries) {
                 try {
                     const { body, statusCode } = await request(Devices, {
                         headers: this.generateHeaders(),
                     });
-                    this.debugWarnLog(`statusCode: ${statusCode}`);
+                    await this.debugWarnLog(`statusCode: ${statusCode}`);
                     const devicesAPI = await body.json();
-                    this.debugWarnLog(`devicesAPI: ${JSON.stringify(devicesAPI)}`);
-                    this.debugWarnLog(`devicesAPI Body: ${JSON.stringify(devicesAPI.body)}`);
-                    this.debugWarnLog(`devicesAPI StatusCode: ${devicesAPI.statusCode}`);
+                    await this.debugWarnLog(`devicesAPI: ${JSON.stringify(devicesAPI)}`);
+                    await this.debugWarnLog(`devicesAPI Body: ${JSON.stringify(devicesAPI.body)}`);
+                    await this.debugWarnLog(`devicesAPI StatusCode: ${devicesAPI.statusCode}`);
                     if ((statusCode === 200 || statusCode === 100) && (devicesAPI.statusCode === 200 || devicesAPI.statusCode === 100)) {
-                        this.debugErrorLog(`statusCode: ${statusCode} & devicesAPI StatusCode: ${devicesAPI.statusCode}`);
+                        await this.debugErrorLog(`statusCode: ${statusCode} & devicesAPI StatusCode: ${devicesAPI.statusCode}`);
                         // SwitchBot Devices
                         const deviceLists = devicesAPI.body.deviceList;
-                        this.debugWarnLog(`DeviceLists: ${JSON.stringify(deviceLists)}`);
-                        this.debugWarnLog(`DeviceLists Length: ${deviceLists.length}`);
+                        await this.debugWarnLog(`DeviceLists: ${JSON.stringify(deviceLists)}`);
+                        await this.debugWarnLog(`DeviceLists Length: ${deviceLists.length}`);
                         if (!this.config.options?.devices) {
-                            this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
+                            await this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
                             if (deviceLists.length === 0) {
-                                this.debugLog(`SwitchBot API Currently Doesn't Have Any Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
+                                await this.debugLog(`SwitchBot API Has No Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
                             }
                             else {
                                 const devices = deviceLists.map((v) => v);
@@ -508,9 +509,9 @@ export class SwitchBotPlatform {
                             }
                         }
                         else if (this.config.credentials?.token && this.config.options.devices) {
-                            this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+                            await this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
                             if (deviceLists.length === 0) {
-                                this.debugLog(`SwitchBot API Currently Doesn't Have Any Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
+                                await this.debugLog(`SwitchBot API Has No Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
                             }
                             else {
                                 const deviceConfigs = this.config.options?.devices;
@@ -519,7 +520,7 @@ export class SwitchBotPlatform {
                                     ...itm,
                                 }));
                                 const devices = mergeBydeviceId(deviceLists, deviceConfigs);
-                                this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
+                                await this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
                                 for (const device of devices) {
                                     if (!device.deviceType) {
                                         device.deviceType = device.configDeviceType;
@@ -541,12 +542,12 @@ export class SwitchBotPlatform {
                             this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
                         }
                         else {
-                            this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
+                            await this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
                         }
                         // IR Devices
                         const irDeviceLists = devicesAPI.body.infraredRemoteList;
                         if (!this.config.options?.irdevices) {
-                            this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+                            await this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
                             const devices = irDeviceLists.map((v) => v);
                             for (const device of devices) {
                                 if (device.remoteType) {
@@ -555,14 +556,14 @@ export class SwitchBotPlatform {
                             }
                         }
                         else {
-                            this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+                            await this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
                             const irDeviceConfig = this.config.options?.irdevices;
                             const mergeIRBydeviceId = (a1, a2) => a1.map((itm) => ({
                                 ...a2.find((item) => item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item),
                                 ...itm,
                             }));
                             const devices = mergeIRBydeviceId(irDeviceLists, irDeviceConfig);
-                            this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
+                            await this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
                             for (const device of devices) {
                                 this.createIRDevice(device);
                             }
@@ -571,7 +572,7 @@ export class SwitchBotPlatform {
                             this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
                         }
                         else {
-                            this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
+                            await this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
                         }
                         break;
                     }
@@ -588,12 +589,12 @@ export class SwitchBotPlatform {
                 catch (e) {
                     retryCount++;
                     this.debugErrorLog(`Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
-                    this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
+                    await this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
                 }
             }
         }
         else if (!this.config.credentials?.token && this.config.options?.devices) {
-            this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+            await this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
             const deviceConfigs = this.config.options?.devices;
             const devices = deviceConfigs.map((v) => v);
             for (const device of devices) {
@@ -608,73 +609,73 @@ export class SwitchBotPlatform {
             this.errorLog('Neither SwitchBot Token or Device Config are not set.');
         }
     }
-    createDevice(device) {
+    async createDevice(device) {
         switch (device.deviceType) {
             case 'Humidifier':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createHumidifier(device);
                 break;
             case 'Hub Mini':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 break;
             case 'Hub Plus':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 break;
             case 'Hub 2':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createHub2(device);
                 break;
             case 'Bot':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createBot(device);
                 break;
             case 'Meter':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createMeter(device);
                 break;
             case 'MeterPlus':
             case 'Meter Plus (JP)':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createMeterPlus(device);
                 break;
             case 'WoIOSensor':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createIOSensor(device);
                 break;
             case 'Water Detector':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createWaterDetector(device);
                 break;
             case 'Motion Sensor':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createMotion(device);
                 break;
             case 'Contact Sensor':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createContact(device);
                 break;
             case 'Curtain':
             case 'Curtain3':
-                this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
                 this.createCurtain(device);
                 break;
             case 'Blind Tilt':
-                this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
                 this.createBlindTilt(device);
                 break;
             case 'Plug':
             case 'Plug Mini (US)':
             case 'Plug Mini (JP)':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createPlug(device);
                 break;
             case 'Smart Lock':
             case 'Smart Lock Pro':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createLock(device);
                 break;
             case 'Color Bulb':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createColorBulb(device);
                 break;
             case 'K10+':
@@ -683,32 +684,32 @@ export class SwitchBotPlatform {
             case 'Robot Vacuum Cleaner S1':
             case 'Robot Vacuum Cleaner S1 Plus':
             case 'Robot Vacuum Cleaner S10':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createRobotVacuumCleaner(device);
                 break;
             case 'Ceiling Light':
             case 'Ceiling Light Pro':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createCeilingLight(device);
                 break;
             case 'Strip Light':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createStripLight(device);
                 break;
             case 'Battery Circulator Fan':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
                 this.createFan(device);
                 break;
             case 'Remote':
             case 'Indoor Cam':
             case 'remote with screen+':
-                this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}, is currently not supported, device: ${JSON.stringify(device)}`);
+                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}, is currently not supported, device: ${JSON.stringify(device)}`);
                 break;
             default:
                 this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.deviceType}, is currently not supported.`, +`Submit Feature Requests Here: https://tinyurl.com/SwitchBotFeatureRequest, device: ${JSON.stringify(device)}`);
         }
     }
-    createIRDevice(device) {
+    async createIRDevice(device) {
         if (device.connectionType === undefined) {
             device.connectionType = 'OpenAPI';
         }
@@ -725,7 +726,7 @@ export class SwitchBotPlatform {
             case 'DIY DVD':
             case 'Speaker':
             case 'DIY Speaker':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 if (device.external === undefined) {
                     device.external = true;
                     this.createTV(device);
@@ -736,45 +737,45 @@ export class SwitchBotPlatform {
                 break;
             case 'Fan':
             case 'DIY Fan':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createIRFan(device);
                 break;
             case 'Air Conditioner':
             case 'DIY Air Conditioner':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createAirConditioner(device);
                 break;
             case 'Light':
             case 'DIY Light':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createLight(device);
                 break;
             case 'Air Purifier':
             case 'DIY Air Purifier':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createAirPurifier(device);
                 break;
             case 'Water Heater':
             case 'DIY Water Heater':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createWaterHeater(device);
                 break;
             case 'Vacuum Cleaner':
             case 'DIY Vacuum Cleaner':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createVacuumCleaner(device);
                 break;
             case 'Camera':
             case 'DIY Camera':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createCamera(device);
                 break;
             case 'Others':
-                this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
                 this.createOthers(device);
                 break;
             default:
-                this.debugLog(`Unsupported Device: ${JSON.stringify(device)}`);
+                await this.debugLog(`Unsupported Device: ${JSON.stringify(device)}`);
                 this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.remoteType}, is currently not supported.`);
                 this.warnLog('Submit Feature Requests Here: ' + 'https://tinyurl.com/SwitchBotFeatureRequest');
         }
@@ -788,52 +789,48 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = SwitchBotModel.Humidifier;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Humidifier(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = SwitchBotModel.Humidifier;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Humidifier(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createBot(device) {
@@ -845,53 +842,49 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = SwitchBotModel.Bot;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Bot(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = SwitchBotModel.Bot;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // accessory.context.version = findaccessories.accessoryAttribute.softwareRevision;
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Bot(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createMeter(device) {
@@ -903,52 +896,48 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.model = SwitchBotModel.Meter;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Meter(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.model = SwitchBotModel.Meter;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Meter(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createMeterPlus(device) {
@@ -961,52 +950,48 @@ export class SwitchBotPlatform {
             if (await this.registerDevice(device)) {
                 // console.log("existingAccessory", existingAccessory);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.model = SwitchBotModel.MeterPlusUS ?? SwitchBotModel.MeterPlusJP;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new MeterPlus(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.model = SwitchBotModel.MeterPlusUS ?? SwitchBotModel.MeterPlusJP;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new MeterPlus(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createHub2(device) {
@@ -1019,52 +1004,48 @@ export class SwitchBotPlatform {
             if (await this.registerDevice(device)) {
                 // console.log("existingAccessory", existingAccessory);
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.model = SwitchBotModel.Hub2;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Hub(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.model = SwitchBotModel.Hub2;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Hub(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createIOSensor(device) {
@@ -1076,52 +1057,48 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.model = SwitchBotModel.OutdoorMeter;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new IOSensor(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.model = SwitchBotModel.OutdoorMeter;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new IOSensor(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createWaterDetector(device) {
@@ -1133,52 +1110,48 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = SwitchBotModel.WaterDetector;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new WaterDetector(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = SwitchBotModel.WaterDetector;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             accessory.context.connectionType = await this.connectionType(device);
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new WaterDetector(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createMotion(device) {
@@ -1190,52 +1163,48 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = SwitchBotModel.MotionSensor;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Motion(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = SwitchBotModel.MotionSensor;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Motion(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createContact(device) {
@@ -1247,52 +1216,48 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = SwitchBotModel.ContactSensor;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Contact(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = SwitchBotModel.ContactSensor;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Contact(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createBlindTilt(device) {
@@ -1304,41 +1269,36 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = SwitchBotModel.BlindTilt;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new BlindTilt(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             if (isBlindTiltDevice(device)) {
                 if (device.group && !device.curtain?.disable_group) {
                     this.debugLog('Your Curtains are grouped, ' +
-                        `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                        `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, deviceId: ${device.deviceId}`);
                 }
                 else {
                     if (device.master) {
-                        this.warnLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                        this.warnLog(`Main Curtain: ${device.deviceName}, deviceId: ${device.deviceId}`);
                     }
                     else {
-                        this.errorLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                        this.errorLog(`Secondary Curtain: ${device.deviceName}, deviceId: ${device.deviceId}`);
                     }
                 }
             }
@@ -1347,23 +1307,25 @@ export class SwitchBotPlatform {
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            ;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = SwitchBotModel.BlindTilt;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new BlindTilt(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createCurtain(device) {
@@ -1375,41 +1337,36 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = device.deviceType === 'Curtain3' ? SwitchBotModel.Curtain3 : SwitchBotModel.Curtain;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Curtain(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             if (isCurtainDevice(device)) {
                 if (device.group && !device.curtain?.disable_group) {
                     this.debugLog('Your Curtains are grouped, ' +
-                        `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                        `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, deviceId: ${device.deviceId}`);
                 }
                 else {
                     if (device.master) {
-                        this.warnLog(`Main Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                        this.warnLog(`Main Curtain: ${device.deviceName}, deviceId: ${device.deviceId}`);
                     }
                     else {
-                        this.errorLog(`Secondary Curtain: ${device.deviceName}, DeviceID: ${device.deviceId}`);
+                        this.errorLog(`Secondary Curtain: ${device.deviceName}, deviceId: ${device.deviceId}`);
                     }
                 }
             }
@@ -1418,23 +1375,24 @@ export class SwitchBotPlatform {
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = device.deviceType === 'Curtain3' ? SwitchBotModel.Curtain3 : SwitchBotModel.Curtain;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Curtain(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createPlug(device) {
@@ -1446,52 +1404,50 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = device.deviceType === 'Plug Mini (US)' ? SwitchBotModel.PlugMiniUS : device.deviceType === 'Plug Mini (JP)'
+                    ? SwitchBotModel.PlugMiniJP : SwitchBotModel.Plug;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Plug(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = device.deviceType === 'Plug Mini (US)' ? SwitchBotModel.PlugMiniUS : device.deviceType === 'Plug Mini (JP)'
+                ? SwitchBotModel.PlugMiniJP : SwitchBotModel.Plug;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Plug(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createLock(device) {
@@ -1503,52 +1459,48 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = device.deviceType === 'Smart Lock Pro' ? SwitchBotModel.LockPro : SwitchBotModel.Lock;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Lock(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = device.deviceType === 'Smart Lock Pro' ? SwitchBotModel.LockPro : SwitchBotModel.Lock;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Lock(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createColorBulb(device) {
@@ -1560,52 +1512,48 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = SwitchBotModel.ColorBulb;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new ColorBulb(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = SwitchBotModel.ColorBulb;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new ColorBulb(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createCeilingLight(device) {
@@ -1617,52 +1565,48 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = device.deviceType === 'Ceiling Light Pro' ? SwitchBotModel.CeilingLightPro : SwitchBotModel.CeilingLight;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new CeilingLight(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = device.deviceType === 'Ceiling Light Pro' ? SwitchBotModel.CeilingLightPro : SwitchBotModel.CeilingLight;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new CeilingLight(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createStripLight(device) {
@@ -1674,52 +1618,48 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = SwitchBotModel.StripLight;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new StripLight(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = SwitchBotModel.StripLight;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new StripLight(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createFan(device) {
@@ -1731,52 +1671,48 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = SwitchBotModel.BatteryCirculatorFan;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Fan(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = SwitchBotModel.BatteryCirculatorFan;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Fan(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createRobotVacuumCleaner(device) {
@@ -1788,52 +1724,56 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (await this.registerDevice(device)) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.deviceType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
-                existingAccessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
+                existingAccessory.context.deviceType = device.deviceType;
+                existingAccessory.context.model = device.deviceType === 'Robot Vacuum Cleaner S1' ? SwitchBotModel.RobotVacuumCleanerS1
+                    : device.deviceType === 'Robot Vacuum Cleaner S1 Plus' ? SwitchBotModel.RobotVacuumCleanerS1Plus
+                        : device.deviceType === 'Robot Vacuum Cleaner S10' ? SwitchBotModel.RobotVacuumCleanerS10
+                            : device.deviceType === 'WoSweeper' ? SwitchBotModel.WoSweeper : device.deviceType === 'WoSweeperMini' ? SwitchBotModel.WoSweeperMini
+                                : SwitchBotModel.Unknown;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
                 existingAccessory.context.connectionType = await this.connectionType(device);
+                existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new RobotVacuumCleaner(this, existingAccessory, device);
-                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (await this.registerDevice(device)) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.deviceType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
-            accessory.context.deviceType = `SwitchBot: ${device.deviceType}`;
+            accessory.context.deviceId = device.deviceId;
+            accessory.context.deviceType = device.deviceType;
+            accessory.context.model = device.deviceType === 'Robot Vacuum Cleaner S1' ? SwitchBotModel.RobotVacuumCleanerS1
+                : device.deviceType === 'Robot Vacuum Cleaner S1 Plus' ? SwitchBotModel.RobotVacuumCleanerS1Plus
+                    : device.deviceType === 'Robot Vacuum Cleaner S10' ? SwitchBotModel.RobotVacuumCleanerS10
+                        : device.deviceType === 'WoSweeper' ? SwitchBotModel.WoSweeper : device.deviceType === 'WoSweeperMini' ? SwitchBotModel.WoSweeperMini
+                            : SwitchBotModel.Unknown;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = await this.connectionType(device);
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new RobotVacuumCleaner(this, accessory, device);
-            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createTV(device) {
@@ -1843,44 +1783,42 @@ export class SwitchBotPlatform {
         const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
         if (!device.hide_device && existingAccessory) {
             // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-            existingAccessory.context.model = device.remoteType;
-            existingAccessory.context.deviceID = device.deviceId;
-            existingAccessory.displayName = device.configDeviceName || device.deviceName;
+            existingAccessory.context.device = device;
+            existingAccessory.context.deviceId = device.deviceId;
             existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-            this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+            existingAccessory.context.model = device.remoteType;
+            existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
+            await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
             existingAccessory.context.connectionType = device.connectionType;
             this.api.updatePlatformAccessories([existingAccessory]);
             // create the accessory handler for the restored accessory
             // this is imported from `platformAccessory.ts`
             new TV(this, existingAccessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
         }
         else if (!device.hide_device && device.hubDeviceId) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.remoteType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
+            accessory.context.deviceId = device.deviceId;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
+            accessory.context.model = device.remoteType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = device.connectionType;
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new TV(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createIRFan(device) {
@@ -1892,52 +1830,47 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.remoteType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.model = device.remoteType;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new IRFan(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (!device.hide_device && device.hubDeviceId) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.remoteType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
+            accessory.context.deviceId = device.deviceId;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
+            accessory.context.model = device.remoteType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = device.connectionType;
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new IRFan(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createLight(device) {
@@ -1949,52 +1882,47 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.remoteType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.model = device.remoteType;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Light(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (!device.hide_device && device.hubDeviceId) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.remoteType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
+            accessory.context.deviceId = device.deviceId;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
+            accessory.context.model = device.remoteType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = device.connectionType;
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Light(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createAirConditioner(device) {
@@ -2006,52 +1934,47 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.remoteType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.model = device.remoteType;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new AirConditioner(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (!device.hide_device && device.hubDeviceId) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.remoteType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
+            accessory.context.deviceId = device.deviceId;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
+            accessory.context.model = device.remoteType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = device.connectionType;
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new AirConditioner(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createAirPurifier(device) {
@@ -2063,52 +1986,47 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.remoteType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.model = device.remoteType;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new AirPurifier(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (!device.hide_device && device.hubDeviceId) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.remoteType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
+            accessory.context.deviceId = device.deviceId;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
+            accessory.context.model = device.remoteType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = device.connectionType;
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new AirPurifier(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createWaterHeater(device) {
@@ -2120,52 +2038,47 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.remoteType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.model = device.remoteType;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new WaterHeater(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (!device.hide_device && device.hubDeviceId) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.remoteType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
+            accessory.context.deviceId = device.deviceId;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
+            accessory.context.model = device.remoteType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = device.connectionType;
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new WaterHeater(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createVacuumCleaner(device) {
@@ -2177,52 +2090,47 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.remoteType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.model = device.remoteType;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new VacuumCleaner(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (!device.hide_device && device.hubDeviceId) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.remoteType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
+            accessory.context.deviceId = device.deviceId;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
+            accessory.context.model = device.remoteType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = device.connectionType;
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new VacuumCleaner(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createCamera(device) {
@@ -2234,52 +2142,47 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.remoteType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.model = device.remoteType;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Camera(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (!device.hide_device && device.hubDeviceId) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.remoteType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
+            accessory.context.deviceId = device.deviceId;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
+            accessory.context.model = device.remoteType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = device.connectionType;
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Camera(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createOthers(device) {
@@ -2291,52 +2194,47 @@ export class SwitchBotPlatform {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
                 // if you need to update the accessory.context then you should run `api.updatePlatformAccessories`. eg.:
-                existingAccessory.context.model = device.remoteType;
-                existingAccessory.context.deviceID = device.deviceId;
-                existingAccessory.displayName = device.configDeviceName || device.deviceName;
-                if (device.firmware) {
-                    existingAccessory.context.version = device.firmware;
-                }
+                existingAccessory.context.device = device;
+                existingAccessory.context.deviceId = device.deviceId;
                 existingAccessory.context.deviceType = `IR: ${device.remoteType}`;
-                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} DeviceID: ${device.deviceId}`);
+                existingAccessory.context.model = device.remoteType;
+                existingAccessory.displayName = device.configDeviceName ?? device.deviceName;
+                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Others(this, existingAccessory, device);
-                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
             }
         }
         else if (!device.hide_device && device.hubDeviceId) {
-            // the accessory does not yet exist, so we need to create it
-            if (!device.external) {
-                this.infoLog(`Adding new accessory: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
-            }
             // create a new accessory
             const accessory = new this.api.platformAccessory(device.deviceName, uuid);
             // store a copy of the device object in the `accessory.context`
             // the `context` property can be used to store any data about the accessory you may need
             accessory.context.device = device;
-            accessory.context.model = device.remoteType;
-            accessory.context.deviceID = device.deviceId;
-            if (device.firmware) {
-                accessory.context.version = device.firmware;
-            }
+            accessory.context.deviceId = device.deviceId;
             accessory.context.deviceType = `IR: ${device.remoteType}`;
+            accessory.context.model = device.remoteType;
+            accessory.displayName = device.configDeviceName ?? device.deviceName;
             accessory.context.connectionType = device.connectionType;
+            accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
+            const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
+            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Others(this, accessory, device);
-            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatformIR(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} DeviceID: ${device.deviceId}`);
+            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async registerCurtains(device) {
@@ -2349,12 +2247,13 @@ export class SwitchBotPlatform {
         }*/
         let registerWindowCovering;
         if (isCurtainDevice(device)) {
-            this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds}, master: `
-                + `${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group}, connectionType: ${device.connectionType}`);
+            await this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds},`
+                + ` master: ${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group},`
+                + ` connectionType: ${device.connectionType}`);
             registerWindowCovering = await this.registerWindowCovering(device);
         }
         else if (isBlindTiltDevice(device)) {
-            this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, blindTiltDevicesIds: ${device.blindTiltDevicesIds},`
+            await this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, blindTiltDevicesIds: ${device.blindTiltDevicesIds},`
                 + ` master: ${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group},`
                 + ` connectionType: ${device.connectionType}`);
             registerWindowCovering = await this.registerWindowCovering(device);
@@ -2365,42 +2264,42 @@ export class SwitchBotPlatform {
         return registerWindowCovering;
     }
     async registerWindowCovering(device) {
-        this.debugLog(device.master);
+        await this.debugLog(`master: ${device.master}`);
         let registerCurtain;
         if (device.master && device.group) {
             // OpenAPI: Master Curtains/Blind Tilt in Group
             registerCurtain = true;
-            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, device.group: ${device.group}`
-                + ` connectionType; ${device.connectionType}`);
-            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master},`
+                + ` device.group: ${device.group} connectionType; ${device.connectionType}`);
+            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else if (!device.master && device.curtain?.disable_group) {
             //!device.group && device.connectionType === 'BLE'
             // OpenAPI: Non-Master Curtains/Blind Tilts that has Disable Grouping Checked
             registerCurtain = true;
-            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, disable_group: `
+            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, disable_group: `
                 + `${device.curtain?.disable_group}, connectionType; ${device.connectionType}`);
-            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else if (device.master && !device.group) {
             // OpenAPI: Master Curtains/Blind Tilts not in Group
             registerCurtain = true;
-            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, device.group: ${device.group}`
-                + ` connectionType; ${device.connectionType}`);
-            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master},`
+                + ` device.group: ${device.group} connectionType; ${device.connectionType}`);
+            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else if (device.connectionType === 'BLE') {
             // BLE: Curtains/Blind Tilt
             registerCurtain = true;
-            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] connectionType: ${device.connectionType}, `
+            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] connectionType: ${device.connectionType}, `
                 + ` group: ${device.group}`);
-            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else {
             registerCurtain = false;
-            this.debugErrorLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] disable_group: ${device.curtain?.disable_group},`
+            await this.debugErrorLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] disable_group: ${device.curtain?.disable_group},`
                 + ` device.master: ${device.master}, device.group: ${device.group}`);
-            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}, device.connectionType: ${device.connectionType}`);
+            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}, device.connectionType: ${device.connectionType}`);
         }
         return registerCurtain;
     }
@@ -2423,17 +2322,17 @@ export class SwitchBotPlatform {
                 case 'Curtain3':
                 case 'Blind Tilt':
                     registerDevice = await this.registerCurtains(device);
-                    this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                     break;
                 default:
                     registerDevice = true;
-                    this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
             }
             if (registerDevice === true) {
-                this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+                await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
             }
             else {
-                this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+                await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
             }
         }
         else if (!device.hide_device && device.deviceId && device.configDeviceType && device.configDeviceName && device.connectionType === 'BLE') {
@@ -2442,17 +2341,17 @@ export class SwitchBotPlatform {
                 case 'Curtain3':
                 case 'Blind Tilt':
                     registerDevice = await this.registerCurtains(device);
-                    this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                     break;
                 default:
                     registerDevice = true;
-                    this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
             }
             if (registerDevice === true) {
-                this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+                await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
             }
             else {
-                this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+                await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
             }
         }
         else if (!device.hide_device && device.connectionType === 'OpenAPI') {
@@ -2461,17 +2360,17 @@ export class SwitchBotPlatform {
                 case 'Curtain3':
                 case 'Blind Tilt':
                     registerDevice = await this.registerCurtains(device);
-                    this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                     break;
                 default:
                     registerDevice = true;
-                    this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
             }
             if (registerDevice === true) {
-                this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+                await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
             }
             else {
-                this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+                await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
             }
         }
         else if (!device.hide_device && device.connectionType === 'Disabled') {
@@ -2480,25 +2379,25 @@ export class SwitchBotPlatform {
                 case 'Curtain3':
                 case 'Blind Tilt':
                     registerDevice = await this.registerCurtains(device);
-                    this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                     break;
                 default:
                     registerDevice = true;
-                    this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
             }
-            this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will continue to display in HomeKit`);
+            await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will continue to display in HomeKit`);
         }
         else if (!device.connectionType && !device.hide_device) {
             registerDevice = false;
-            this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
+            await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
         }
         else if (device.hide_device) {
             registerDevice = false;
-            this.debugErrorLog(`Device: ${device.deviceName} hide_device: ${device.hide_device}, will not display in HomeKit`);
+            await this.debugErrorLog(`Device: ${device.deviceName} hide_device: ${device.hide_device}, will not display in HomeKit`);
         }
         else {
             registerDevice = false;
-            this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, hide_device: `
+            await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, hide_device: `
                 + `${device.hide_device},  will not display in HomeKit`);
         }
         return registerDevice;
@@ -2510,21 +2409,21 @@ export class SwitchBotPlatform {
          * publish your TV as an external accessory.
          */
         if (device.external) {
-            this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
+            await this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
             this.externalAccessory(accessory);
         }
         else {
-            this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
+            await this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
             this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
         }
     }
     async externalOrPlatform(device, accessory) {
         if (device.external) {
-            this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
-            this.externalAccessory(accessory);
+            await this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
+            await this.externalAccessory(accessory);
         }
         else {
-            this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
+            await this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
             this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
         }
     }