@switchbot/homebridge-switchbot 4.1.1-beta.2 → 4.1.1-beta.4

package/dist/platform.js

@@ -149,14 +149,14 @@ 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 () => {
-            await this.debugLog('Executed didFinishLaunching callback');
+            this.debugLog('Executed didFinishLaunching callback');
             // run the method to discover / register your devices as accessories
             try {
                 await this.discoverDevices();
             }
             catch (e) {
-                await this.errorLog(`Failed to Discover, Error Message: ${e.message ?? e}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
-                await this.debugErrorLog(`Failed to Discover, Error: ${e.message ?? e}`);
+                this.errorLog(`Failed to Discover, Error Message: ${e.message ?? e}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
+                this.debugErrorLog(`Failed to Discover, Error: ${e.message ?? e}`);
             }
         });
         try {
@@ -183,29 +183,29 @@ export class SwitchBotPlatform {
             try {
                 const { connectAsync } = asyncmqtt;
                 this.mqttClient = await connectAsync(this.config.options?.mqttURL, this.config.options.mqttOptions || {});
-                await this.debugLog('MQTT connection has been established successfully.');
+                this.debugLog('MQTT connection has been established successfully.');
                 this.mqttClient.on('error', async (e) => {
-                    await this.errorLog(`Failed to publish MQTT messages. ${e.message ?? e}`);
+                    this.errorLog(`Failed to publish MQTT messages. ${e.message ?? e}`);
                 });
                 if (!this.config.options?.webhookURL) {
                     // receive webhook events via MQTT
-                    await this.infoLog(`Webhook is configured to be received through ${this.config.options.mqttURL}/homebridge-switchbot/webhook.`);
+                    this.infoLog(`Webhook is configured to be received through ${this.config.options.mqttURL}/homebridge-switchbot/webhook.`);
                     this.mqttClient.subscribe('homebridge-switchbot/webhook/+');
                     this.mqttClient.on('message', async (topic, message) => {
                         try {
-                            await this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
+                            this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
                             const context = JSON.parse(message.toString());
                             this.webhookEventHandler[context.deviceMac]?.(context);
                         }
                         catch (e) {
-                            await this.errorLog(`Failed to handle webhook event. Error:${e.message ?? e}`);
+                            this.errorLog(`Failed to handle webhook event. Error:${e.message ?? e}`);
                         }
                     });
                 }
             }
             catch (e) {
                 this.mqttClient = null;
-                await this.errorLog(`Failed to establish MQTT connection. ${e.message ?? e}`);
+                this.errorLog(`Failed to establish MQTT connection. ${e.message ?? e}`);
             }
         }
     }
@@ -226,14 +226,14 @@ export class SwitchBotPlatform {
                 });
             }
             catch (e) {
-                await this.errorLog(`Failed to setup webhook. Error:${e.message ?? e}`);
+                this.errorLog(`Failed to setup webhook. Error:${e.message ?? e}`);
             }
             this.api.on('shutdown', async () => {
                 try {
                     this.switchBotAPI.deleteWebhook(url);
                 }
                 catch (e) {
-                    await this.errorLog(`Failed to delete webhook. Error:${e.message ?? e}`);
+                    this.errorLog(`Failed to delete webhook. Error:${e.message ?? e}`);
                 }
             });
         }
@@ -272,20 +272,20 @@ export class SwitchBotPlatform {
             });
         }
         if (this.config.options?.BLE) {
-            await this.debugLog('setupBLE');
+            this.debugLog('setupBLE');
             if (this.switchBotBLE === undefined) {
-                await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${JSON.stringify(this.switchBotBLE)}`);
+                this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${JSON.stringify(this.switchBotBLE)}`);
             }
             else {
                 // Start to monitor advertisement packets
                 (async () => {
                     // Start to monitor advertisement packets
-                    await this.debugLog('Scanning for BLE SwitchBot devices...');
+                    this.debugLog('Scanning for BLE SwitchBot devices...');
                     try {
                         await this.switchBotBLE.startScan();
                     }
                     catch (e) {
-                        await this.errorLog(`Failed to start BLE scanning. Error:${e.message ?? e}`);
+                        this.errorLog(`Failed to start BLE scanning. Error:${e.message ?? e}`);
                     }
                     // Set an event handler to monitor advertisement packets
                     this.switchBotBLE.onadvertisement = async (ad) => {
@@ -293,23 +293,23 @@ export class SwitchBotPlatform {
                             this.bleEventHandler[ad.address]?.(ad.serviceData);
                         }
                         catch (e) {
-                            await this.errorLog(`Failed to handle BLE event. Error:${e.message ?? e}`);
+                            this.errorLog(`Failed to handle BLE event. Error:${e.message ?? e}`);
                         }
                     };
                 })();
                 this.api.on('shutdown', async () => {
                     try {
                         // this.switchBotBLE.stopScan()
-                        await this.infoLog('Stopped BLE scanning to close listening.');
+                        this.infoLog('Stopped BLE scanning to close listening.');
                     }
                     catch (e) {
-                        await this.errorLog(`Failed to stop Platform BLE scanning. Error:${e.message ?? e}`);
+                        this.errorLog(`Failed to stop Platform BLE scanning. Error:${e.message ?? e}`);
                     }
                 });
             }
         }
         else {
-            await this.debugLog('Platform BLE is not enabled');
+            this.debugLog('Platform BLE is not enabled');
         }
     }
     /**
@@ -318,7 +318,7 @@ export class SwitchBotPlatform {
      */
     async configureAccessory(accessory) {
         const { displayName } = accessory;
-        await this.debugLog(`Loading accessory from cache: ${displayName}`);
+        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);
     }
@@ -326,7 +326,7 @@ export class SwitchBotPlatform {
      * Verify the config passed to the plugin is valid
      */
     async verifyConfig() {
-        await this.debugLog('Verifying Config');
+        this.debugLog('Verifying Config');
         this.config = this.config || {};
         this.config.options = this.config.options || {};
         const platformConfig = {};
@@ -340,7 +340,7 @@ export class SwitchBotPlatform {
             platformConfig.pushRate = this.config.options.pushRate;
         }
         if (Object.entries(platformConfig).length !== 0) {
-            await this.debugWarnLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
+            this.debugWarnLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
         }
         if (this.config.options) {
             // Device Config
@@ -361,10 +361,10 @@ export class SwitchBotPlatform {
                 for (const irDeviceConfig of this.config.options.irdevices) {
                     if (!irDeviceConfig.hide_device) {
                         if (!irDeviceConfig.deviceId) {
-                            await this.errorLog('The devices config section is missing the *Device ID* in the config. Please check your config.');
+                            this.errorLog('The devices config section is missing the *Device ID* in the config. Please check your config.');
                         }
                         if (!irDeviceConfig.deviceId && !irDeviceConfig.configRemoteType) {
-                            await this.errorLog('The devices config section is missing the *Device Type* in the config. Please check your config.');
+                            this.errorLog('The devices config section is missing the *Device Type* in the config. Please check your config.');
                         }
                     }
                 }
@@ -376,16 +376,16 @@ export class SwitchBotPlatform {
         if (!this.config.options.refreshRate) {
             // default 120 seconds (2 minutes)
             this.config.options.refreshRate = 120;
-            await this.debugWarnLog('Using Default Refresh Rate (2 minutes).');
+            this.debugWarnLog('Using Default Refresh Rate (2 minutes).');
         }
         if (!this.config.options.pushRate) {
             // default 100 milliseconds
             this.config.options.pushRate = 0.1;
-            await this.debugWarnLog('Using Default Push Rate.');
+            this.debugWarnLog('Using Default Push Rate.');
         }
         if (!this.config.options.maxRetries) {
             this.config.options.maxRetries = 5;
-            await this.debugWarnLog('Using Default Max Retries.');
+            this.debugWarnLog('Using Default Max Retries.');
         }
         else {
             this.maxRetries = this.config.options.maxRetries;
@@ -393,23 +393,23 @@ export class SwitchBotPlatform {
         if (!this.config.options.delayBetweenRetries) {
             // default 3 seconds
             this.config.options.delayBetweenRetries = 3000;
-            await this.debugWarnLog('Using Default Delay Between Retries.');
+            this.debugWarnLog('Using Default Delay Between Retries.');
         }
         else {
             this.delayBetweenRetries = this.config.options.delayBetweenRetries * 1000;
         }
         if (!this.config.credentials && !this.config.options) {
-            await this.debugWarnLog('Missing Credentials');
+            this.debugWarnLog('Missing Credentials');
         }
         else if (this.config.credentials && !this.config.credentials.notice) {
             if (!this.config.credentials?.token) {
-                await this.debugErrorLog('Missing token');
-                await this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
+                this.debugErrorLog('Missing token');
+                this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
             }
             if (this.config.credentials?.token) {
                 if (!this.config.credentials?.secret) {
-                    await this.debugErrorLog('Missing secret');
-                    await this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
+                    this.debugErrorLog('Missing secret');
+                    this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
                 }
             }
         }
@@ -421,13 +421,13 @@ export class SwitchBotPlatform {
         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}`);
+        this.debugWarnLog(`Retry Count: ${retryCount}`);
+        this.debugWarnLog(`Max Retries: ${maxRetries}`);
+        this.debugWarnLog(`Delay Between Retries: ${delayBetweenRetries}`);
         while (retryCount < maxRetries) {
             try {
                 const { response, statusCode } = await this.switchBotAPI.getDevices();
-                await this.debugLog(`response: ${JSON.stringify(response)}`);
+                this.debugLog(`response: ${JSON.stringify(response)}`);
                 if (this.isSuccessfulResponse(statusCode)) {
                     await this.handleDevices(Array.isArray(response.body.deviceList) ? response.body.deviceList : []);
                     await this.handleIRDevices(Array.isArray(response.body.infraredRemoteList) ? response.body.infraredRemoteList : []);
@@ -440,32 +440,32 @@ export class SwitchBotPlatform {
             }
             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.message ?? e}`);
+                this.debugErrorLog(`Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`);
+                this.debugErrorLog(`Failed to Discover Devices, Error: ${e.message ?? e}`);
             }
         }
     }
     async handleManualConfig() {
         if (this.config.options?.devices) {
-            await this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+            this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
             const devices = this.config.options.devices.map((v) => v);
             for (const device of devices) {
                 device.deviceType = device.configDeviceType;
                 device.deviceName = device.configDeviceName;
                 try {
                     device.deviceId = formatDeviceIdAsMac(device.deviceId, true);
-                    await this.debugLog(`deviceId: ${device.deviceId}`);
+                    this.debugLog(`deviceId: ${device.deviceId}`);
                     if (device.deviceType) {
                         await this.createDevice(device);
                     }
                 }
                 catch (error) {
-                    await this.errorLog(`failed to format device ID as MAC, Error: ${error}`);
+                    this.errorLog(`failed to format device ID as MAC, Error: ${error}`);
                 }
             }
         }
         else {
-            await this.errorLog('Neither SwitchBot Token or Device Config are set.');
+            this.errorLog('Neither SwitchBot Token or Device Config are set.');
         }
     }
     isSuccessfulResponse(apiStatusCode) {
@@ -473,9 +473,9 @@ export class SwitchBotPlatform {
     }
     async handleDevices(deviceLists) {
         if (!this.config.options?.devices && !this.config.options?.deviceConfig) {
-            await this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
+            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');
+                this.debugLog('SwitchBot API Has No Devices With Cloud Services Enabled');
             }
             else {
                 for (const device of deviceLists) {
@@ -489,15 +489,15 @@ export class SwitchBotPlatform {
             }
         }
         else if (this.config.options?.devices || this.config.options?.deviceConfig) {
-            await this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+            this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
             // Step 1: Check and assign configDeviceType to deviceType if deviceType is not present
             const devicesWithTypeConfigPromises = deviceLists.map(async (device) => {
                 if (!device.deviceType && device.configDeviceType) {
                     device.deviceType = device.configDeviceType;
-                    await this.warnLog(`API is displaying no deviceType: ${device.deviceType}, So using configDeviceType: ${device.configDeviceType}`);
+                    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.');
+                    this.errorLog('No deviceType or configDeviceType for device. No device will be created.');
                     return null; // Skip this device
                 }
                 // Retrieve deviceTypeConfig for each device and merge it
@@ -507,7 +507,7 @@ export class SwitchBotPlatform {
             // Wait for all promises to resolve
             const devicesWithTypeConfig = (await Promise.all(devicesWithTypeConfigPromises)).filter(device => device !== null); // Filter out skipped devices
             const devices = this.mergeByDeviceId(this.config.options.devices ?? [], devicesWithTypeConfig ?? []);
-            await this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
+            this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
             for (const device of devices) {
                 const deviceIdConfig = this.config.options?.devices?.[device.deviceId] || {};
                 const deviceWithConfig = Object.assign({}, device, deviceIdConfig);
@@ -521,7 +521,7 @@ export class SwitchBotPlatform {
     }
     async handleIRDevices(irDeviceLists) {
         if (!this.config.options?.irdevices && !this.config.options?.irdeviceConfig) {
-            await this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+            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);
@@ -529,15 +529,15 @@ export class SwitchBotPlatform {
             }
         }
         else if (this.config.options?.irdevices || this.config.options?.irdeviceConfig) {
-            await this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+            this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
             // Step 1: Check and assign configRemoteType to remoteType if remoteType is not present
             const devicesWithTypeConfigPromises = irDeviceLists.map(async (device) => {
                 if (!device.remoteType && device.configRemoteType) {
                     device.remoteType = device.configRemoteType;
-                    await this.warnLog(`API is displaying no remoteType: ${device.remoteType}, So using configRemoteType: ${device.configRemoteType}`);
+                    this.warnLog(`API is displaying no remoteType: ${device.remoteType}, So using configRemoteType: ${device.configRemoteType}`);
                 }
                 else if (!device.remoteType && !device.configDeviceName) {
-                    await this.errorLog('No remoteType or configRemoteType for device. No device will be created.');
+                    this.errorLog('No remoteType or configRemoteType for device. No device will be created.');
                     return null; // Skip this device
                 }
                 // Retrieve remoteTypeConfig for each device and merge it
@@ -547,7 +547,7 @@ export class SwitchBotPlatform {
             // Wait for all promises to resolve
             const devicesWithRemoteTypeConfig = (await Promise.all(devicesWithTypeConfigPromises)).filter(device => device !== null); // Filter out skipped devices
             const devices = this.mergeByDeviceId(this.config.options.irdevices ?? [], devicesWithRemoteTypeConfig ?? []);
-            await this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
+            this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
             for (const device of devices) {
                 const irdeviceIdConfig = this.config.options?.irdevices?.[device.deviceId] || {};
                 const irdeviceWithConfig = Object.assign({}, device, irdeviceIdConfig);
@@ -609,14 +609,14 @@ export class SwitchBotPlatform {
             'Battery Circulator Fan': this.createFan.bind(this),
         };
         if (deviceTypeHandlers[device.deviceType]) {
-            await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+            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)}`);
+            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)}`);
+            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) {
@@ -651,14 +651,14 @@ export class SwitchBotPlatform {
             'Others': this.createOthers.bind(this),
         };
         if (deviceTypeHandlers[device.remoteType]) {
-            await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+            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)}`);
+            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) {
@@ -679,12 +679,12 @@ export class SwitchBotPlatform {
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
                 existingAccessory.context.connectionType = await this.connectionType(device);
                 existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Humidifier(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -707,17 +707,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Humidifier(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createBot(device) {
@@ -743,7 +743,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Bot(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -767,18 +767,18 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // accessory.context.version = findaccessories.accessoryAttribute.softwareRevision;
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Bot(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createMeter(device) {
@@ -804,7 +804,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Meter(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -828,17 +828,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Meter(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createMeterPlus(device) {
@@ -865,7 +865,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new MeterPlus(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -889,17 +889,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new MeterPlus(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createMeterPro(device) {
@@ -926,7 +926,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new MeterPro(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -950,17 +950,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new MeterPro(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createHub2(device) {
@@ -987,7 +987,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Hub(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1011,17 +1011,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Hub(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createIOSensor(device) {
@@ -1042,12 +1042,12 @@ export class SwitchBotPlatform {
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
                 existingAccessory.context.connectionType = await this.connectionType(device);
                 existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new IOSensor(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1071,17 +1071,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new IOSensor(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createWaterDetector(device) {
@@ -1107,7 +1107,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new WaterDetector(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1131,17 +1131,17 @@ export class SwitchBotPlatform {
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             accessory.context.connectionType = await this.connectionType(device);
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new WaterDetector(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createMotion(device) {
@@ -1167,7 +1167,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Motion(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1191,17 +1191,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Motion(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createContact(device) {
@@ -1227,7 +1227,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Contact(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1251,17 +1251,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Contact(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createBlindTilt(device) {
@@ -1287,7 +1287,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new BlindTilt(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1325,17 +1325,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new BlindTilt(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createCurtain(device) {
@@ -1356,12 +1356,12 @@ export class SwitchBotPlatform {
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
                 existingAccessory.context.connectionType = await this.connectionType(device);
                 existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Curtain(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1399,17 +1399,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Curtain(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createPlug(device) {
@@ -1434,12 +1434,12 @@ export class SwitchBotPlatform {
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
                 existingAccessory.context.connectionType = await this.connectionType(device);
                 existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Plug(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1467,17 +1467,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Plug(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createLock(device) {
@@ -1503,7 +1503,7 @@ export class SwitchBotPlatform {
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Lock(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1527,17 +1527,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Lock(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createColorBulb(device) {
@@ -1558,12 +1558,12 @@ export class SwitchBotPlatform {
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
                 existingAccessory.context.connectionType = await this.connectionType(device);
                 existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new ColorBulb(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1587,17 +1587,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new ColorBulb(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createCeilingLight(device) {
@@ -1618,12 +1618,12 @@ export class SwitchBotPlatform {
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
                 existingAccessory.context.connectionType = await this.connectionType(device);
                 existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new CeilingLight(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1647,17 +1647,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new CeilingLight(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createStripLight(device) {
@@ -1678,12 +1678,12 @@ export class SwitchBotPlatform {
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
                 existingAccessory.context.connectionType = await this.connectionType(device);
                 existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new StripLight(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1707,17 +1707,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new StripLight(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createFan(device) {
@@ -1738,12 +1738,12 @@ export class SwitchBotPlatform {
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
                 existingAccessory.context.connectionType = await this.connectionType(device);
                 existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Fan(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1767,17 +1767,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Fan(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createRobotVacuumCleaner(device) {
@@ -1808,12 +1808,12 @@ export class SwitchBotPlatform {
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
                 existingAccessory.context.connectionType = await this.connectionType(device);
                 existingAccessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new RobotVacuumCleaner(this, existingAccessory, device);
-                await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1847,17 +1847,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new RobotVacuumCleaner(this, accessory, device);
-            await this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
+            this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.deviceType} deviceId: ${device.deviceId}`);
         }
     }
     async createTV(device) {
@@ -1874,13 +1874,13 @@ export class SwitchBotPlatform {
             existingAccessory.displayName = device.configDeviceName
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
-            await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
             existingAccessory.context.connectionType = device.connectionType;
             this.api.updatePlatformAccessories([existingAccessory]);
             // create the accessory handler for the restored accessory
             // this is imported from `platformAccessory.ts`
             new TV(this, existingAccessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
         }
         else if (!device.hide_device && device.hubDeviceId) {
             // create a new accessory
@@ -1899,16 +1899,16 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new TV(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createIRFan(device) {
@@ -1927,13 +1927,13 @@ export class SwitchBotPlatform {
                 existingAccessory.displayName = device.configDeviceName
                     ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new IRFan(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -1956,17 +1956,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new IRFan(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createLight(device) {
@@ -1985,13 +1985,13 @@ export class SwitchBotPlatform {
                 existingAccessory.displayName = device.configDeviceName
                     ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Light(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2014,17 +2014,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Light(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createAirConditioner(device) {
@@ -2043,13 +2043,13 @@ export class SwitchBotPlatform {
                 existingAccessory.displayName = device.configDeviceName
                     ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new AirConditioner(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2072,17 +2072,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new AirConditioner(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createAirPurifier(device) {
@@ -2101,13 +2101,13 @@ export class SwitchBotPlatform {
                 existingAccessory.displayName = device.configDeviceName
                     ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new AirPurifier(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2130,17 +2130,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new AirPurifier(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createWaterHeater(device) {
@@ -2159,13 +2159,13 @@ export class SwitchBotPlatform {
                 existingAccessory.displayName = device.configDeviceName
                     ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new WaterHeater(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2188,17 +2188,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new WaterHeater(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createVacuumCleaner(device) {
@@ -2217,13 +2217,13 @@ export class SwitchBotPlatform {
                 existingAccessory.displayName = device.configDeviceName
                     ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new VacuumCleaner(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2246,17 +2246,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new VacuumCleaner(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createCamera(device) {
@@ -2275,13 +2275,13 @@ export class SwitchBotPlatform {
                 existingAccessory.displayName = device.configDeviceName
                     ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Camera(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2304,17 +2304,17 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Camera(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async createOthers(device) {
@@ -2333,13 +2333,13 @@ export class SwitchBotPlatform {
                 existingAccessory.displayName = device.configDeviceName
                     ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                     : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
-                await this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
+                this.infoLog(`Restoring existing accessory from cache: ${existingAccessory.displayName} deviceId: ${device.deviceId}`);
                 existingAccessory.context.connectionType = device.connectionType;
                 this.api.updatePlatformAccessories([existingAccessory]);
                 // create the accessory handler for the restored accessory
                 // this is imported from `platformAccessory.ts`
                 new Others(this, existingAccessory, device);
-                await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
+                this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${existingAccessory.UUID})`);
             }
             else {
                 this.unregisterPlatformAccessories(existingAccessory);
@@ -2362,27 +2362,27 @@ export class SwitchBotPlatform {
             accessory.context.connectionType = await this.connectionType(device);
             accessory.context.version = device.firmware ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
-            await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
+            this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
             // create the accessory handler for the newly create accessory
             // this is imported from `platformAccessory.ts`
             new Others(this, accessory, device);
-            await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
+            this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
             this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
-            await this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
+            this.debugLog(`Device not registered: ${device.deviceName} ${device.remoteType} deviceId: ${device.deviceId}`);
         }
     }
     async registerCurtains(device) {
         let registerWindowCovering;
         if (isCurtainDevice(device)) {
-            await this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds},x master: ${device.master}, group: ${device.group}, disable_group: ${device.disable_group}, connectionType: ${device.connectionType}`);
+            this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds},x master: ${device.master}, group: ${device.group}, disable_group: ${device.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.disable_group}, connectionType: ${device.connectionType}`);
+            this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, blindTiltDevicesIds: ${device.blindTiltDevicesIds}, master: ${device.master}, group: ${device.group}, disable_group: ${device.disable_group}, connectionType: ${device.connectionType}`);
             registerWindowCovering = await this.registerWindowCovering(device);
         }
         else {
@@ -2391,35 +2391,35 @@ export class SwitchBotPlatform {
         return registerWindowCovering;
     }
     async registerWindowCovering(device) {
-        await this.debugLog(`master: ${device.master}`);
+        this.debugLog(`master: ${device.master}`);
         let registerCurtain;
         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.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, device.group: ${device.group} connectionType; ${device.connectionType}`);
+            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else if (!device.master && device.disable_group) {
             registerCurtain = true;
-            await this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, disable_group: ${device.disable_group}, connectionType; ${device.connectionType}`);
-            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, disable_group: ${device.disable_group}, connectionType; ${device.connectionType}`);
+            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.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] device.master: ${device.master}, device.group: ${device.group} connectionType; ${device.connectionType}`);
+            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         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.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
+            this.debugLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] connectionType: ${device.connectionType}, group: ${device.group}`);
+            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}`);
         }
         else {
             registerCurtain = false;
-            await this.debugErrorLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] disable_group: ${device.disable_group}, device.master: ${device.master}, device.group: ${device.group}`);
-            await this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}, device.connectionType: ${device.connectionType}`);
+            this.debugErrorLog(`deviceName: ${device.deviceName} [${device.deviceType} Config] disable_group: ${device.disable_group}, device.master: ${device.master}, device.group: ${device.group}`);
+            this.debugWarnLog(`Device: ${device.deviceName} registerCurtains: ${registerCurtain}, device.connectionType: ${device.connectionType}`);
         }
         return registerCurtain;
     }
@@ -2442,7 +2442,7 @@ export class SwitchBotPlatform {
         }
         else {
             registerDevice = false;
-            await this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, hide_device: ${device.hide_device}, will not display in HomeKit`);
+            this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, hide_device: ${device.hide_device}, will not display in HomeKit`);
         }
         return registerDevice;
     }
@@ -2453,17 +2453,17 @@ export class SwitchBotPlatform {
             case 'Curtain3':
             case 'Blind Tilt':
                 registerDevice = await this.registerCurtains(device);
-                await this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
+                this.debugWarnLog(`Device: ${device.deviceName} ${device.deviceType} registerDevice: ${registerDevice}`);
                 break;
             default:
                 registerDevice = true;
-                await this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
+                this.debugWarnLog(`Device: ${device.deviceName} registerDevice: ${registerDevice}`);
         }
         if (registerDevice) {
-            await this.debugWarnLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will display in HomeKit`);
+            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`);
+            this.debugErrorLog(`Device: ${device.deviceName} connectionType: ${device.connectionType}, will not display in HomeKit`);
         }
         return registerDevice;
     }
@@ -2471,11 +2471,11 @@ export class SwitchBotPlatform {
         const { displayName } = accessory;
         const isExternal = device.external ?? false;
         if (isExternal) {
-            await this.debugWarnLog(`${displayName} External Accessory Mode`);
+            this.debugWarnLog(`${displayName} External Accessory Mode`);
             this.api.publishExternalAccessories(PLUGIN_NAME, [accessory]);
         }
         else {
-            await this.debugLog(`${displayName} External Accessory Mode: ${isExternal}`);
+            this.debugLog(`${displayName} External Accessory Mode: ${isExternal}`);
             this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
         }
     }
@@ -2519,10 +2519,10 @@ export class SwitchBotPlatform {
         };
         const message = messages[statusCode] ?? `Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`;
         if ([100, 200].includes(statusCode)) {
-            await this.debugLog(message);
+            this.debugLog(message);
         }
         else {
-            await this.errorLog(message);
+            this.errorLog(message);
         }
     }
     async retryRequest(deviceId, deviceMaxRetries, deviceDelayBetweenRetries) {
@@ -2532,14 +2532,14 @@ export class SwitchBotPlatform {
         while (retryCount < maxRetries) {
             try {
                 const { response, statusCode } = await this.switchBotAPI.getDeviceStatus(deviceId);
-                await this.debugLog(`response: ${JSON.stringify(response)}`);
+                this.debugLog(`response: ${JSON.stringify(response)}`);
                 return { response, statusCode };
             }
             catch (error) {
-                await this.errorLog(`Error making request: ${error.message}`);
+                this.errorLog(`Error making request: ${error.message}`);
             }
             retryCount++;
-            await this.debugLog(`Retry attempt ${retryCount} of ${maxRetries}`);
+            this.debugLog(`Retry attempt ${retryCount} of ${maxRetries}`);
             await sleep(delayBetweenRetries);
         }
         return { response: {
@@ -2555,17 +2555,17 @@ export class SwitchBotPlatform {
     async connectBLE(accessory, device) {
         try {
             queueScheduler.schedule(async () => this.switchBotBLE);
-            await this.debugLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${this.switchBotBLE}`);
+            this.debugLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${this.switchBotBLE}`);
             return this.switchBotBLE;
         }
         catch (e) {
-            await this.errorLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' not found, Error: ${e.message ?? e}`);
+            this.errorLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' not found, Error: ${e.message ?? e}`);
             return false;
         }
     }
     async getVersion() {
         const json = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
-        await this.debugLog(`Plugin Version: ${json.version}`);
+        this.debugLog(`Plugin Version: ${json.version}`);
         this.version = json.version;
         return json.version;
     }
@@ -2580,15 +2580,15 @@ export class SwitchBotPlatform {
             this.maxRetries = options.maxRetries || 3;
             platformConfig.maxRetries = this.maxRetries;
             if (!options.maxRetries) {
-                await this.debugWarnLog('Using Default Max Retries');
+                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');
+                this.debugWarnLog('Using Default Delay Between Retries');
             }
             if (Object.keys(platformConfig).length) {
-                await this.debugLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
+                this.debugLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
             }
             this.platformConfig = platformConfig;
         }
@@ -2597,15 +2597,15 @@ export class SwitchBotPlatform {
         this.debugMode = process.argv.includes('-D') ?? process.argv.includes('--debug');
         if (this.config.options?.logging === 'debug' || this.config.options?.logging === 'standard' || this.config.options?.logging === 'none') {
             this.platformLogging = this.config.options.logging;
-            await this.debugWarnLog(`Using Config Logging: ${this.platformLogging}`);
+            this.debugWarnLog(`Using Config Logging: ${this.platformLogging}`);
         }
         else if (this.debugMode) {
             this.platformLogging = 'debugMode';
-            await this.debugWarnLog(`Using ${this.platformLogging} Logging`);
+            this.debugWarnLog(`Using ${this.platformLogging} Logging`);
         }
         else {
             this.platformLogging = 'standard';
-            await this.debugWarnLog(`Using ${this.platformLogging} Logging`);
+            this.debugWarnLog(`Using ${this.platformLogging} Logging`);
         }
     }
     /**
@@ -2624,20 +2624,20 @@ export class SwitchBotPlatform {
             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)) {
-                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.`);
+                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;
-                    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`);
+                    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, '');
-                    await this.warnLog(`${name} Before: '${before}' After: '${value}'`);
+                    this.warnLog(`${name} Before: '${before}' After: '${value}'`);
                 }
                 // Ensure it starts and ends with an alphanumeric character
                 if (invalidStartEndPattern.test(value)) {
                     const before = value;
-                    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`);
+                    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, '');
-                    await this.warnLog(`${name} Before: '${before}' After: '${value}'`);
+                    this.warnLog(`${name} Before: '${before}' After: '${value}'`);
                 }
             }
             return value;