@switchbot/homebridge-switchbot 5.0.0-beta.8 → 5.0.0-beta.80

package/src/platform.ts

@@ -0,0 +1,395 @@
+import type { API, Logger, PlatformConfig } from 'homebridge'
+import { SwitchBotClient } from './switchbotClient.js'
+import { createDevice } from './deviceFactory.js'
+import type { SwitchBotPluginConfig } from './settings.js'
+import { PLUGIN_NAME, PLATFORM_NAME } from './settings.js'
+
+// Which device types should prefer Matter if available
+const DEVICE_MATTER_SUPPORTED: Record<string, boolean> = {
+  bot: false,
+  curtain: true,
+  fan: true,
+  light: true,
+  lightstrip: true,
+  motion: true,
+  contact: true,
+  vacuum: false,
+  lock: true,
+  humidifier: true,
+  temperature: true,
+}
+
+export class SwitchBotHAPPlatform {
+  api: API | undefined
+  log: Logger
+  config: SwitchBotPluginConfig
+  devices: any[] = []
+  // cached accessories restored by Homebridge
+  accessories: Map<string, any>
+
+  constructor(log: Logger, config: PlatformConfig, api?: API) {
+    this.log = log
+    this.config = (config as any) ?? {}
+    this.api = api
+    this.accessories = new Map()
+    this.log.info('SwitchBot HAP platform initialized')
+
+    // Create/shared SwitchBot client and attach to config so child devices reuse it.
+    try {
+      const client = new SwitchBotClient(this.config)
+      void client.init()
+      ;(this.config as any)._client = client
+    } catch (e) {
+      this.log.debug('Failed to create shared SwitchBot client', e)
+    }
+
+    // Create/shared SwitchBot client and attach to config so child devices reuse it.
+    try {
+      const client = new SwitchBotClient(this.config)
+      void client.init()
+      ;(this.config as any)._client = client
+    } catch (e) {
+      this.log.debug('Failed to create shared SwitchBot client', e)
+    }
+
+    // Wait for Homebridge to finish launching to create/register accessories
+    if (this.api && typeof (this.api as any).on === 'function') {
+      ;(this.api as any).on('didFinishLaunching', () => {
+        void this.loadDevices()
+      })
+    } else {
+      void this.loadDevices()
+    }
+  }
+
+  async loadDevices() {
+    const devices = (this.config as any)?.devices ?? []
+    for (const raw of devices) {
+      // Normalize config keys from UI schema to internal shape
+      const d: any = {
+        id: raw.deviceId ?? raw.id,
+        name: raw.configDeviceName ?? raw.name,
+        type: raw.configDeviceType ?? raw.type ?? raw.deviceType ?? 'unknown',
+        _raw: raw,
+      }
+
+      const type: string = d.type
+      const matterSupported = !!DEVICE_MATTER_SUPPORTED[(type || '').toLowerCase()]
+      const useMatter = !!this.config.enableMatter && matterSupported && !!this.config.preferMatter
+
+      try {
+        const created = await createDevice({ id: d.id, type, name: d.name }, this.config, useMatter)
+        this.devices.push(created)
+        // Prefer Matter: try registering to the Matter child bridge first.
+        let matterRegistered = false
+        if (useMatter) {
+          this.log.info(`Attempting Matter registration for ${d.id} (${type})`)
+          // If Homebridge Matter APIs are available, register the accessory
+          try {
+            const matterApi = (this.api as any)?.matter
+            if (this.api?.isMatterAvailable?.() && this.api?.isMatterEnabled?.() && matterApi && typeof matterApi.registerPlatformAccessories === 'function') {
+              const createdDesc = created.createAccessory?.(this.api) || { id: d.id, name: d.name || type }
+              const uuid = matterApi.uuid.generate(`${d.id}`)
+              const accessory: any = {
+                uuid,
+                displayName: createdDesc.name || d.name || type,
+                context: { deviceId: d.id, type: type, _created: true },
+              }
+              try {
+                await matterApi.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory])
+                this.accessories.set(uuid, accessory)
+                matterRegistered = true
+                this.log.info(`Registered Matter accessory ${d.id} (${type}) with uuid=${uuid}`)
+              } catch (e) {
+                this.log.warn('Failed to register Matter accessory with Homebridge matter API', e)
+              }
+            } else {
+              this.log.info('Homebridge Matter API not available or not enabled; will fallback to HAP')
+            }
+          } catch (e) {
+            this.log.warn('Matter registration attempt failed', e)
+          }
+        }
+
+        // If Matter wasn't registered (either not supported, API missing, or registration failed), fall back to HAP registration.
+        if (!matterRegistered && this.api && (this.api as any).hap) {
+          // Basic HAP accessory creation using homebridge API when available
+          try {
+            const hap = (this.api as any).hap
+            const uuid = hap.uuid.generate(`${d.id}`)
+            // Reuse cached accessory if available by uuid
+            let accessory: any = this.accessories.get(uuid)
+            // If not found by uuid, attempt to find by stored deviceId in accessory.context
+            if (!accessory) {
+              for (const [k, a] of Array.from(this.accessories.entries())) {
+                try {
+                  if (a && a.context && a.context.deviceId === d.id) {
+                    accessory = a
+                    break
+                  }
+                } catch (e) {
+                  // ignore
+                }
+              }
+            }
+
+            if (!accessory) {
+              accessory = new (this.api as any).platformAccessory(d.name || type, uuid)
+              // Store device metadata on accessory.context for persistence across restarts
+              try {
+                accessory.context = accessory.context || {}
+                accessory.context.deviceId = d.id
+                accessory.context.type = type
+              } catch (e) {
+                // ignore context failures
+              }
+              // Register new accessory with Homebridge so it's cached
+              try {
+                ;(this.api as any).registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory])
+              } catch (e) {
+                // older API variations may require different registration; ignore if unavailable
+              }
+              this.accessories.set(uuid, accessory)
+            } else {
+              // ensure context includes deviceId (in case restored accessory lacked it)
+              try {
+                accessory.context = accessory.context || {}
+                accessory.context.deviceId = accessory.context.deviceId || d.id
+                accessory.context.type = accessory.context.type || type
+              } catch (e) {
+                // ignore
+              }
+            }
+            // Add basic service descriptor from device
+            const accDesc = created.createAccessory?.(this.api)
+            if (accDesc && accDesc.services) {
+              for (const s of accDesc.services) {
+                const Service = hap.Service[s.type] || hap.Service[s.type]
+                if (!Service) continue
+                const service = accessory.getService(Service) || accessory.addService(Service)
+                for (const [charName, getterSetterRaw] of Object.entries(s.characteristics || {})) {
+                  const getterSetter: any = getterSetterRaw
+                  const Characteristic = (hap.Characteristic as any)[charName]
+                  if (!Characteristic) continue
+                  // Apply characteristic props if provided (min/max/step)
+                  if (getterSetter && getterSetter.props) {
+                    try {
+                      service.getCharacteristic(Characteristic).setProps(getterSetter.props)
+                    } catch (e) {
+                      // ignore setProps failures on older HAP implementations
+                    }
+                  }
+
+                  // Wire simple get/set handlers if provided
+                  if (getterSetter && typeof getterSetter.get === 'function') {
+                    service.getCharacteristic(Characteristic).onGet(getterSetter.get)
+                  }
+                  if (getterSetter && typeof getterSetter.set === 'function') {
+                    service.getCharacteristic(Characteristic).onSet(getterSetter.set)
+                  }
+                }
+              }
+            }
+            this.log.info(`Created/updated HAP accessory ${d.id} (${type})`)
+          } catch (e) {
+            this.log.warn('HAP accessory creation failed', e)
+          }
+        } else if (!matterRegistered) {
+          this.log.info(`Created HAP descriptor for ${d.id} (${type}) (API not available to register)`)
+        }
+      } catch (e) {
+        this.log.error(`Failed to create device ${d.id}:`, e as any)
+      }
+    }
+  }
+
+  // Example lifecycle method called by Homebridge
+  async configureAccessory(accessory: any) {
+    // Homebridge calls this for restored cached accessories — keep a reference.
+    try {
+      const uuid = accessory.UUID || accessory.UUID
+      this.accessories.set(uuid, accessory)
+      this.log.info(`Restored cached accessory ${accessory.displayName || uuid}`)
+    } catch (e) {
+      this.log.warn('configureAccessory failed to restore accessory', e)
+    }
+  }
+
+  // Called by Homebridge when a cached Matter accessory is restored
+  configureMatterAccessory?(accessory: any) {
+    try {
+      const uuid = accessory.uuid || accessory.UUID || accessory.uuid
+      this.accessories.set(uuid, accessory)
+      this.log.info(`Restored cached Matter accessory ${accessory.displayName || uuid}`)
+    } catch (e) {
+      this.log.warn('configureMatterAccessory failed to restore accessory', e)
+    }
+  }
+}
+
+// Matter platform implementation (placeholder)
+export class SwitchBotMatterPlatform {
+  api: API | undefined
+  log: Logger
+  config: SwitchBotPluginConfig
+  devices: any[] = []
+  accessories: Map<string, any>
+
+  constructor(log: Logger, config: PlatformConfig, api?: API) {
+    this.log = log
+    this.config = (config as any) ?? {}
+    this.api = api
+    this.accessories = new Map()
+    this.log.info('SwitchBot Matter platform initialized')
+
+    if (this.api && typeof (this.api as any).on === 'function') {
+      ;(this.api as any).on('didFinishLaunching', () => {
+        ;(async () => {
+          // After launch, perform discovery (if any) and register Matter accessories
+          try {
+            await this.loadDevices()
+            if ((this.api as any).isMatterAvailable?.() && (this.api as any).isMatterEnabled?.() && (this.api as any).matter && typeof (this.api as any).matter.registerPlatformAccessories === 'function') {
+              try {
+                await (this as any).registerMatterAccessories?.()
+              } catch (e) {
+                this.log.warn('registerMatterAccessories failed', e)
+              }
+            }
+          } catch (e) {
+            this.log.warn('Error during Matter platform startup', e)
+          }
+        })()
+      })
+    } else {
+      void this.loadDevices()
+    }
+    // Create/shared SwitchBot client and attach to config so child devices reuse it.
+    try {
+      const client = new SwitchBotClient(this.config)
+      void client.init()
+      ;(this.config as any)._client = client
+    } catch (e) {
+      this.log.debug('Failed to create shared SwitchBot client', e)
+    }
+  }
+
+  async loadDevices() {
+    const devices = (this.config as any)?.devices ?? []
+    for (const raw of devices) {
+      // Normalize config keys produced by the UI schema
+      const d: any = {
+        id: raw.deviceId ?? raw.id,
+        name: raw.configDeviceName ?? raw.name,
+        type: raw.configDeviceType ?? raw.type ?? raw.deviceType ?? 'unknown',
+        _raw: raw,
+      }
+
+      const type: string = d.type
+      const matterSupported = !!DEVICE_MATTER_SUPPORTED[(type || '').toLowerCase()]
+      const useMatter = !!this.config.enableMatter && matterSupported
+      try {
+        const created = await createDevice({ id: d.id, type, name: d.name }, this.config, useMatter)
+        this.devices.push(created)
+        if (useMatter) {
+          this.log.info(`Prepared Matter accessory for ${d.id} (${type})`)
+        } else {
+          this.log.info(`Skipping Matter for ${d.id} (${type}) - not supported`)
+        }
+      } catch (e) {
+        this.log.error(`Failed to create Matter device ${d.id}:`, e as any)
+      }
+    }
+  }
+
+  async configureAccessory(accessory: any) {
+    try {
+      const uuid = accessory.UUID || accessory.UUID
+      this.accessories.set(uuid, accessory)
+      this.log.info(`Restored cached Matter accessory ${accessory.displayName || uuid}`)
+    } catch (e) {
+      this.log.warn('configureAccessory failed to restore Matter accessory', e)
+    }
+  }
+
+  // Homebridge calls this when restoring cached Matter accessories
+  configureMatterAccessory(accessory: any) {
+    try {
+      const uuid = accessory.uuid || accessory.UUID || accessory.uuid
+      this.accessories.set(uuid, accessory)
+      this.log.info(`Restored cached Matter accessory ${accessory.displayName || uuid}`)
+    } catch (e) {
+      this.log.warn('configureMatterAccessory failed to restore Matter accessory', e)
+    }
+  }
+
+  // Register serialized Matter accessories via Homebridge Matter API
+  async registerMatterAccessories() {
+    if (!this.api) return
+    const matterApi = (this.api as any).matter
+    if (!matterApi || typeof matterApi.registerPlatformAccessories !== 'function') {
+      this.log.info('Homebridge Matter API not available; skipping Matter accessory registration')
+      return
+    }
+
+    const devices = (this.config as any)?.devices ?? []
+    const accessoriesToRegister: any[] = []
+
+    for (const d of devices) {
+      const type: string = d.type || d.deviceType || 'unknown'
+      const matterSupported = !!DEVICE_MATTER_SUPPORTED[(type || '').toLowerCase()]
+      const useMatter = !!this.config.enableMatter && matterSupported
+      if (!useMatter) continue
+
+      try {
+        const created = await createDevice({ id: d.id, type, name: d.name }, this.config, true)
+        const createdDesc = created.createAccessory?.(this.api) || { id: d.id, name: d.name || type }
+        const uuid = matterApi.uuid.generate(`${d.id}`)
+        // Try to find existing restored accessory by deviceId
+        let existing: any | undefined
+        for (const [k, a] of Array.from(this.accessories.entries())) {
+          try {
+            if (a && a.context && a.context.deviceId === d.id) {
+              existing = a
+              break
+            }
+          } catch (e) {
+            // ignore
+          }
+        }
+
+        if (existing) {
+          // Ensure context and displayName are up to date
+          existing.context = existing.context || {}
+          existing.context.deviceId = existing.context.deviceId || d.id
+          existing.context.type = existing.context.type || type
+          existing.displayName = createdDesc.name || d.name || type
+          accessoriesToRegister.push(existing)
+          this.accessories.set(existing.uuid || uuid, existing)
+        } else {
+          const serialized: any = {
+            uuid,
+            displayName: createdDesc.name || d.name || type,
+            context: { deviceId: d.id, type, created: true },
+          }
+          accessoriesToRegister.push(serialized)
+          this.accessories.set(uuid, serialized)
+        }
+      } catch (e) {
+        this.log.warn(`Failed to prepare Matter accessory for ${d.id} (${type})`, e)
+      }
+    }
+
+    if (accessoriesToRegister.length > 0) {
+      try {
+        await matterApi.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessoriesToRegister)
+        this.log.info(`Registered ${accessoriesToRegister.length} Matter accessory(ies) with Homebridge`) 
+      } catch (e) {
+        this.log.warn('Failed to register Matter accessories', e)
+      }
+    } else {
+      this.log.info('No Matter accessories to register')
+    }
+  }
+}
+
+export default SwitchBotHAPPlatform

package/src/settings.ts

@@ -1,283 +1,18 @@
-/* Copyright(C) 2017-2024, donavanbecker (https://github.com/donavanbecker). All rights reserved.
- *
- * settings.ts: @switchbot/homebridge-switchbot platform class.
- */
-import type { IClientOptions } from 'async-mqtt'
-import type { PlatformConfig } from 'homebridge'
-/*
-* 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, SwitchBotModel } from 'node-switchbot'
-/**
- * This is the name of the platform that users will use to register the plugin in the Homebridge config.json
- */
-export const PLATFORM_NAME = 'SwitchBot'
-
-/**
- * This must match the name of your plugin as defined the package.json
- */
 export const PLUGIN_NAME = '@switchbot/homebridge-switchbot'
+export const PLATFORM_NAME = 'SwitchBot'
 
-// Config
-export interface SwitchBotPlatformConfig extends PlatformConfig {
-  credentials?: credentials
-  options?: options
-}
-interface credentials {
-  token?: string
-  secret?: string
-  notice?: string
-}
-
-export interface options {
-  devices?: devicesConfig[]
-  deviceConfig?: { [deviceType: string]: devicesConfig }
-  irdevices?: irDevicesConfig[]
-  irdeviceConfig?: { [remoteType: string]: irDevicesConfig }
-  allowInvalidCharacters?: boolean
-  mqttURL?: string
-  mqttOptions?: IClientOptions
-  mqttPubOptions?: IClientOptions
-  BLE?: boolean
-  discoverBLE?: boolean
-  disableLogsforBLE?: boolean
-  disableLogsforOpenAPI?: boolean
-  hostname?: string
-  webhookURL?: string
-  maxRetries?: number
-  delayBetweenRetries?: number
-  refreshRate?: number
-  updateRate?: number
-  pushRate?: number
-  logging?: string
-};
-
-export type devicesConfig = botConfig | relaySwitch1Config | relaySwitch1PMConfig | meterConfig | meterProConfig | indoorOutdoorSensorConfig | humidifierConfig | curtainConfig | blindTiltConfig | contactConfig | motionConfig | waterDetectorConfig | plugConfig | colorBulbConfig | stripLightConfig | ceilingLightConfig | lockConfig | hubConfig
-
-export interface BaseDeviceConfig extends device {
-  bleMac?: string
-  model: SwitchBotModel
-  bleModel: SwitchBotBLEModel
-  bleModelName: SwitchBotBLEModelName
-  bleModelFriednlyName: SwitchBotBLEModelFriendlyName
-  configDeviceType: string
-  configDeviceName?: string
-  deviceId: string
-  external?: boolean
-  refreshRate?: number
-  updateRate?: number
-  pushRate?: number
-  firmware?: string
-  logging?: string
-  connectionType?: string
-  customBLEaddress?: string
-  scanDuration?: number
-  hide_device?: boolean
-  offline?: boolean
-  maxRetry?: number
-  maxRetries?: number
-  delayBetweenRetries?: number
-  disableCaching?: boolean
-  disablePlatformBLE?: boolean
-  mqttURL?: string
-  mqttOptions?: IClientOptions
-  mqttPubOptions?: IClientOptions
-  history?: boolean
-  webhook?: boolean
+export interface SwitchBotPluginConfig {
+  openApiToken?: string
+  openApiSecret?: string
+  preferMatter?: boolean
+  enableMatter?: boolean
+  // other plugin-specific configuration
+  [key: string]: any
 }
 
-export interface botConfig extends BaseDeviceConfig {
-  configDeviceType: 'Bot'
-  mode?: string
-  type: string
-  doublePress?: number
-  pushRatePress?: number
-  allowPush?: boolean
-  multiPress?: boolean
-};
-
-export interface relaySwitch1Config extends BaseDeviceConfig {
-  configDeviceType: 'Relay Switch 1'
-  type: string
-  allowPush?: boolean
-};
-
-export interface relaySwitch1PMConfig extends BaseDeviceConfig {
-  configDeviceType: 'Relay Switch 1PM'
-  type: string
-  allowPush?: boolean
-};
-
-export interface meterConfig extends BaseDeviceConfig {
-  configDeviceType: 'Meter' | 'MeterPlus'
-  hide_temperature?: boolean
-  convertUnitTo?: string
-  hide_humidity?: boolean
-};
-
-export interface meterProConfig extends BaseDeviceConfig {
-  configDeviceType: 'Meter Pro' | 'MeterPro(CO2)'
-  hide_temperature?: boolean
-  convertUnitTo?: string
-  hide_humidity?: boolean
-  hide_co2?: boolean
-};
-
-export interface indoorOutdoorSensorConfig extends BaseDeviceConfig {
-  configDeviceType: 'WoIOSensor'
-  hide_temperature?: boolean
-  convertUnitTo?: string
-  hide_humidity?: boolean
-};
-
-export interface humidifierConfig extends BaseDeviceConfig {
-  configDeviceType: 'Humidifier' | 'Humidifier2'
-  hide_temperature?: boolean
-  convertUnitTo?: string
-  set_minStep?: number
-};
-
-export interface curtainConfig extends BaseDeviceConfig {
-  configDeviceType: 'Curtain' | 'Curtain3' | 'WoRollerShade' | 'Roller Shade'
-  disable_group?: boolean
-  hide_lightsensor?: boolean
-  set_minLux?: number
-  set_maxLux?: number
-  set_max?: number
-  set_min?: number
-  set_minStep?: number
-  setCloseMode?: string
-  setOpenMode?: string
-  silentModeSwitch?: boolean
-};
-
-export interface blindTiltConfig extends BaseDeviceConfig {
-  configDeviceType: 'Blind Tilt'
-  disable_group?: boolean
-  mapping?: string
-  hide_lightsensor?: boolean
-  set_minLux?: number
-  set_maxLux?: number
-  set_max?: number
-  set_min?: number
-  set_minStep?: number
-  setCloseMode?: string
-  setOpenMode?: string
-  silentModeSwitch?: boolean
-};
-
-export interface contactConfig extends BaseDeviceConfig {
-  configDeviceType: 'Contact Sensor'
-  hide_lightsensor?: boolean
-  set_minLux?: number
-  set_maxLux?: number
-  hide_motionsensor?: boolean
-};
-
-export interface motionConfig extends BaseDeviceConfig {
-  configDeviceType: 'Motion Sensor'
-  hide_lightsensor?: boolean
-  set_minLux?: number
-  set_maxLux?: number
-};
-
-export interface waterDetectorConfig extends BaseDeviceConfig {
-  configDeviceType: 'Water Detector'
-  hide_leak?: boolean
-  dry?: boolean
-};
-
-export interface plugConfig extends BaseDeviceConfig {
-  configDeviceType: 'Plug' | 'Plug Mini (US)' | 'Plug Mini (JP)'
-};
-
-export interface colorBulbConfig extends BaseDeviceConfig {
-  configDeviceType: 'Color Bulb'
-  set_minStep?: number
-  adaptiveLightingShift?: number
-};
-
-export interface stripLightConfig extends BaseDeviceConfig {
-  configDeviceType: 'Strip Light'
-  set_minStep?: number
-  adaptiveLightingShift?: number
-};
-
-export interface ceilingLightConfig extends BaseDeviceConfig {
-  configDeviceType: 'Ceiling Light' | 'Ceiling Light Pro'
-  set_minStep?: number
-  adaptiveLightingShift?: number
-};
-
-export interface lockConfig extends BaseDeviceConfig {
-  configDeviceType: 'Smart Lock' | 'Smart Lock Pro'
-  hide_contactsensor?: boolean
-  activate_latchbutton?: boolean
-};
-
-export interface hubConfig extends BaseDeviceConfig {
-  configDeviceType: 'Hub 2'
-  hide_temperature?: boolean
-  convertUnitTo?: string
-  hide_humidity?: boolean
-  hide_lightsensor?: boolean
-  set_minLux?: number
-  set_maxLux?: number
-};
-
-export type irDevicesConfig = irFanConfig | irLightConfig | irAirConfig | irOtherConfig
-
-export interface irBaseDeviceConfig extends irdevice {
-  configDeviceName?: string
-  configRemoteType?: string
-  connectionType?: string
-  hide_device?: boolean
-  external?: boolean
-  refreshRate?: number
-  updateRate?: number
-  pushRate?: number
-  maxRetries?: number
-  delayBetweenRetries?: number
-  firmware?: string
-  deviceId: string
-  logging?: string
-  customOn?: string
-  customOff?: string
-  customize?: boolean
-  commandType?: string
-  disablePushOn?: boolean
-  disablePushOff?: boolean
-  disablePushDetail?: boolean
+export const DEFAULT_CONFIG: Partial<SwitchBotPluginConfig> = {
+  preferMatter: true,
+  enableMatter: true,
 }
 
-export interface irFanConfig extends irBaseDeviceConfig {
-  configRemoteType?: 'Fan' | 'DIY Fan'
-  swing_mode?: boolean
-  rotation_speed?: boolean
-  set_minStep?: number
-  set_max?: number
-  set_min?: number
-};
-
-export interface irLightConfig extends irBaseDeviceConfig {
-  configRemoteType?: 'Light' | 'DIY Light'
-  stateless?: boolean
-};
-
-export interface irAirConfig extends irBaseDeviceConfig {
-  configRemoteType?: 'Air Conditioner' | 'DIY Air Conditioner'
-  hide_automode?: boolean
-  set_max_heat?: number
-  set_min_heat?: number
-  set_max_cool?: number
-  set_min_cool?: number
-  meterType?: string
-  meterId?: string
-  meterUuid?: string
-};
-
-export interface irOtherConfig extends irBaseDeviceConfig {
-  configRemoteType?: 'Others'
-  type?: string
-};
+export type DeviceType = string