@switchbot/homebridge-switchbot 3.8.3-beta.3 → 3.8.3-beta.31

package/src/platform.ts

@@ -2,21 +2,14 @@
  *
  * platform.ts: @switchbot/homebridge-switchbot platform class.
  */
-import type { IncomingMessage, Server, ServerResponse } from 'node:http'
-import type { UrlObject } from 'node:url'
+import type { Server } from 'node:http'
 
 import type { API, DynamicPlatformPlugin, Logging, PlatformAccessory } from 'homebridge'
 import type { MqttClient } from 'mqtt'
-import type { Dispatcher } from 'undici'
 
 import type { devicesConfig, irDevicesConfig, options, SwitchBotPlatformConfig } from './settings.js'
-import type { blindTilt, curtain, curtain3, device } from './types/devicelist.js'
-import type { irdevice } from './types/irdevicelist.js'
 
-import { Buffer } from 'node:buffer'
-import crypto, { randomUUID } from 'node:crypto'
 import { readFileSync, writeFileSync } from 'node:fs'
-import { createServer } from 'node:http'
 import process from 'node:process'
 
 import asyncmqtt from 'async-mqtt'
@@ -24,11 +17,13 @@ import fakegato from 'fakegato-history'
 import { EveHomeKitTypes } from 'homebridge-lib/EveHomeKitTypes'
 /*
 * For Testing Locally:
-* import { SwitchBotModel } from '/Users/Shared/GitHub/OpenWonderLabs/node-switchbot/dist/index.js';
+* import type { blindTilt, curtain, curtain3, device, irdevice } from '/Users/Shared/GitHub/OpenWonderLabs/node-switchbot/dist/index.js';
+* import  { LogLevel, SwitchBotBLE, SwitchBotModel, SwitchBotOpenAPI } from '/Users/Shared/GitHub/OpenWonderLabs/node-switchbot/dist/index.js';
 */
-import { SwitchBot, SwitchBotModel } from 'node-switchbot'
+import type { blindTilt, curtain, curtain3, device, irdevice } from 'node-switchbot'
+
+import { LogLevel, SwitchBotBLE, SwitchBotModel, SwitchBotOpenAPI } from 'node-switchbot'
 import { queueScheduler } from 'rxjs'
-import { request } from 'undici'
 
 import { BlindTilt } from './device/blindtilt.js'
 import { Bot } from './device/bot.js'
@@ -57,7 +52,7 @@ import { Others } from './irdevice/other.js'
 import { TV } from './irdevice/tv.js'
 import { VacuumCleaner } from './irdevice/vacuumcleaner.js'
 import { WaterHeater } from './irdevice/waterheater.js'
-import { deleteWebhook, Devices, PLATFORM_NAME, PLUGIN_NAME, queryWebhook, setupWebhook, updateWebhook } from './settings.js'
+import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js'
 import { formatDeviceIdAsMac, isBlindTiltDevice, isCurtainDevice, sleep } from './utils.js'
 
 /**
@@ -85,6 +80,10 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
   mqttClient: MqttClient | null = null
   webhookEventListener: Server | null = null
 
+  // SwitchBot APIs
+  switchBotAPI!: SwitchBotOpenAPI
+  switchBotBLE!: SwitchBotBLE
+
   // External APIs
   public readonly eve: any
   public readonly fakegatoAPI: any
@@ -127,11 +126,44 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       this.verifyConfig()
       this.debugLog('Config OK')
     } catch (e: any) {
-      this.errorLog(`Verify Config, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug')
-      this.debugErrorLog(`Verify Config, Error: ${e}`)
+      this.errorLog(`Verify Config, Error Message: ${e.message ?? e}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug')
+      this.debugErrorLog(`Verify Config, Error: ${e.message ?? e}`)
       return
     }
 
+    // SwitchBot OpenAPI
+    this.switchBotAPI = new SwitchBotOpenAPI(this.config.credentials?.token, this.config.credentials?.secret)
+    // Listen for log events
+    if (!this.config.options?.disableLogsforOpenAPI) {
+      this.switchBotAPI.on('log', (log) => {
+        switch (log.level) {
+          case LogLevel.SUCCESS:
+            this.successLog(log.message)
+            break
+          case LogLevel.DEBUGSUCCESS:
+            this.debugSuccessLog(log.message)
+            break
+          case LogLevel.WARN:
+            this.warnLog(log.message)
+            break
+          case LogLevel.DEBUGWARN:
+            this.debugWarnLog(log.message)
+            break
+          case LogLevel.ERROR:
+            this.errorLog(log.message)
+            break
+          case LogLevel.DEBUGERROR:
+            this.debugErrorLog(log.message)
+            break
+          case LogLevel.DEBUG:
+            this.debugLog(log.message)
+            break
+          case LogLevel.INFO:
+          default:
+            this.infoLog(log.message)
+        }
+      })
+    }
     // import fakegato-history module and EVE characteristics
     this.fakegatoAPI = fakegato(api)
     this.eve = new EveHomeKitTypes(api)
@@ -152,25 +184,25 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
           await this.discoverDevices()
         }
       } catch (e: any) {
-        await this.errorLog(`Failed to Discover, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug')
-        await this.debugErrorLog(`Failed to Discover, Error: ${e}`)
+        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}`)
       }
     })
 
     try {
       this.setupMqtt()
     } catch (e: any) {
-      this.errorLog(`Setup MQTT, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug')
+      this.errorLog(`Setup MQTT, Error Message: ${e.message ?? e}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug')
     }
     try {
       this.setupwebhook()
     } catch (e: any) {
-      this.errorLog(`Setup Webhook, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug')
+      this.errorLog(`Setup Webhook, Error Message: ${e.message ?? e}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug')
     }
     try {
       this.setupBlE()
     } catch (e: any) {
-      this.errorLog(`Setup Platform BLE, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug')
+      this.errorLog(`Setup Platform BLE, Error Message: ${e.message ?? e}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug')
     }
   }
 
@@ -181,7 +213,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         this.mqttClient = await connectAsync(this.config.options?.mqttURL, this.config.options.mqttOptions || {})
         await this.debugLog('MQTT connection has been established successfully.')
         this.mqttClient.on('error', async (e: Error) => {
-          await this.errorLog(`Failed to publish MQTT messages. ${e}`)
+          await this.errorLog(`Failed to publish MQTT messages. ${e.message ?? e}`)
         })
         if (!this.config.options?.webhookURL) {
           // receive webhook events via MQTT
@@ -193,13 +225,13 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
               const context = JSON.parse(message.toString())
               this.webhookEventHandler[context.deviceMac]?.(context)
             } catch (e: any) {
-              await this.errorLog(`Failed to handle webhook event. Error:${e}`)
+              await this.errorLog(`Failed to handle webhook event. Error:${e.message ?? e}`)
             }
           })
         }
-      } catch (e) {
+      } catch (e: any) {
         this.mqttClient = null
-        await this.errorLog(`Failed to establish MQTT connection. ${e}`)
+        await this.errorLog(`Failed to establish MQTT connection. ${e.message ?? e}`)
       }
     }
   }
@@ -208,156 +240,94 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     // webhook configuration
     if (this.config.options?.webhookURL) {
       const url = this.config.options?.webhookURL
-
       try {
-        const xurl = new URL(url)
-        const port = Number(xurl.port)
-        const path = xurl.pathname
-        this.webhookEventListener = createServer((request: IncomingMessage, response: ServerResponse) => {
-          try {
-            if (request.url === path && request.method === 'POST') {
-              request.on('data', async (data) => {
-                try {
-                  const body = JSON.parse(data)
-                  await this.debugLog(`Received Webhook: ${JSON.stringify(body)}`)
-                  if (this.config.options?.mqttURL) {
-                    const mac = body.context.deviceMac?.toLowerCase().match(/[\s\S]{1,2}/g)?.join(':')
-                    const options = this.config.options?.mqttPubOptions || {}
-                    this.mqttClient?.publish(`homebridge-switchbot/webhook/${mac}`, `${JSON.stringify(body.context)}`, options)
-                  }
-                  this.webhookEventHandler[body.context.deviceMac]?.(body.context)
-                } catch (e: any) {
-                  await this.errorLog(`Failed to handle webhook event. Error:${e}`)
-                }
-              })
-              response.writeHead(200, { 'Content-Type': 'text/plain' })
-              response.end('OK')
-            }
-            // else {
-            //   response.writeHead(403, {'Content-Type': 'text/plain'});
-            //   response.end(`NG`);
-            // }
-          } catch (e: any) {
-            this.errorLog(`Failed to handle webhook event. Error:${e}`)
+        this.switchBotAPI.setupWebhook(url)
+        // Listen for webhook events
+        this.switchBotAPI.on('webhookEvent', (body) => {
+          if (this.config.options?.mqttURL) {
+            const mac = body.context.deviceMac?.toLowerCase().match(/[\s\S]{1,2}/g)?.join(':')
+            const options = this.config.options?.mqttPubOptions || {}
+            this.mqttClient?.publish(`homebridge-switchbot/webhook/${mac}`, `${JSON.stringify(body.context)}`, options)
           }
-        }).listen(port || 80)
-      } catch (e: any) {
-        await this.errorLog(`Failed to create webhook listener. Error:${e.message}`)
-        return
-      }
-
-      try {
-        const { body, statusCode } = await request(setupWebhook, {
-          method: 'POST',
-          headers: this.generateHeaders(),
-          body: JSON.stringify({
-            action: 'setupWebhook',
-            url,
-            deviceList: 'ALL',
-          }),
+          this.webhookEventHandler[body.context.deviceMac]?.(body.context)
         })
-        const response: any = await body.json()
-        await this.debugLog(`setupWebhook: url:${url}, body:${JSON.stringify(response)}, statusCode:${statusCode}`)
-        if (statusCode !== 200 || response?.statusCode !== 100) {
-          await this.errorLog(`Failed to configure webhook. Existing webhook well be overridden. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`)
-        }
       } catch (e: any) {
-        await this.errorLog(`Failed to configure webhook. Error: ${e.message}`)
-      }
-
-      try {
-        const { body, statusCode } = await request(updateWebhook, {
-          method: 'POST',
-          headers: this.generateHeaders(),
-          body: JSON.stringify({
-            action: 'updateWebhook',
-            config: {
-              url,
-              enable: true,
-            },
-          }),
-        })
-        const response: any = await body.json()
-        await this.debugLog(`updateWebhook: url:${url}, body:${JSON.stringify(response)}, statusCode:${statusCode}`)
-        if (statusCode !== 200 || response?.statusCode !== 100) {
-          await this.errorLog(`Failed to update webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`)
-        }
-      } catch (e: any) {
-        await this.errorLog(`Failed to update webhook. Error:${e.message}`)
-      }
-
-      try {
-        const { body, statusCode } = await request(queryWebhook, {
-          method: 'POST',
-          headers: this.generateHeaders(),
-          body: JSON.stringify({
-            action: 'queryUrl',
-          }),
-        })
-        const response: any = await body.json()
-        await this.debugLog(`queryWebhook: body:${JSON.stringify(response)}`)
-        await this.debugLog(`queryWebhook: statusCode:${statusCode}`)
-        if (statusCode !== 200 || response?.statusCode !== 100) {
-          await this.errorLog(`Failed to query webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`)
-        } else {
-          await this.infoLog(`Listening webhook on ${response?.body?.urls[0]}`)
-        }
-      } catch (e: any) {
-        await this.errorLog(`Failed to query webhook. Error:${e}`)
+        await this.errorLog(`Failed to setup webhook. Error:${e.message ?? e}`)
       }
 
       this.api.on('shutdown', async () => {
         try {
-          const { body, statusCode } = await request(deleteWebhook, {
-            method: 'POST',
-            headers: this.generateHeaders(),
-            body: JSON.stringify({
-              action: 'deleteWebhook',
-              url,
-            }),
-          })
-          const response: any = await body.json()
-          await this.debugLog(`deleteWebhook: url:${url}, body:${JSON.stringify(response)}, statusCode:${statusCode}`)
-          if (statusCode !== 200 || response?.statusCode !== 100) {
-            await this.errorLog(`Failed to delete webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`)
-          } else {
-            await this.infoLog('Unregistered webhook to close listening.')
-          }
+          this.switchBotAPI.deleteWebhook(url)
         } catch (e: any) {
-          await this.errorLog(`Failed to delete webhook. Error:${e.message}`)
+          await this.errorLog(`Failed to delete webhook. Error:${e.message ?? e}`)
         }
       })
     }
   }
 
   async setupBlE() {
+    this.switchBotBLE = new SwitchBotBLE()
+    // Listen for log events
+    if (!this.config.options?.disableLogsforBLE) {
+      this.switchBotBLE.on('log', (log) => {
+        switch (log.level) {
+          case LogLevel.SUCCESS:
+            this.successLog(log.message)
+            break
+          case LogLevel.DEBUGSUCCESS:
+            this.debugSuccessLog(log.message)
+            break
+          case LogLevel.WARN:
+            this.warnLog(log.message)
+            break
+          case LogLevel.DEBUGWARN:
+            this.debugWarnLog(log.message)
+            break
+          case LogLevel.ERROR:
+            this.errorLog(log.message)
+            break
+          case LogLevel.DEBUGERROR:
+            this.debugErrorLog(log.message)
+            break
+          case LogLevel.DEBUG:
+            this.debugLog(log.message)
+            break
+          case LogLevel.INFO:
+          default:
+            this.infoLog(log.message)
+        }
+      })
+    }
     if (this.config.options?.BLE) {
       await this.debugLog('setupBLE')
-      const switchbot = new SwitchBot()
-      if (switchbot === undefined) {
-        await this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`)
+      if (this.switchBotBLE === undefined) {
+        await 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...')
-          await switchbot.startScan()
+          try {
+            await this.switchBotBLE.startScan()
+          } catch (e: any) {
+            await this.errorLog(`Failed to start BLE scanning. Error:${e.message ?? e}`)
+          }
           // Set an event handler to monitor advertisement packets
-          switchbot.onadvertisement = async (ad: any) => {
+          this.switchBotBLE.onadvertisement = async (ad: any) => {
             try {
               this.bleEventHandler[ad.address]?.(ad.serviceData)
             } catch (e: any) {
-              await this.errorLog(`Failed to handle BLE event. Error:${e}`)
+              await this.errorLog(`Failed to handle BLE event. Error:${e.message ?? e}`)
             }
           }
         })()
 
         this.api.on('shutdown', async () => {
           try {
-            switchbot.stopScan()
+            // this.switchBotBLE.stopScan()
             await this.infoLog('Stopped BLE scanning to close listening.')
           } catch (e: any) {
-            await this.errorLog(`Failed to stop Platform BLE scanning. Error:${e.message}`)
+            await this.errorLog(`Failed to stop Platform BLE scanning. Error:${e.message ?? e}`)
           }
         })
       }
@@ -527,26 +497,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       writeFileSync(this.api.user.configPath(), JSON.stringify(currentConfig, null, 4))
       await this.verifyConfig()
     } catch (e: any) {
-      await this.errorLog(`Update Token: ${e}`)
-    }
-  }
-
-  generateHeaders = () => {
-    const t = `${Date.now()}`
-    const nonce = randomUUID()
-    const data = this.config.credentials?.token + t + nonce
-    const signTerm = crypto
-      .createHmac('sha256', this.config.credentials?.secret)
-      .update(Buffer.from(data, 'utf-8'))
-      .digest()
-    const sign = signTerm.toString('base64')
-
-    return {
-      'Authorization': this.config.credentials?.token,
-      'sign': sign,
-      'nonce': nonce,
-      't': t,
-      'Content-Type': 'application/json',
+      await this.errorLog(`Update Token: ${e.message ?? e}`)
     }
   }
 
@@ -565,23 +516,20 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
 
     while (retryCount < maxRetries) {
       try {
-        const { body, statusCode } = await request(Devices, { headers: this.generateHeaders() })
-        await this.debugWarnLog(`statusCode: ${statusCode}`)
-        const devicesAPI: any = await body.json()
-        await this.debugWarnLog(`devicesAPI: ${JSON.stringify(devicesAPI)}`)
-
-        if (this.isSuccessfulResponse(statusCode, devicesAPI.statusCode)) {
-          await this.handleDevices(devicesAPI.body.deviceList)
-          await this.handleIRDevices(devicesAPI.body.infraredRemoteList)
+        const { response, statusCode } = await this.switchBotAPI.getDevices()
+        await 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 : [])
           break
         } else {
-          await this.handleErrorResponse(statusCode, devicesAPI.statusCode, retryCount, maxRetries, delayBetweenRetries)
+          await this.handleErrorResponse(statusCode, retryCount, maxRetries, delayBetweenRetries)
           retryCount++
         }
       } catch (e: any) {
         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}`)
+        await this.debugErrorLog(`Failed to Discover Devices, Error: ${e.message ?? e}`)
       }
     }
   }
@@ -608,8 +556,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     }
   }
 
-  private isSuccessfulResponse(statusCode: number, apiStatusCode: number): boolean {
-    return (statusCode === 200 || statusCode === 100) && (apiStatusCode === 200 || apiStatusCode === 100)
+  private isSuccessfulResponse(apiStatusCode: number): boolean {
+    return (apiStatusCode === 200 || apiStatusCode === 100)
   }
 
   private async handleDevices(deviceLists: any[]) {
@@ -674,11 +622,10 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     })
   }
 
-  private async handleErrorResponse(statusCode: number, apiStatusCode: number, retryCount: number, maxRetries: number, delayBetweenRetries: number) {
-    await this.statusCode(statusCode)
+  private async handleErrorResponse(apiStatusCode: number, retryCount: number, maxRetries: number, delayBetweenRetries: number) {
     await this.statusCode(apiStatusCode)
-    if (statusCode === 500) {
-      this.infoLog(`statusCode: ${statusCode} Attempt ${retryCount + 1} of ${maxRetries}`)
+    if (apiStatusCode === 500) {
+      this.infoLog(`statusCode: ${apiStatusCode} Attempt ${retryCount + 1} of ${maxRetries}`)
       await sleep(delayBetweenRetries)
     }
   }
@@ -2639,18 +2586,15 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     }
   }
 
-  async retryRequest(deviceMaxRetries: number, deviceDelayBetweenRetries: number, url: string | URL | UrlObject, options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>): Promise<{ body: any, statusCode: number }> {
+  async retryRequest(deviceId: string, deviceMaxRetries: number, deviceDelayBetweenRetries: number): Promise<{ response: any, statusCode: number }> {
     let retryCount = 0
     const maxRetries = deviceMaxRetries
     const delayBetweenRetries = deviceDelayBetweenRetries
     while (retryCount < maxRetries) {
       try {
-        const { body, statusCode } = await request(url, options)
-        if (statusCode === 200 || statusCode === 100) {
-          return { body, statusCode }
-        } else {
-          await this.debugLog(`Received status code: ${statusCode}`)
-        }
+        const { response, statusCode } = await this.switchBotAPI.getDeviceStatus(deviceId)
+        await this.debugLog(`response: ${JSON.stringify(response)}`)
+        return { response, statusCode }
       } catch (error: any) {
         await this.errorLog(`Error making request: ${error.message}`)
       }
@@ -2658,18 +2602,17 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       await this.debugLog(`Retry attempt ${retryCount} of ${maxRetries}`)
       await sleep(delayBetweenRetries)
     }
-    return { body: null, statusCode: -1 }
+    return { response: null, statusCode: 500 }
   }
 
   // BLE Connection
   async connectBLE(accessory: PlatformAccessory, device: device & devicesConfig): Promise<any> {
     try {
-      const switchbot = new SwitchBot()
-      queueScheduler.schedule(async () => switchbot)
-      await this.debugLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${switchbot}`)
-      return switchbot
+      queueScheduler.schedule(async () => this.switchBotBLE)
+      await this.debugLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${this.switchBotBLE}`)
+      return this.switchBotBLE
     } catch (e: any) {
-      await this.errorLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' not found, Error: ${e}`)
+      await this.errorLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' not found, Error: ${e.message ?? e}`)
       return false
     }
   }

package/src/settings.ts

@@ -4,10 +4,11 @@
  */
 import type { IClientOptions } from 'async-mqtt'
 import type { PlatformConfig } from 'homebridge'
-import type { SwitchBotBLEModel, SwitchBotBLEModelFriendlyName, SwitchBotBLEModelName } from 'node-switchbot'
-
-import type { device } from './types/devicelist'
-import type { irdevice } from './types/irdevicelist'
+/*
+* For Testing Locally:
+* import type { device, irdevice, SwitchBotBLEModel, SwitchBotBLEModelFriendlyName, SwitchBotBLEModelName } from '/Users/Shared/GitHub/OpenWonderLabs/node-switchbot/dist/index.js';
+*/
+import type { device, irdevice, SwitchBotBLEModel, SwitchBotBLEModelFriendlyName, SwitchBotBLEModelName } from 'node-switchbot'
 /**
  * This is the name of the platform that users will use to register the plugin in the Homebridge config.json
  */
@@ -63,6 +64,9 @@ export interface options {
   mqttOptions?: IClientOptions
   mqttPubOptions?: IClientOptions
   BLE?: boolean
+  discoverBLE?: boolean
+  disableLogsforBLE?: boolean
+  disableLogsforOpenAPI?: boolean
   webhookURL?: string
   maxRetries?: number
   delayBetweenRetries?: number

package/src/utils.ts

@@ -2,8 +2,9 @@
  *
  * util.ts: @switchbot/homebridge-switchbot platform class.
  */
+import type { blindTilt, curtain, curtain3, device } from 'node-switchbot'
+
 import type { devicesConfig } from './settings.js'
-import type { blindTilt, curtain, curtain3, device } from './types/devicelist.js'
 
 export enum SwitchBotModel {
   HubMini = 'W0202200',