@switchbot/homebridge-switchbot 3.7.1-beta.9 → 3.8.0

package/dist/platform.js

@@ -1,59 +1,58 @@
-/* Copyright(C) 2017-2024, donavanbecker (https://github.com/donavanbecker). All rights reserved.
- *
- * platform.ts: @switchbot/homebridge-switchbot platform class.
- */
-import { Hub } from './device/hub.js';
+import { Buffer } from 'node:buffer';
+import crypto, { randomUUID } from 'node:crypto';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import process from 'node:process';
+import asyncmqtt from 'async-mqtt';
+import fakegato from 'fakegato-history';
+import { EveHomeKitTypes } from 'homebridge-lib/EveHomeKitTypes';
+/*
+* For Testing Locally:
+* import { SwitchBotModel } from '/Users/Shared/GitHub/OpenWonderLabs/node-switchbot/dist/index.js';
+*/
+import { SwitchBot, SwitchBotModel } from 'node-switchbot';
+import { queueScheduler } from 'rxjs';
+import { request } from 'undici';
+import { BlindTilt } from './device/blindtilt.js';
 import { Bot } from './device/bot.js';
-import { Plug } from './device/plug.js';
-import { Lock } from './device/lock.js';
-import { Meter } from './device/meter.js';
-import { Motion } from './device/motion.js';
+import { CeilingLight } from './device/ceilinglight.js';
+import { ColorBulb } from './device/colorbulb.js';
 import { Contact } from './device/contact.js';
 import { Curtain } from './device/curtain.js';
+import { Fan } from './device/fan.js';
+import { Hub } from './device/hub.js';
+import { Humidifier } from './device/humidifier.js';
 import { IOSensor } from './device/iosensor.js';
-import { MeterPlus } from './device/meterplus.js';
-import { ColorBulb } from './device/colorbulb.js';
 import { StripLight } from './device/lightstrip.js';
-import { Humidifier } from './device/humidifier.js';
-import { CeilingLight } from './device/ceilinglight.js';
-import { WaterDetector } from './device/waterdetector.js';
+import { Lock } from './device/lock.js';
+import { Meter } from './device/meter.js';
+import { MeterPlus } from './device/meterplus.js';
+import { Motion } from './device/motion.js';
+import { Plug } from './device/plug.js';
 import { RobotVacuumCleaner } from './device/robotvacuumcleaner.js';
-import { Fan } from './device/fan.js';
-import { TV } from './irdevice/tv.js';
+import { WaterDetector } from './device/waterdetector.js';
+import { AirConditioner } from './irdevice/airconditioner.js';
+import { AirPurifier } from './irdevice/airpurifier.js';
+import { Camera } from './irdevice/camera.js';
 import { IRFan } from './irdevice/fan.js';
 import { Light } from './irdevice/light.js';
 import { Others } from './irdevice/other.js';
-import { Camera } from './irdevice/camera.js';
-import { BlindTilt } from './device/blindtilt.js';
-import { AirPurifier } from './irdevice/airpurifier.js';
-import { WaterHeater } from './irdevice/waterheater.js';
+import { TV } from './irdevice/tv.js';
 import { VacuumCleaner } from './irdevice/vacuumcleaner.js';
-import { AirConditioner } from './irdevice/airconditioner.js';
-import { Buffer } from 'buffer';
-import { request } from 'undici';
-import asyncmqtt from 'async-mqtt';
-import { createServer } from 'http';
-import { queueScheduler } from 'rxjs';
-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 { WaterHeater } from './irdevice/waterheater.js';
+import { deleteWebhook, Devices, PLATFORM_NAME, PLUGIN_NAME, queryWebhook, setupWebhook, updateWebhook } from './settings.js';
 import { isBlindTiltDevice, isCurtainDevice, sleep } from './utils.js';
-/*
-* For Testing Locally:
-* import { SwitchBotModel } from '/Users/Shared/GitHub/OpenWonderLabs/node-switchbot/dist/index.js';
-*/
-import { SwitchBotModel } from 'node-switchbot';
 /**
  * HomebridgePlatform
  * This class is the main constructor for your plugin, this is where you should
  * parse the user config and discover/register accessories with Homebridge.
  */
 export class SwitchBotPlatform {
-    accessories;
+    // Platform properties
+    accessories = [];
     api;
     log;
+    // Configuration properties
     version;
     Logging;
     debugMode;
@@ -62,15 +61,16 @@ export class SwitchBotPlatform {
     platformConfig;
     platformLogging;
     config;
+    // MQTT and Webhook properties
     mqttClient = null;
     webhookEventListener = null;
+    // External APIs
     eve;
     fakegatoAPI;
+    // Event Handlers
     webhookEventHandler = {};
     bleEventHandler = {};
     constructor(log, config, api) {
-        // initialize
-        this.accessories = [];
         this.api = api;
         this.log = log;
         // only load if configured
@@ -108,21 +108,21 @@ export class SwitchBotPlatform {
         // in order to ensure they weren't added to homebridge already. This event can also be used
         // to start discovery of new accessories.
         this.api.on('didFinishLaunching', async () => {
-            this.debugLog('Executed didFinishLaunching callback');
+            await this.debugLog('Executed didFinishLaunching callback');
             // run the method to discover / register your devices as accessories
             try {
                 if (this.config.credentials?.openToken && !this.config.credentials.token) {
                     await this.updateToken();
                 }
                 else if (this.config.credentials?.token && !this.config.credentials?.secret) {
-                    this.errorLog('"secret" config is not populated, you must populate then please restart Homebridge.');
+                    await this.errorLog('"secret" config is not populated, you must populate then please restart Homebridge.');
                 }
                 else {
-                    this.discoverDevices();
+                    await this.discoverDevices();
                 }
             }
             catch (e) {
-                this.errorLog(`Failed to Discover, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
+                await this.errorLog(`Failed to Discover, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
                 await this.debugErrorLog(`Failed to Discover, Error: ${e}`);
             }
         });
@@ -160,7 +160,7 @@ export class SwitchBotPlatform {
                     this.mqttClient.subscribe('homebridge-switchbot/webhook/+');
                     this.mqttClient.on('message', async (topic, message) => {
                         try {
-                            await await this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
+                            await this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
                             const context = JSON.parse(message.toString());
                             this.webhookEventHandler[context.deviceMac]?.(context);
                         }
@@ -177,7 +177,7 @@ export class SwitchBotPlatform {
         }
     }
     async setupwebhook() {
-        //webhook configuration
+        // webhook configuration
         if (this.config.options?.webhookURL) {
             const url = this.config.options?.webhookURL;
             try {
@@ -192,17 +192,14 @@ export class SwitchBotPlatform {
                                     const body = JSON.parse(data);
                                     await this.debugLog(`Received Webhook: ${JSON.stringify(body)}`);
                                     if (this.config.options?.mqttURL) {
-                                        const mac = body.context.deviceMac
-                                            ?.toLowerCase()
-                                            .match(/[\s\S]{1,2}/g)
-                                            ?.join(':');
+                                        const mac = body.context.deviceMac?.toLowerCase().match(/[\s\S]{1,2}/g)?.join(':');
                                         const options = this.config.options?.mqttPubOptions || {};
                                         this.mqttClient?.publish(`homebridge-switchbot/webhook/${mac}`, `${JSON.stringify(body.context)}`, options);
                                     }
                                     this.webhookEventHandler[body.context.deviceMac]?.(body.context);
                                 }
                                 catch (e) {
-                                    this.errorLog(`Failed to handle webhook event. Error:${e}`);
+                                    await this.errorLog(`Failed to handle webhook event. Error:${e}`);
                                 }
                             });
                             response.writeHead(200, { 'Content-Type': 'text/plain' });
@@ -216,10 +213,10 @@ export class SwitchBotPlatform {
                     catch (e) {
                         this.errorLog(`Failed to handle webhook event. Error:${e}`);
                     }
-                }).listen(port ? port : 80);
+                }).listen(port || 80);
             }
             catch (e) {
-                this.errorLog(`Failed to create webhook listener. Error:${e.message}`);
+                await this.errorLog(`Failed to create webhook listener. Error:${e.message}`);
                 return;
             }
             try {
@@ -227,64 +224,61 @@ export class SwitchBotPlatform {
                     method: 'POST',
                     headers: this.generateHeaders(),
                     body: JSON.stringify({
-                        'action': 'setupWebhook',
-                        'url': url,
-                        'deviceList': 'ALL',
+                        action: 'setupWebhook',
+                        url,
+                        deviceList: 'ALL',
                     }),
                 });
                 const response = await body.json();
-                await this.debugLog(`setupWebhook: url:${url}`);
-                await this.debugLog(`setupWebhook: body:${JSON.stringify(response)}`);
-                await this.debugLog(`setupWebhook: statusCode:${statusCode}`);
+                await this.debugLog(`setupWebhook: url:${url}, body:${JSON.stringify(response)}, 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}`);
+                    await this.errorLog(`Failed to configure webhook. Existing webhook well be overridden. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                 }
             }
             catch (e) {
-                this.errorLog(`Failed to configure webhook. Error: ${e.message}`);
+                await this.errorLog(`Failed to configure webhook. Error: ${e.message}`);
             }
             try {
                 const { body, statusCode } = await request(updateWebhook, {
-                    method: 'POST', headers: this.generateHeaders(), body: JSON.stringify({
-                        'action': 'updateWebhook',
-                        'config': {
-                            'url': url,
-                            'enable': true,
+                    method: 'POST',
+                    headers: this.generateHeaders(),
+                    body: JSON.stringify({
+                        action: 'updateWebhook',
+                        config: {
+                            url,
+                            enable: true,
                         },
                     }),
                 });
                 const response = await body.json();
-                await this.debugLog(`updateWebhook: url:${url}`);
-                await this.debugLog(`updateWebhook: body:${JSON.stringify(response)}`);
-                await this.debugLog(`updateWebhook: statusCode:${statusCode}`);
+                await this.debugLog(`updateWebhook: url:${url}, body:${JSON.stringify(response)}, statusCode:${statusCode}`);
                 if (statusCode !== 200 || response?.statusCode !== 100) {
-                    this.errorLog(`Failed to update webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
+                    await this.errorLog(`Failed to update webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                 }
             }
             catch (e) {
-                this.errorLog(`Failed to update webhook. Error:${e.message}`);
+                await this.errorLog(`Failed to update webhook. Error:${e.message}`);
             }
             try {
                 const { body, statusCode } = await request(queryWebhook, {
                     method: 'POST',
                     headers: this.generateHeaders(),
                     body: JSON.stringify({
-                        'action': 'queryUrl',
+                        action: 'queryUrl',
                     }),
                 });
                 const response = await body.json();
                 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}`);
+                    await this.errorLog(`Failed to query webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                 }
                 else {
-                    this.infoLog(`Listening webhook on ${response?.body?.urls[0]}`);
+                    await this.infoLog(`Listening webhook on ${response?.body?.urls[0]}`);
                 }
             }
             catch (e) {
-                this.errorLog(`Failed to query webhook. Error:${e}`);
+                await this.errorLog(`Failed to query webhook. Error:${e}`);
             }
             this.api.on('shutdown', async () => {
                 try {
@@ -292,21 +286,21 @@ export class SwitchBotPlatform {
                         method: 'POST',
                         headers: this.generateHeaders(),
                         body: JSON.stringify({
-                            'action': 'deleteWebhook',
-                            'url': url,
+                            action: 'deleteWebhook',
+                            url,
                         }),
                     });
                     const response = await body.json();
                     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}`);
+                        await this.errorLog(`Failed to delete webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                     }
                     else {
-                        this.infoLog('Unregistered webhook to close listening.');
+                        await this.infoLog('Unregistered webhook to close listening.');
                     }
                 }
                 catch (e) {
-                    this.errorLog(`Failed to delete webhook. Error:${e.message}`);
+                    await this.errorLog(`Failed to delete webhook. Error:${e.message}`);
                 }
             });
         }
@@ -314,7 +308,6 @@ export class SwitchBotPlatform {
     async setupBlE() {
         if (this.config.options?.BLE) {
             await this.debugLog('setupBLE');
-            const SwitchBot = (await import('node-switchbot')).SwitchBot;
             const switchbot = new SwitchBot();
             if (switchbot === undefined) {
                 await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
@@ -338,10 +331,10 @@ export class SwitchBotPlatform {
                 this.api.on('shutdown', async () => {
                     try {
                         switchbot.stopScan();
-                        this.infoLog('Stopped BLE scanning to close listening.');
+                        await this.infoLog('Stopped BLE scanning to close listening.');
                     }
                     catch (e) {
-                        this.errorLog(`Failed to stop Platform BLE scanning. Error:${e.message}`);
+                        await this.errorLog(`Failed to stop Platform BLE scanning. Error:${e.message}`);
                     }
                 });
             }
@@ -355,7 +348,8 @@ export class SwitchBotPlatform {
      * It should be used to setup event handlers for characteristics and update respective values.
      */
     async configureAccessory(accessory) {
-        await this.debugLog(`Loading accessory from cache: ${accessory.displayName}`);
+        const { displayName } = accessory;
+        await this.debugLog(`Loading accessory from cache: ${displayName}`);
         // add the restored accessory to the accessories cache so we can track if it has already been registered
         this.accessories.push(accessory);
     }
@@ -363,18 +357,18 @@ export class SwitchBotPlatform {
      * Verify the config passed to the plugin is valid
      */
     async verifyConfig() {
-        this.debugLog('Verifying Config');
+        await this.debugLog('Verifying Config');
         this.config = this.config || {};
         this.config.options = this.config.options || {};
         const platformConfig = {};
         if (this.config.options.logging) {
-            platformConfig['logging'] = this.config.options.logging;
+            platformConfig.logging = this.config.options.logging;
         }
         if (this.config.options.logging && this.config.options.refreshRate) {
-            platformConfig['refreshRate'] = this.config.options.refreshRate;
+            platformConfig.refreshRate = this.config.options.refreshRate;
         }
         if (this.config.options.logging && this.config.options.pushRate) {
-            platformConfig['pushRate'] = this.config.options.pushRate;
+            platformConfig.pushRate = this.config.options.pushRate;
         }
         if (Object.entries(platformConfig).length !== 0) {
             await this.debugWarnLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
@@ -398,10 +392,10 @@ export class SwitchBotPlatform {
                 for (const irDeviceConfig of this.config.options.irdevices) {
                     if (!irDeviceConfig.hide_device) {
                         if (!irDeviceConfig.deviceId) {
-                            this.errorLog('The devices config section is missing the *Device ID* in the config. Please check your config.');
+                            await this.errorLog('The devices config section is missing the *Device ID* in the config. Please check your config.');
                         }
                         if (!irDeviceConfig.deviceId && !irDeviceConfig.configRemoteType) {
-                            this.errorLog('The devices config section is missing the *Device Type* in the config. Please check your config.');
+                            await this.errorLog('The devices config section is missing the *Device Type* in the config. Please check your config.');
                         }
                     }
                 }
@@ -413,16 +407,16 @@ export class SwitchBotPlatform {
         if (!this.config.options.refreshRate) {
             // default 120 seconds (2 minutes)
             this.config.options.refreshRate = 120;
-            this.debugWarnLog('Using Default Refresh Rate (2 minutes).');
+            await this.debugWarnLog('Using Default Refresh Rate (2 minutes).');
         }
         if (!this.config.options.pushRate) {
             // default 100 milliseconds
             this.config.options.pushRate = 0.1;
-            this.debugWarnLog('Using Default Push Rate.');
+            await this.debugWarnLog('Using Default Push Rate.');
         }
         if (!this.config.options.maxRetries) {
             this.config.options.maxRetries = 5;
-            this.debugWarnLog('Using Default Max Retries.');
+            await this.debugWarnLog('Using Default Max Retries.');
         }
         else {
             this.maxRetries = this.config.options.maxRetries;
@@ -430,23 +424,23 @@ export class SwitchBotPlatform {
         if (!this.config.options.delayBetweenRetries) {
             // default 3 seconds
             this.config.options.delayBetweenRetries = 3000;
-            this.debugWarnLog('Using Default Delay Between Retries.');
+            await this.debugWarnLog('Using Default Delay Between Retries.');
         }
         else {
             this.delayBetweenRetries = this.config.options.delayBetweenRetries * 1000;
         }
         if (!this.config.credentials && !this.config.options) {
-            this.debugWarnLog('Missing Credentials');
+            await this.debugWarnLog('Missing Credentials');
         }
         else if (this.config.credentials && !this.config.credentials.notice) {
             if (!this.config.credentials?.token) {
-                this.debugErrorLog('Missing token');
-                this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
+                await this.debugErrorLog('Missing token');
+                await this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
             }
             if (this.config.credentials?.token) {
                 if (!this.config.credentials?.secret) {
-                    this.debugErrorLog('Missing secret');
-                    this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
+                    await this.debugErrorLog('Missing secret');
+                    await this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
                 }
             }
         }
@@ -454,7 +448,6 @@ export class SwitchBotPlatform {
     /**
      * The openToken was old config.
      * This method saves the openToken as the token in the config.json file
-     * @param this.config.credentials.openToken
      */
     async updateToken() {
         try {
@@ -466,7 +459,7 @@ export class SwitchBotPlatform {
             const currentConfig = JSON.parse(readFileSync(this.api.user.configPath(), 'utf8'));
             // check the platforms section is an array before we do array things on it
             if (!Array.isArray(currentConfig.platforms)) {
-                throw new Error('Cannot find platforms array in config');
+                throw new TypeError('Cannot find platforms array in config');
             }
             // find this plugins current config
             const pluginConfig = currentConfig.platforms.find((x) => x.platform === PLATFORM_NAME);
@@ -475,17 +468,15 @@ export class SwitchBotPlatform {
             }
             // check the .credentials is an object before doing object things with it
             if (typeof pluginConfig.credentials !== 'object') {
-                throw new Error('pluginConfig.credentials is not an object');
+                throw new TypeError('pluginConfig.credentials is not an object');
             }
             // Move openToken to token
             if (!this.config.credentials.secret) {
-                this.warnLog('This plugin has been updated to use OpenAPI v1.1, config is set with openToken,'
-                    + ' "openToken" cconfig has been moved to the "token" config');
+                await this.warnLog('This plugin has been updated to use OpenAPI v1.1, config is set with openToken, "openToken" cconfig has been moved to the "token" config');
                 this.errorLog('"secret" config is not populated, you must populate then please restart Homebridge.');
             }
             else {
-                this.warnLog('This plugin has been updated to use OpenAPI v1.1, config is set with openToken, '
-                    + '"openToken" config has been moved to the "token" config, please restart Homebridge.');
+                await this.warnLog('This plugin has been updated to use OpenAPI v1.1, config is set with openToken, "openToken" config has been moved to the "token" config, please restart Homebridge.');
             }
             // set the refresh token
             pluginConfig.credentials.token = this.config.credentials?.openToken;
@@ -495,10 +486,10 @@ export class SwitchBotPlatform {
             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();
+            await this.verifyConfig();
         }
         catch (e) {
-            this.errorLog(`Update Token: ${e}`);
+            await this.errorLog(`Update Token: ${e}`);
         }
     }
     generateHeaders = () => {
@@ -511,340 +502,228 @@ export class SwitchBotPlatform {
             .digest();
         const sign = signTerm.toString('base64');
         return {
-            Authorization: this.config.credentials?.token,
-            sign: sign,
-            nonce: nonce,
-            t: t,
+            'Authorization': this.config.credentials?.token,
+            'sign': sign,
+            'nonce': nonce,
+            't': t,
             'Content-Type': 'application/json',
         };
     };
-    /**
-     * this method discovers devices
-     *
-        const t = `${Date.now()}`;
-        const nonce = 'requestID';
-        const data = this.config.credentials?.token + t + nonce;
-        const signTerm = crypto.createHmac('sha256', this.config.credentials?.secret).update(Buffer.from(data, 'utf-8')).digest();
-        const sign = signTerm.toString('base64');
-     */
     async discoverDevices() {
-        if (this.config.credentials?.token) {
-            let retryCount = 0;
-            const maxRetries = this.maxRetries; // Maximum number of retries
-            const delayBetweenRetries = this.delayBetweenRetries; // Delay between retries in milliseconds
-            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(),
-                    });
-                    await this.debugWarnLog(`statusCode: ${statusCode}`);
-                    const devicesAPI = await body.json();
-                    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)) {
-                        await this.debugErrorLog(`statusCode: ${statusCode} & devicesAPI StatusCode: ${devicesAPI.statusCode}`);
-                        // SwitchBot Devices
-                        const deviceLists = devicesAPI.body.deviceList;
-                        await this.debugWarnLog(`DeviceLists: ${JSON.stringify(deviceLists)}`);
-                        await this.debugWarnLog(`DeviceLists Length: ${deviceLists.length}`);
-                        if (!this.config.options?.devices) {
-                            await this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
-                            if (deviceLists.length === 0) {
-                                await this.debugLog(`SwitchBot API Has No Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
-                            }
-                            else {
-                                const devices = deviceLists.map((v) => v);
-                                for (const device of devices) {
-                                    if (device.deviceType) {
-                                        if (device.configDeviceName) {
-                                            device.deviceName = device.configDeviceName;
-                                        }
-                                        this.createDevice(device);
-                                    }
-                                }
-                            }
-                        }
-                        else if (this.config.credentials?.token && this.config.options.devices) {
-                            await this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
-                            if (deviceLists.length === 0) {
-                                await this.debugLog(`SwitchBot API Has No Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
-                            }
-                            else {
-                                const deviceConfigs = this.config.options?.devices;
-                                const mergeBydeviceId = (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 = mergeBydeviceId(deviceLists, deviceConfigs);
-                                await this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
-                                for (const device of devices) {
-                                    if (!device.deviceType) {
-                                        device.deviceType = device.configDeviceType;
-                                        this.errorLog(`API has displaying no deviceType: ${device.deviceType}, So using configDeviceType: ${device.configDeviceType}`);
-                                    }
-                                    if (device.deviceType) {
-                                        if (device.configDeviceName) {
-                                            device.deviceName = device.configDeviceName;
-                                        }
-                                        this.createDevice(device);
-                                    }
-                                }
-                            }
-                        }
-                        else {
-                            this.errorLog('SwitchBot Token Supplied, Issue with Auth.');
-                        }
-                        if (devicesAPI.body.deviceList.length !== 0) {
-                            this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
-                        }
-                        else {
-                            await this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
-                        }
-                        // IR Devices
-                        const irDeviceLists = devicesAPI.body.infraredRemoteList;
-                        if (!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) {
-                                    this.createIRDevice(device);
-                                }
-                            }
-                        }
-                        else {
-                            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);
-                            await this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
-                            for (const device of devices) {
-                                this.createIRDevice(device);
-                            }
-                        }
-                        if (devicesAPI.body.infraredRemoteList.length !== 0) {
-                            this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
-                        }
-                        else {
-                            await this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
-                        }
-                        break;
-                    }
-                    else {
-                        this.statusCode(statusCode);
-                        this.statusCode(devicesAPI.statusCode);
-                        if (statusCode === 500) {
-                            retryCount++;
-                            this.infoLog(`statusCode: ${statusCode} Attempt ${retryCount} of ${maxRetries}`);
-                            await sleep(delayBetweenRetries);
-                        }
-                    }
+        if (!this.config.credentials?.token) {
+            return this.handleManualConfig();
+        }
+        let retryCount = 0;
+        const maxRetries = this.maxRetries;
+        const delayBetweenRetries = this.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() });
+                await this.debugWarnLog(`statusCode: ${statusCode}`);
+                const devicesAPI = await body.json();
+                await this.debugWarnLog(`devicesAPI: ${JSON.stringify(devicesAPI)}`);
+                if (this.isSuccessfulResponse(statusCode, devicesAPI.statusCode)) {
+                    await this.handleDevices(devicesAPI.body.deviceList);
+                    await this.handleIRDevices(devicesAPI.body.infraredRemoteList);
+                    break;
                 }
-                catch (e) {
+                else {
+                    await this.handleErrorResponse(statusCode, devicesAPI.statusCode, retryCount, maxRetries, delayBetweenRetries);
                     retryCount++;
-                    this.debugErrorLog(`Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
-                    await this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
                 }
             }
+            catch (e) {
+                retryCount++;
+                await this.debugErrorLog(`Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`);
+                await this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
+            }
         }
-        else if (!this.config.credentials?.token && this.config.options?.devices) {
+    }
+    async handleManualConfig() {
+        if (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);
+            const devices = this.config.options.devices.map((v) => v);
             for (const device of devices) {
                 device.deviceType = device.configDeviceType;
                 device.deviceName = device.configDeviceName;
                 if (device.deviceType) {
-                    this.createDevice(device);
+                    await this.createDevice(device);
                 }
             }
         }
         else {
-            this.errorLog('Neither SwitchBot Token or Device Config are not set.');
+            await this.errorLog('Neither SwitchBot Token or Device Config are set.');
+        }
+    }
+    isSuccessfulResponse(statusCode, apiStatusCode) {
+        return (statusCode === 200 || statusCode === 100) && (apiStatusCode === 200 || apiStatusCode === 100);
+    }
+    async handleDevices(deviceLists) {
+        if (!this.config.options?.devices) {
+            await this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
+            if (deviceLists.length === 0) {
+                await this.debugLog('SwitchBot API Has No Devices With Cloud Services Enabled');
+            }
+            else {
+                for (const device of deviceLists) {
+                    if (device.deviceType) {
+                        if (device.configDeviceName) {
+                            device.deviceName = device.configDeviceName;
+                        }
+                        await this.createDevice(device);
+                    }
+                }
+            }
+        }
+        else {
+            await this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+            const devices = this.mergeByDeviceId(deviceLists, this.config.options.devices);
+            await this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
+            for (const device of devices) {
+                if (!device.deviceType && device.configDeviceType) {
+                    device.deviceType = device.configDeviceType;
+                    await this.warnLog(`API is displaying no deviceType: ${device.deviceType}, So using configDeviceType: ${device.configDeviceType}`);
+                }
+                else if (!device.deviceType && !device.configDeviceName) {
+                    await this.errorLog('No deviceType or configDeviceType for device. No device will be created.');
+                }
+                if (device.deviceType) {
+                    if (device.configDeviceName) {
+                        device.deviceName = device.configDeviceName;
+                    }
+                    await this.createDevice(device);
+                }
+            }
+        }
+    }
+    async handleIRDevices(irDeviceLists) {
+        if (!this.config.options?.irdevices) {
+            await this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+            for (const device of irDeviceLists) {
+                if (device.remoteType) {
+                    await this.createIRDevice(device);
+                }
+            }
+        }
+        else {
+            await this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+            const devices = this.mergeByDeviceId(irDeviceLists, this.config.options.irdevices);
+            await this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
+            for (const device of devices) {
+                await this.createIRDevice(device);
+            }
+        }
+    }
+    mergeByDeviceId(a1, a2) {
+        const normalizeDeviceId = (deviceId) => deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '');
+        return a1.map((itm) => {
+            const matchingItem = a2.find(item => normalizeDeviceId(item.deviceId) === normalizeDeviceId(itm.deviceId));
+            return { ...matchingItem, ...itm };
+        });
+    }
+    async handleErrorResponse(statusCode, apiStatusCode, retryCount, maxRetries, delayBetweenRetries) {
+        await this.statusCode(statusCode);
+        await this.statusCode(apiStatusCode);
+        if (statusCode === 500) {
+            this.infoLog(`statusCode: ${statusCode} Attempt ${retryCount + 1} of ${maxRetries}`);
+            await sleep(delayBetweenRetries);
         }
     }
     async createDevice(device) {
-        switch (device.deviceType) {
-            case 'Humidifier':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createHumidifier(device);
-                break;
-            case 'Hub Mini':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                break;
-            case 'Hub Plus':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                break;
-            case 'Hub 2':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createHub2(device);
-                break;
-            case 'Bot':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createBot(device);
-                break;
-            case 'Meter':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createMeter(device);
-                break;
-            case 'MeterPlus':
-            case 'Meter Plus (JP)':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createMeterPlus(device);
-                break;
-            case 'WoIOSensor':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createIOSensor(device);
-                break;
-            case 'Water Detector':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createWaterDetector(device);
-                break;
-            case 'Motion Sensor':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createMotion(device);
-                break;
-            case 'Contact Sensor':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createContact(device);
-                break;
-            case 'Curtain':
-            case 'Curtain3':
-                await this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
-                this.createCurtain(device);
-                break;
-            case 'Blind Tilt':
-                await this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
-                this.createBlindTilt(device);
-                break;
-            case 'Plug':
-            case 'Plug Mini (US)':
-            case 'Plug Mini (JP)':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createPlug(device);
-                break;
-            case 'Smart Lock':
-            case 'Smart Lock Pro':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createLock(device);
-                break;
-            case 'Color Bulb':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createColorBulb(device);
-                break;
-            case 'K10+':
-            case 'WoSweeper':
-            case 'WoSweeperMini':
-            case 'Robot Vacuum Cleaner S1':
-            case 'Robot Vacuum Cleaner S1 Plus':
-            case 'Robot Vacuum Cleaner S10':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createRobotVacuumCleaner(device);
-                break;
-            case 'Ceiling Light':
-            case 'Ceiling Light Pro':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createCeilingLight(device);
-                break;
-            case 'Strip Light':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createStripLight(device);
-                break;
-            case 'Battery Circulator Fan':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createFan(device);
-                break;
-            case 'Remote':
-            case 'Indoor Cam':
-            case 'remote with screen+':
-                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)}`);
+        const deviceTypeHandlers = {
+            'Humidifier': this.createHumidifier.bind(this),
+            'Hub 2': this.createHub2.bind(this),
+            'Bot': this.createBot.bind(this),
+            'Meter': this.createMeter.bind(this),
+            'MeterPlus': this.createMeterPlus.bind(this),
+            'Meter Plus (JP)': this.createMeterPlus.bind(this),
+            'WoIOSensor': this.createIOSensor.bind(this),
+            'Water Detector': this.createWaterDetector.bind(this),
+            'Motion Sensor': this.createMotion.bind(this),
+            'Contact Sensor': this.createContact.bind(this),
+            'Curtain': this.createCurtain.bind(this),
+            'Curtain3': this.createCurtain.bind(this),
+            'WoRollerShade': this.createCurtain.bind(this),
+            'Roller Shade': this.createCurtain.bind(this),
+            'Blind Tilt': this.createBlindTilt.bind(this),
+            'Plug': this.createPlug.bind(this),
+            'Plug Mini (US)': this.createPlug.bind(this),
+            'Plug Mini (JP)': this.createPlug.bind(this),
+            'Smart Lock': this.createLock.bind(this),
+            'Smart Lock Pro': this.createLock.bind(this),
+            'Color Bulb': this.createColorBulb.bind(this),
+            'K10+': this.createRobotVacuumCleaner.bind(this),
+            'WoSweeper': this.createRobotVacuumCleaner.bind(this),
+            'WoSweeperMini': this.createRobotVacuumCleaner.bind(this),
+            'Robot Vacuum Cleaner S1': this.createRobotVacuumCleaner.bind(this),
+            'Robot Vacuum Cleaner S1 Plus': this.createRobotVacuumCleaner.bind(this),
+            'Robot Vacuum Cleaner S10': this.createRobotVacuumCleaner.bind(this),
+            'Ceiling Light': this.createCeilingLight.bind(this),
+            'Ceiling Light Pro': this.createCeilingLight.bind(this),
+            'Strip Light': this.createStripLight.bind(this),
+            'Battery Circulator Fan': this.createFan.bind(this),
+        };
+        if (deviceTypeHandlers[device.deviceType]) {
+            await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+            await deviceTypeHandlers[device.deviceType](device);
+        }
+        else if (['Hub Mini', 'Hub Plus', 'Remote', 'Indoor Cam', 'remote with screen'].includes(device.deviceType)) {
+            await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}, is currently not supported, device: ${JSON.stringify(device)}`);
+        }
+        else {
+            await 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)}`);
         }
     }
     async createIRDevice(device) {
-        if (device.connectionType === undefined) {
-            device.connectionType = 'OpenAPI';
-        }
-        switch (device.remoteType) {
-            case 'TV':
-            case 'DIY TV':
-            case 'Projector':
-            case 'DIY Projector':
-            case 'Set Top Box':
-            case 'DIY Set Top Box':
-            case 'IPTV':
-            case 'DIY IPTV':
-            case 'DVD':
-            case 'DIY DVD':
-            case 'Speaker':
-            case 'DIY Speaker':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                if (device.external === undefined) {
-                    device.external = true;
-                    this.createTV(device);
-                }
-                else {
-                    this.createTV(device);
-                }
-                break;
-            case 'Fan':
-            case 'DIY Fan':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createIRFan(device);
-                break;
-            case 'Air Conditioner':
-            case 'DIY Air Conditioner':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createAirConditioner(device);
-                break;
-            case 'Light':
-            case 'DIY Light':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createLight(device);
-                break;
-            case 'Air Purifier':
-            case 'DIY Air Purifier':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createAirPurifier(device);
-                break;
-            case 'Water Heater':
-            case 'DIY Water Heater':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createWaterHeater(device);
-                break;
-            case 'Vacuum Cleaner':
-            case 'DIY Vacuum Cleaner':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createVacuumCleaner(device);
-                break;
-            case 'Camera':
-            case 'DIY Camera':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createCamera(device);
-                break;
-            case 'Others':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createOthers(device);
-                break;
-            default:
-                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');
+        device.connectionType = device.connectionType ?? 'OpenAPI';
+        const deviceTypeHandlers = {
+            'TV': this.createTV.bind(this),
+            'DIY TV': this.createTV.bind(this),
+            'Projector': this.createTV.bind(this),
+            'DIY Projector': this.createTV.bind(this),
+            'Set Top Box': this.createTV.bind(this),
+            'DIY Set Top Box': this.createTV.bind(this),
+            'IPTV': this.createTV.bind(this),
+            'DIY IPTV': this.createTV.bind(this),
+            'DVD': this.createTV.bind(this),
+            'DIY DVD': this.createTV.bind(this),
+            'Speaker': this.createTV.bind(this),
+            'DIY Speaker': this.createTV.bind(this),
+            'Fan': this.createIRFan.bind(this),
+            'DIY Fan': this.createIRFan.bind(this),
+            'Air Conditioner': this.createAirConditioner.bind(this),
+            'DIY Air Conditioner': this.createAirConditioner.bind(this),
+            'Light': this.createLight.bind(this),
+            'DIY Light': this.createLight.bind(this),
+            'Air Purifier': this.createAirPurifier.bind(this),
+            'DIY Air Purifier': this.createAirPurifier.bind(this),
+            'Water Heater': this.createWaterHeater.bind(this),
+            'DIY Water Heater': this.createWaterHeater.bind(this),
+            'Vacuum Cleaner': this.createVacuumCleaner.bind(this),
+            'DIY Vacuum Cleaner': this.createVacuumCleaner.bind(this),
+            'Camera': this.createCamera.bind(this),
+            'DIY Camera': this.createCamera.bind(this),
+            'Others': this.createOthers.bind(this),
+        };
+        if (deviceTypeHandlers[device.remoteType]) {
+            await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+            if (device.remoteType.startsWith('DIY') && device.external === undefined) {
+                device.external = true;
+            }
+            await deviceTypeHandlers[device.remoteType](device);
+        }
+        else {
+            await this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.remoteType}, is currently not supported. Submit Feature Requests Here: https://tinyurl.com/SwitchBotFeatureRequest, device: ${JSON.stringify(device)}`);
         }
     }
     async createHumidifier(device) {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -903,7 +782,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -964,7 +843,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1024,7 +903,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1085,7 +964,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1146,7 +1025,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1206,7 +1085,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1266,7 +1145,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1326,7 +1205,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1386,7 +1265,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1414,8 +1293,8 @@ export class SwitchBotPlatform {
         else if (await this.registerDevice(device)) {
             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}`);
+                    this.debugLog('Your Curtains are grouped, '
+                        + `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, deviceId: ${device.deviceId}`);
                 }
                 else {
                     if (device.master) {
@@ -1433,7 +1312,6 @@ 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.deviceId = device.deviceId;
             accessory.context.deviceType = device.deviceType;
             accessory.context.model = SwitchBotModel.BlindTilt;
@@ -1461,7 +1339,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1489,8 +1367,8 @@ export class SwitchBotPlatform {
         else if (await this.registerDevice(device)) {
             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}`);
+                    this.debugLog('Your Curtains are grouped, '
+                        + `, Secondary curtain automatically hidden. Main Curtain: ${device.deviceName}, deviceId: ${device.deviceId}`);
                 }
                 else {
                     if (device.master) {
@@ -1535,7 +1413,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1543,8 +1421,11 @@ export class SwitchBotPlatform {
                 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.context.model = device.deviceType === 'Plug Mini (US)'
+                    ? SwitchBotModel.PlugMiniUS
+                    : device.deviceType === 'Plug Mini (JP)'
+                        ? SwitchBotModel.PlugMiniJP
+                        : SwitchBotModel.Plug;
                 existingAccessory.displayName = device.configDeviceName
                     ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
@@ -1571,8 +1452,11 @@ export class SwitchBotPlatform {
             accessory.context.device = device;
             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.context.model = device.deviceType === 'Plug Mini (US)'
+                ? SwitchBotModel.PlugMiniUS
+                : device.deviceType === 'Plug Mini (JP)'
+                    ? SwitchBotModel.PlugMiniJP
+                    : SwitchBotModel.Plug;
             accessory.displayName = device.configDeviceName
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
@@ -1597,7 +1481,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1657,7 +1541,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1717,7 +1601,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1777,7 +1661,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1837,7 +1721,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1897,7 +1781,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (await this.registerDevice(device)) {
@@ -1905,11 +1789,17 @@ export class SwitchBotPlatform {
                 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.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
                     ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
@@ -1936,11 +1826,17 @@ export class SwitchBotPlatform {
             accessory.context.device = device;
             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.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
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
@@ -1965,7 +1861,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        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.device = device;
@@ -1998,7 +1894,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            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}`);
@@ -2006,7 +1901,7 @@ export class SwitchBotPlatform {
             // this is imported from `platformAccessory.ts`
             new TV(this, accessory, device);
             await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
-            this.externalOrPlatformIR(device, accessory);
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2017,7 +1912,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
@@ -2056,7 +1951,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            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}`);
@@ -2065,7 +1959,7 @@ export class SwitchBotPlatform {
             new IRFan(this, accessory, device);
             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.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2076,7 +1970,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
@@ -2115,7 +2009,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            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}`);
@@ -2124,7 +2017,7 @@ export class SwitchBotPlatform {
             new Light(this, accessory, device);
             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.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2135,7 +2028,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
@@ -2174,7 +2067,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            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}`);
@@ -2183,7 +2075,7 @@ export class SwitchBotPlatform {
             new AirConditioner(this, accessory, device);
             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.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2194,7 +2086,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
@@ -2233,7 +2125,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            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}`);
@@ -2242,7 +2133,7 @@ export class SwitchBotPlatform {
             new AirPurifier(this, accessory, device);
             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.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2253,7 +2144,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
@@ -2292,7 +2183,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            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}`);
@@ -2301,7 +2191,7 @@ export class SwitchBotPlatform {
             new WaterHeater(this, accessory, device);
             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.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2312,7 +2202,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
@@ -2351,7 +2241,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            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}`);
@@ -2360,7 +2249,7 @@ export class SwitchBotPlatform {
             new VacuumCleaner(this, accessory, device);
             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.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2371,7 +2260,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
@@ -2410,7 +2299,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            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}`);
@@ -2419,7 +2307,7 @@ export class SwitchBotPlatform {
             new Camera(this, accessory, device);
             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.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2430,7 +2318,7 @@ export class SwitchBotPlatform {
         const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.remoteType}`);
         // see if an accessory with the same uuid has already been registered and restored from
         // the cached devices we stored in the `configureAccessory` method above
-        const existingAccessory = this.accessories.find((accessory) => accessory.UUID === uuid);
+        const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
         if (existingAccessory) {
             // the accessory already exists
             if (!device.hide_device && device.hubDeviceId) {
@@ -2469,7 +2357,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            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}`);
@@ -2478,7 +2365,7 @@ export class SwitchBotPlatform {
             new Others(this, accessory, device);
             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.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2486,24 +2373,13 @@ export class SwitchBotPlatform {
         }
     }
     async registerCurtains(device) {
-        /*function isCurtainDevice(device: device & devicesConfig): device is (curtain | curtain3) & devicesConfig {
-          return device.deviceType === 'Curtain' || device.deviceType === 'Curtain3';
-        }
-    
-        function isBlindTiltDevice(device: device & devicesConfig): device is blindTilt & devicesConfig {
-          return device.deviceType === 'Blind Tilt';
-        }*/
         let registerWindowCovering;
         if (isCurtainDevice(device)) {
-            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}`);
+            await this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds},x master: ${device.master}, group: ${device.group}, disable_group: ${device.curtain?.disable_group}, connectionType: ${device.connectionType}`);
             registerWindowCovering = await this.registerWindowCovering(device);
         }
         else if (isBlindTiltDevice(device)) {
-            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}`);
+            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);
         }
         else {
@@ -2517,36 +2393,31 @@ export class SwitchBotPlatform {
         if (device.master && device.group) {
             // OpenAPI: Master Curtains/Blind Tilt in Group
             registerCurtain = true;
-            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master},`
-                + ` device.group: ${device.group} connectionType; ${device.connectionType}`);
+            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'
+            // !device.group && device.connectionType === 'BLE'
             // OpenAPI: Non-Master Curtains/Blind Tilts that has Disable Grouping Checked
             registerCurtain = true;
-            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, disable_group: `
-                + `${device.curtain?.disable_group}, connectionType; ${device.connectionType}`);
+            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, disable_group: ${device.curtain?.disable_group}, connectionType; ${device.connectionType}`);
             await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else if (device.master && !device.group) {
             // OpenAPI: Master Curtains/Blind Tilts not in Group
             registerCurtain = true;
-            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master},`
-                + ` device.group: ${device.group} connectionType; ${device.connectionType}`);
+            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;
-            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] connectionType: ${device.connectionType}, `
-                + ` group: ${device.group}`);
+            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] connectionType: ${device.connectionType}, group: ${device.group}`);
             await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else {
             registerCurtain = false;
-            await this.debugErrorLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] disable_group: ${device.curtain?.disable_group},`
-                + ` device.master: ${device.master}, device.group: ${device.group}`);
+            await this.debugErrorLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] disable_group: ${device.curtain?.disable_group}, device.master: ${device.master}, device.group: ${device.group}`);
             await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}, device.connectionType: ${device.connectionType}`);
         }
         return registerCurtain;
@@ -2564,189 +2435,93 @@ export class SwitchBotPlatform {
     async registerDevice(device) {
         device.connectionType = await this.connectionType(device);
         let registerDevice;
-        if (!device.hide_device && device.connectionType === 'BLE/OpenAPI') {
-            switch (device.deviceType) {
-                case 'Curtain':
-                case 'Curtain3':
-                case 'Blind Tilt':
-                    registerDevice = await this.registerCurtains(device);
-                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
-                    break;
-                default:
-                    registerDevice = true;
-                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
-            }
-            if (registerDevice === true) {
-                await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
-            }
-            else {
-                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') {
-            switch (device.deviceType) {
-                case 'Curtain':
-                case 'Curtain3':
-                case 'Blind Tilt':
-                    registerDevice = await this.registerCurtains(device);
-                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
-                    break;
-                default:
-                    registerDevice = true;
-                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
-            }
-            if (registerDevice === true) {
-                await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
-            }
-            else {
-                await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
-            }
-        }
-        else if (!device.hide_device && device.connectionType === 'OpenAPI') {
-            switch (device.deviceType) {
-                case 'Curtain':
-                case 'Curtain3':
-                case 'Blind Tilt':
-                    registerDevice = await this.registerCurtains(device);
-                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
-                    break;
-                default:
-                    registerDevice = true;
-                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
-            }
-            if (registerDevice === true) {
-                await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
-            }
-            else {
-                await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
-            }
-        }
-        else if (!device.hide_device && device.connectionType === 'Disabled') {
-            switch (device.deviceType) {
-                case 'Curtain':
-                case 'Curtain3':
-                case 'Blind Tilt':
-                    registerDevice = await this.registerCurtains(device);
-                    await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
-                    break;
-                default:
-                    registerDevice = true;
-                    await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
-            }
-            await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will continue to display in HomeKit`);
-        }
-        else if (!device.connectionType && !device.hide_device) {
-            registerDevice = false;
-            await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
-        }
-        else if (device.hide_device) {
-            registerDevice = false;
-            await this.debugErrorLog(`Device: ${device.deviceName} hide_device: ${device.hide_device}, will not display in HomeKit`);
+        const shouldRegister = !device.hide_device && (device.connectionType === 'BLE/OpenAPI' || (device.deviceId && device.configDeviceType && device.configDeviceName && device.connectionType === 'BLE') || device.connectionType === 'OpenAPI' || device.connectionType === 'Disabled');
+        if (shouldRegister) {
+            registerDevice = await this.handleDeviceRegistration(device);
         }
         else {
             registerDevice = false;
-            await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, hide_device: `
-                + `${device.hide_device},  will not display in HomeKit`);
+            await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, hide_device: ${device.hide_device}, will not display in HomeKit`);
         }
         return registerDevice;
     }
-    async externalOrPlatformIR(device, accessory) {
-        /**
-         * Publish as external accessory
-         * Only one TV can exist per bridge, to bypass this limitation, you should
-         * publish your TV as an external accessory.
-         */
-        if (device.external) {
-            await this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
-            this.externalAccessory(accessory);
+    async handleDeviceRegistration(device) {
+        let registerDevice;
+        switch (device.deviceType) {
+            case 'Curtain':
+            case 'Curtain3':
+            case 'Blind Tilt':
+                registerDevice = await this.registerCurtains(device);
+                await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                break;
+            default:
+                registerDevice = true;
+                await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+        }
+        if (registerDevice) {
+            await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
         }
         else {
-            await this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
-            this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+            await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
         }
+        return registerDevice;
     }
     async externalOrPlatform(device, accessory) {
-        if (device.external) {
-            await this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
-            await this.externalAccessory(accessory);
+        const { displayName } = accessory;
+        const isExternal = device.external ?? false;
+        if (isExternal) {
+            await this.debugWarnLog(`${displayName} External Accessory Mode`);
+            this.api.publishExternalAccessories(PLUGIN_NAME, [accessory]);
         }
         else {
-            await this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
+            await this.debugLog(`${displayName} External Accessory Mode: ${isExternal}`);
             this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
         }
     }
-    async externalAccessory(accessory) {
-        this.api.publishExternalAccessories(PLUGIN_NAME, [accessory]);
-    }
     unregisterPlatformAccessories(existingAccessory) {
+        const { displayName } = existingAccessory;
         // remove platform accessories when no longer present
         this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [existingAccessory]);
-        this.warnLog(`Removing existing accessory from cache: ${existingAccessory.displayName}`);
+        this.warnLog(`Removing existing accessory from cache: ${displayName}`);
     }
+    /**
+     * Handles the status codes returned by the device and logs appropriate messages.
+     *
+     * @param statusCode - The status code returned by the device.
+     * @returns A promise that resolves when the logging is complete.
+     */
     async statusCode(statusCode) {
-        switch (statusCode) {
-            case 151:
-                await this.errorLog(`Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: ` +
-                    'https://tinyurl.com/SwitchBotFeatureRequest');
-                break;
-            case 152:
-                await this.errorLog(`Device not found, statusCode: ${statusCode}`);
-                break;
-            case 160:
-                await this.errorLog(`Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`);
-                break;
-            case 161:
-                await this.errorLog(`Device is offline, statusCode: ${statusCode}`);
-                break;
-            case 171:
-                await this.errorLog(`is offline, statusCode: ${statusCode}`);
-                break;
-            case 190:
-                await this.errorLog(`Requests reached the daily limit, statusCode: ${statusCode}`);
-                break;
-            case 100:
-                await this.debugLog(`Command successfully sent, statusCode: ${statusCode}`);
-                break;
-            case 200:
-                await this.debugLog(`Request successful, statusCode: ${statusCode}`);
-                break;
-            case 400:
-                await this.errorLog('Bad Request, The client has issued an invalid request. This is commonly used to specify validation errors in a request '
-                    + `payload, statusCode: ${statusCode}`);
-                break;
-            case 401:
-                await this.errorLog('Unauthorized,	Authorization for the API is required, but the request has not been authenticated, '
-                    + `statusCode: ${statusCode}`);
-                break;
-            case 403:
-                await this.errorLog('Forbidden,	The request has been authenticated but does not have appropriate permissions, or a requested resource is not '
-                    + `found, statusCode: ${statusCode}`);
-                break;
-            case 404:
-                await this.errorLog(`Not Found,	Specifies the requested path does not exist, statusCode: ${statusCode}`);
-                break;
-            case 406:
-                await this.errorLog('Not Acceptable,	The client has requested a MIME type via the Accept header for a value not supported by the server, '
-                    + `statusCode: ${statusCode}`);
-                break;
-            case 415:
-                await this.errorLog('Unsupported Media Type,	The client has defined a contentType header that is not supported by the server, '
-                    + `statusCode: ${statusCode}`);
-                break;
-            case 422:
-                await this.errorLog('Unprocessable Entity,	The client has made a valid request, but the server cannot process it. This is often used for '
-                    + `APIs for which certain limits have been exceeded, statusCode: ${statusCode}`);
-                break;
-            case 429:
-                await this.errorLog('Too Many Requests,	The client has exceeded the number of requests allowed for a given time window, '
-                    + `statusCode: ${statusCode}`);
-                break;
-            case 500:
-                await this.errorLog('Internal Server Error,	An unexpected error on the SmartThings servers has occurred. These errors should be rare, '
-                    + `statusCode: ${statusCode}`);
-                break;
-            default:
-                await this.errorLog(`Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
+        const messages = {
+            151: `Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: 
+            https://tinyurl.com/SwitchBotFeatureRequest`,
+            152: `Device not found, statusCode: ${statusCode}`,
+            160: `Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`,
+            161: `Device is offline, statusCode: ${statusCode}`,
+            171: `is offline, statusCode: ${statusCode}`,
+            190: `Requests reached the daily limit, statusCode: ${statusCode}`,
+            100: `Command successfully sent, statusCode: ${statusCode}`,
+            200: `Request successful, statusCode: ${statusCode}`,
+            400: `Bad Request, The client has issued an invalid request. This is commonly used to specify validation errors in a request payload, 
+            statusCode: ${statusCode}`,
+            401: `Unauthorized, Authorization for the API is required, but the request has not been authenticated, statusCode: ${statusCode}`,
+            403: `Forbidden, The request has been authenticated but does not have appropriate permissions, or a requested resource is not found, 
+            statusCode: ${statusCode}`,
+            404: `Not Found, Specifies the requested path does not exist, statusCode: ${statusCode}`,
+            406: `Not Acceptable, The client has requested a MIME type via the Accept header for a value not supported by the server, 
+            statusCode: ${statusCode}`,
+            415: `Unsupported Media Type, The client has defined a contentType header that is not supported by the server, statusCode: ${statusCode}`,
+            422: `Unprocessable Entity, The client has made a valid request, but the server cannot process it. This is often used for APIs for which 
+            certain limits have been exceeded, statusCode: ${statusCode}`,
+            429: `Too Many Requests, The client has exceeded the number of requests allowed for a given time window, statusCode: ${statusCode}`,
+            500: `Internal Server Error, An unexpected error on the SmartThings servers has occurred. These errors should be rare, 
+            statusCode: ${statusCode}`,
+        };
+        const message = messages[statusCode] ?? `Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`;
+        if ([100, 200].includes(statusCode)) {
+            await this.debugLog(message);
+        }
+        else {
+            await this.errorLog(message);
         }
     }
     async retryRequest(deviceMaxRetries, deviceDelayBetweenRetries, url, options) {
@@ -2774,57 +2549,42 @@ export class SwitchBotPlatform {
     }
     // BLE Connection
     async connectBLE(accessory, device) {
-        let switchbot;
         try {
-            const SwitchBot = (await import('node-switchbot')).SwitchBot;
-            queueScheduler.schedule(() => (switchbot = new SwitchBot()));
+            const switchbot = new SwitchBot();
+            queueScheduler.schedule(async () => switchbot);
             await this.debugLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${switchbot}`);
+            return switchbot;
         }
         catch (e) {
-            switchbot = false;
-            await this.errorLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${switchbot}, Error: ${e}`);
+            await this.errorLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' not found, Error: ${e}`);
+            return false;
         }
-        return switchbot;
     }
     async getVersion() {
         const json = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
         await this.debugLog(`Plugin Version: ${json.version}`);
         this.version = json.version;
+        return json.version;
     }
     async getPlatformConfigSettings() {
+        const { options } = this.config;
         const platformConfig = {};
-        if (this.config.options) {
-            if (this.config.options.logging) {
-                platformConfig.logging = this.config.options.logging;
-            }
-            if (this.config.options.refreshRate) {
-                platformConfig.refreshRate = this.config.options.refreshRate;
-            }
-            if (this.config.options.updateRate) {
-                platformConfig.updateRate = this.config.options.updateRate;
-            }
-            if (this.config.options.pushRate) {
-                platformConfig.pushRate = this.config.options.pushRate;
-            }
-            if (this.config.options.maxRetries) {
-                this.maxRetries = this.config.options.maxRetries;
-                platformConfig.maxRetries = this.config.options.maxRetries;
-            }
-            else {
-                this.maxRetries = 3;
-                this.debugWarnLog('Using Default Max Retries');
-                platformConfig.maxRetries = this.maxRetries;
-            }
-            if (this.config.options.delayBetweenRetries) {
-                this.delayBetweenRetries = this.config.options.delayBetweenRetries * 1000;
-                platformConfig.delayBetweenRetries = this.config.options.delayBetweenRetries;
-            }
-            else {
-                this.delayBetweenRetries = 3000;
-                this.debugWarnLog('Using Default Delay Between Retries');
-                platformConfig.delayBetweenRetries = this.delayBetweenRetries / 1000;
-            }
-            if (Object.entries(platformConfig).length !== 0) {
+        if (options) {
+            platformConfig.logging = options.logging;
+            platformConfig.refreshRate = options.refreshRate;
+            platformConfig.updateRate = options.updateRate;
+            platformConfig.pushRate = options.pushRate;
+            this.maxRetries = options.maxRetries || 3;
+            platformConfig.maxRetries = this.maxRetries;
+            if (!options.maxRetries) {
+                await this.debugWarnLog('Using Default Max Retries');
+            }
+            this.delayBetweenRetries = (options.delayBetweenRetries || 3) * 1000;
+            platformConfig.delayBetweenRetries = this.delayBetweenRetries / 1000;
+            if (!options.delayBetweenRetries) {
+                await this.debugWarnLog('Using Default Delay Between Retries');
+            }
+            if (Object.keys(platformConfig).length) {
                 await this.debugLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
             }
             this.platformConfig = platformConfig;
@@ -2851,34 +2611,30 @@ export class SwitchBotPlatform {
      * @param name - The name of the characteristic.
      * @param value - The value to be validated and cleaned.
      * @returns The cleaned string value.
-    */
+     */
     async validateAndCleanDisplayName(displayName, name, value) {
         if (this.config.options?.allowInvalidCharacters) {
             return value;
         }
         else {
-            const validPattern = new RegExp(/^[\p{L}\p{N}][\p{L}\p{N} ']*[\p{L}\p{N}]$/u);
+            const validPattern = /^[\p{L}\p{N}][\p{L}\p{N} ']*[\p{L}\p{N}]$/u;
             const invalidCharsPattern = /[^\p{L}\p{N} ']/gu;
             const invalidStartEndPattern = /^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu;
             if (typeof value === 'string' && !validPattern.test(value)) {
-                this.warnLog(`WARNING: The accessory '${displayName}' has an invalid '${name}' characteristic ('${value}'). Please use only alphanumeric,`
-                    + ' space, and apostrophe characters. Ensure it starts and ends with an alphabetic or numeric character, and avoid emojis. This may'
-                    + ' prevent the accessory from being added in the Home App or cause unresponsiveness.');
+                await this.warnLog(`WARNING: The accessory '${displayName}' has an invalid '${name}' characteristic ('${value}'). Please use only alphanumeric, space, and apostrophe characters. Ensure it starts and ends with an alphabetic or numeric character, and avoid emojis. This may prevent the accessory from being added in the Home App or cause unresponsiveness.`);
                 // Remove invalid characters
                 if (invalidCharsPattern.test(value)) {
                     const before = value;
-                    this.warnLog(`Removing invalid characters from '${name}' characteristic, if you feel this is incorrect,`
-                        + ' please enable \'allowInvalidCharacter\' in the config to allow all characters');
+                    await this.warnLog(`Removing invalid characters from '${name}' characteristic, if you feel this is incorrect, please enable \'allowInvalidCharacter\' in the config to allow all characters`);
                     value = value.replace(invalidCharsPattern, '');
-                    this.warnLog(`${name} Before: '${before}' After: '${value}'`);
+                    await this.warnLog(`${name} Before: '${before}' After: '${value}'`);
                 }
                 // Ensure it starts and ends with an alphanumeric character
                 if (invalidStartEndPattern.test(value)) {
                     const before = value;
-                    this.warnLog(`Removing invalid starting or ending characters from '${name}' characteristic, if you feel this is incorrect,`
-                        + ' please enable \'allowInvalidCharacter\' in the config to allow all characters');
+                    await this.warnLog(`Removing invalid starting or ending characters from '${name}' characteristic, if you feel this is incorrect, please enable \'allowInvalidCharacter\' in the config to allow all characters`);
                     value = value.replace(invalidStartEndPattern, '');
-                    this.warnLog(`${name} Before: '${before}' After: '${value}'`);
+                    await this.warnLog(`${name} Before: '${before}' After: '${value}'`);
                 }
             }
             return value;