@switchbot/homebridge-switchbot 3.5.0-beta.22 → 3.5.0-beta.24

package/src/irdevice/waterheater.ts

@@ -1,82 +1,63 @@
-import { CharacteristicValue, PlatformAccessory, Service, API, Logging, HAP } from 'homebridge';
+/* Copyright(C) 2021-2024, donavanbecker (https://github.com/donavanbecker). All rights reserved.
+ *
+ * waterheater.ts: @switchbot/homebridge-switchbot.
+ */
 import { request } from 'undici';
+import { irdeviceBase } from './irdevice.js';
 import { SwitchBotPlatform } from '../platform.js';
-import { Devices, irDevicesConfig, irdevice, SwitchBotPlatformConfig } from '../settings.js';
+import { Devices, irDevicesConfig, irdevice } from '../settings.js';
+import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
 
 /**
  * Platform Accessory
  * An instance of this class is created for each accessory your platform registers
  * Each accessory may expose multiple services of different service types.
  */
-export class WaterHeater {
-  public readonly api: API;
-  public readonly log: Logging;
-  public readonly config!: SwitchBotPlatformConfig;
-  protected readonly hap: HAP;
+export class WaterHeater extends irdeviceBase {
   // Services
-  valveService!: Service;
-
-  // Characteristic Values
-  Active!: CharacteristicValue;
-  FirmwareRevision!: CharacteristicValue;
-
-  // Config
-  deviceLogging!: string;
-  disablePushOn?: boolean;
-  disablePushOff?: boolean;
+  private Valve: {
+    Service: Service;
+    Active: CharacteristicValue;
+  };
 
   constructor(
-    private readonly platform: SwitchBotPlatform,
-    private accessory: PlatformAccessory,
-    public device: irdevice & irDevicesConfig,
+    readonly platform: SwitchBotPlatform,
+    accessory: PlatformAccessory,
+    device: irdevice & irDevicesConfig,
   ) {
-    this.api = this.platform.api;
-    this.log = this.platform.log;
-    this.config = this.platform.config;
-    this.hap = this.api.hap;
-    // default placeholders
-    this.deviceLogs(device);
-    this.deviceContext();
-    this.disablePushOnChanges(device);
-    this.disablePushOffChanges(device);
-    this.deviceConfig(device);
+    super(platform, accessory, device);
 
-    // set accessory information
-    accessory
-      .getService(this.hap.Service.AccessoryInformation)!
-      .setCharacteristic(this.hap.Characteristic.Manufacturer, 'SwitchBot')
-      .setCharacteristic(this.hap.Characteristic.Model, device.remoteType)
-      .setCharacteristic(this.hap.Characteristic.SerialNumber, device.deviceId)
-      .setCharacteristic(this.hap.Characteristic.FirmwareRevision, accessory.context.FirmwareRevision);
+    // Initialize Valve property
+    this.Valve = {
+      Service: accessory.addService(this.hap.Service.Valve),
+      Active: accessory.context.Active || this.hap.Characteristic.Active.INACTIVE,
+    };
 
     // get the Television service if it exists, otherwise create a new Television service
     // you can create multiple services for each accessory
-    const valveService = `${accessory.displayName} ${device.remoteType}`;
-    (this.valveService = accessory.getService(this.hap.Service.Valve)
-      || accessory.addService(this.hap.Service.Valve)), valveService;
+    const ValveService = `${accessory.displayName} ${device.remoteType}`;
+    (this.Valve.Service = accessory.getService(this.hap.Service.Valve)
+      || accessory.addService(this.hap.Service.Valve)), ValveService;
 
-    this.valveService.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
-    if (!this.valveService.testCharacteristic(this.hap.Characteristic.ConfiguredName)) {
-      this.valveService.addCharacteristic(this.hap.Characteristic.ConfiguredName, accessory.displayName);
-    }
+    this.Valve.Service.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
 
     // set sleep discovery characteristic
-    this.valveService.setCharacteristic(this.hap.Characteristic.ValveType, this.hap.Characteristic.ValveType.GENERIC_VALVE);
+    this.Valve.Service.setCharacteristic(this.hap.Characteristic.ValveType, this.hap.Characteristic.ValveType.GENERIC_VALVE);
 
     // handle on / off events using the Active characteristic
-    this.valveService.getCharacteristic(this.hap.Characteristic.Active).onSet(this.ActiveSet.bind(this));
+    this.Valve.Service.getCharacteristic(this.hap.Characteristic.Active).onSet(this.ActiveSet.bind(this));
   }
 
   async ActiveSet(value: CharacteristicValue): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${value}`);
 
-    this.Active = value;
-    if (this.Active === this.hap.Characteristic.Active.ACTIVE) {
+    this.Valve.Active = value;
+    if (this.Valve.Active === this.hap.Characteristic.Active.ACTIVE) {
       await this.pushWaterHeaterOnChanges();
-      this.valveService.setCharacteristic(this.hap.Characteristic.InUse, this.hap.Characteristic.InUse.IN_USE);
+      this.Valve.Service.setCharacteristic(this.hap.Characteristic.InUse, this.hap.Characteristic.InUse.IN_USE);
     } else {
       await this.pushWaterHeaterOffChanges();
-      this.valveService.setCharacteristic(this.hap.Characteristic.InUse, this.hap.Characteristic.InUse.NOT_IN_USE);
+      this.Valve.Service.setCharacteristic(this.hap.Characteristic.InUse, this.hap.Characteristic.InUse.NOT_IN_USE);
     }
   }
 
@@ -87,11 +68,9 @@ export class WaterHeater {
    * WaterHeater     "command"       "turnOn"          "default"	       set to ON state
    */
   async pushWaterHeaterOnChanges(): Promise<void> {
-    this.debugLog(
-      `${this.device.remoteType}: ${this.accessory.displayName} pushWaterHeaterOnChanges Active: ${this.Active},` +
-      ` disablePushOn: ${this.disablePushOn}`,
-    );
-    if (this.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushWaterHeaterOnChanges Active: ${this.Valve.Active},`
+      + ` disablePushOn: ${this.disablePushOn}`);
+    if (this.Valve.Active === this.hap.Characteristic.Active.ACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOn();
       const bodyChange = JSON.stringify({
@@ -104,11 +83,9 @@ export class WaterHeater {
   }
 
   async pushWaterHeaterOffChanges(): Promise<void> {
-    this.debugLog(
-      `${this.device.remoteType}: ${this.accessory.displayName} pushWaterHeaterOffChanges Active: ${this.Active},` +
-      ` disablePushOff: ${this.disablePushOff}`,
-    );
-    if (this.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOff) {
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushWaterHeaterOffChanges Active: ${this.Valve.Active},`
+      + ` disablePushOff: ${this.disablePushOff}`);
+    if (this.Valve.Active === this.hap.Characteristic.Active.INACTIVE && !this.disablePushOff) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOff();
       const bodyChange = JSON.stringify({
@@ -145,272 +122,27 @@ export class WaterHeater {
         }
       } catch (e: any) {
         this.apiError(e);
-        this.errorLog(
-          `${this.device.remoteType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType}` +
-          ` Connection, Error Message: ${JSON.stringify(e.message)}`,
-        );
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType}`
+          + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
       }
     } else {
-      this.warnLog(
-        `${this.device.remoteType}: ${this.accessory.displayName}` +
-        ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`,
-      );
+      this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+        + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
     }
   }
 
   async updateHomeKitCharacteristics(): Promise<void> {
     // Active
-    if (this.Active === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.Active}`);
-    } else {
-      this.accessory.context.Active = this.Active;
-      this.valveService?.updateCharacteristic(this.hap.Characteristic.Active, this.Active);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Active}`);
-    }
-  }
-
-  async disablePushOnChanges(device: irdevice & irDevicesConfig): Promise<void> {
-    if (device.disablePushOn === undefined) {
-      this.disablePushOn = false;
-    } else {
-      this.disablePushOn = device.disablePushOn;
-    }
-  }
-
-  async disablePushOffChanges(device: irdevice & irDevicesConfig): Promise<void> {
-    if (device.disablePushOff === undefined) {
-      this.disablePushOff = false;
-    } else {
-      this.disablePushOff = device.disablePushOff;
-    }
-  }
-
-  async commandType(): Promise<string> {
-    let commandType: string;
-    if (this.device.customize) {
-      commandType = 'customize';
-    } else {
-      commandType = 'command';
-    }
-    return commandType;
-  }
-
-  async commandOn(): Promise<string> {
-    let command: string;
-    if (this.device.customize && this.device.customOn) {
-      command = this.device.customOn;
-    } else {
-      command = 'turnOn';
-    }
-    return command;
-  }
-
-  async commandOff(): Promise<string> {
-    let command: string;
-    if (this.device.customize && this.device.customOff) {
-      command = this.device.customOff;
+    if (this.Valve.Active === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.Valve.Active}`);
     } else {
-      command = 'turnOff';
-    }
-    return command;
-  }
-
-  async statusCode(statusCode: number): Promise<void> {
-    switch (statusCode) {
-      case 151:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command not supported by this deviceType, statusCode: ${statusCode}`);
-        break;
-      case 152:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device not found, statusCode: ${statusCode}`);
-        break;
-      case 160:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command is not supported, statusCode: ${statusCode}`);
-        break;
-      case 161:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device is offline, statusCode: ${statusCode}`);
-        break;
-      case 171:
-        this.errorLog(
-          `${this.device.remoteType}: ${this.accessory.displayName} Hub Device is offline, statusCode: ${statusCode}. ` +
-          `Hub: ${this.device.hubDeviceId}`,
-        );
-        break;
-      case 190:
-        this.errorLog(
-          `${this.device.remoteType}: ${this.accessory.displayName} Device internal error due to device states not synchronized with server,` +
-          ` Or command format is invalid, statusCode: ${statusCode}`,
-        );
-        break;
-      case 100:
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Command successfully sent, statusCode: ${statusCode}`);
-        break;
-      case 200:
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Request successful, statusCode: ${statusCode}`);
-        break;
-      case 400:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Bad Request, The client has issued an invalid request. `
-              + `This is commonly used to specify validation errors in a request payload, statusCode: ${statusCode}`);
-        break;
-      case 401:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unauthorized,	Authorization for the API is required, `
-              + `but the request has not been authenticated, statusCode: ${statusCode}`);
-        break;
-      case 403:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Forbidden,	The request has been authenticated but does not `
-              + `have appropriate permissions, or a requested resource is not found, statusCode: ${statusCode}`);
-        break;
-      case 404:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Not Found,	Specifies the requested path does not exist, `
-          + `statusCode: ${statusCode}`);
-        break;
-      case 406:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Not Acceptable,	The client has requested a MIME type via `
-              + `the Accept header for a value not supported by the server, statusCode: ${statusCode}`);
-        break;
-      case 415:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unsupported Media Type,	The client has defined a contentType `
-              + `header that is not supported by the server, statusCode: ${statusCode}`);
-        break;
-      case 422:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unprocessable Entity,	The client has made a valid request, but `
-              + `the server cannot process it. This is often used for APIs for which certain limits have been exceeded, statusCode: ${statusCode}`);
-        break;
-      case 429:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Too Many Requests,	The client has exceeded the number of `
-              + `requests allowed for a given time window, statusCode: ${statusCode}`);
-        break;
-      case 500:
-        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Internal Server Error,	An unexpected error on the SmartThings `
-              + `servers has occurred. These errors should be rare, statusCode: ${statusCode}`);
-        break;
-      default:
-        this.infoLog(
-          `${this.device.remoteType}: ${this.accessory.displayName} Unknown statusCode: ` +
-          `${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`,
-        );
+      this.accessory.context.Active = this.Valve.Active;
+      this.Valve.Service?.updateCharacteristic(this.hap.Characteristic.Active, this.Valve.Active);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Valve.Active}`);
     }
   }
 
   async apiError({ e }: { e: any }): Promise<void> {
-    this.valveService.updateCharacteristic(this.hap.Characteristic.Active, e);
-  }
-
-  async deviceContext(): Promise<void> {
-    if (this.Active === undefined) {
-      this.Active = this.hap.Characteristic.Active.INACTIVE;
-    } else {
-      this.Active = this.accessory.context.Active;
-    }
-    if (this.FirmwareRevision === undefined) {
-      this.FirmwareRevision = this.platform.version;
-      this.accessory.context.FirmwareRevision = this.FirmwareRevision;
-    }
-  }
-
-  async deviceConfig(device: irdevice & irDevicesConfig): Promise<void> {
-    let config = {};
-    if (device.irwh) {
-      config = device.irwh;
-    }
-    if (device.logging !== undefined) {
-      config['logging'] = device.logging;
-    }
-    if (device.connectionType !== undefined) {
-      config['connectionType'] = device.connectionType;
-    }
-    if (device.external !== undefined) {
-      config['external'] = device.external;
-    }
-    if (device.customOn !== undefined) {
-      config['customOn'] = device.customOn;
-    }
-    if (device.customOff !== undefined) {
-      config['customOff'] = device.customOff;
-    }
-    if (device.customize !== undefined) {
-      config['customize'] = device.customize;
-    }
-    if (device.disablePushOn !== undefined) {
-      config['disablePushOn'] = device.disablePushOn;
-    }
-    if (device.disablePushOff !== undefined) {
-      config['disablePushOff'] = device.disablePushOff;
-    }
-    if (Object.entries(config).length !== 0) {
-      this.debugWarnLog({ log: [`${this.device.remoteType}: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`] });
-    }
-  }
-
-  async deviceLogs(device: irdevice & irDevicesConfig): Promise<void> {
-    if (this.platform.debugMode) {
-      this.deviceLogging = this.accessory.context.logging = 'debugMode';
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
-    } else if (device.logging) {
-      this.deviceLogging = this.accessory.context.logging = device.logging;
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Device Config Logging: ${this.deviceLogging}`);
-    } else if (this.platform.config.options?.logging) {
-      this.deviceLogging = this.accessory.context.logging = this.platform.config.options?.logging;
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Platform Config Logging: ${this.deviceLogging}`);
-    } else {
-      this.deviceLogging = this.accessory.context.logging = 'standard';
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Logging Not Set, Using: ${this.deviceLogging}`);
-    }
-  }
-
-  /**
-   * Logging for Device
-   */
-  successLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      this.platform.log.success(String(...log));
-    }
-  }
-
-  infoLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      this.platform.log.info(String(...log));
-    }
-  }
-
-  warnLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      this.platform.log.warn(String(...log));
-    }
-  }
-
-  debugWarnLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      if (this.deviceLogging?.includes('debug')) {
-        this.platform.log.warn('[DEBUG]', String(...log));
-      }
-    }
-  }
-
-  errorLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      this.platform.log.error(String(...log));
-    }
-  }
-
-  debugErrorLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      if (this.deviceLogging?.includes('debug')) {
-        this.platform.log.error('[DEBUG]', String(...log));
-      }
-    }
-  }
-
-  debugLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      if (this.deviceLogging === 'debug') {
-        this.platform.log.info('[DEBUG]', String(...log));
-      } else {
-        this.platform.log.debug(String(...log));
-      }
-    }
-  }
-
-  enablingDeviceLogging(): boolean {
-    return this.deviceLogging.includes('debug') || this.deviceLogging === 'standard';
+    this.Valve.Service.updateCharacteristic(this.hap.Characteristic.Active, e);
   }
 }

package/src/settings.ts

@@ -53,6 +53,7 @@ export interface devicesConfig extends device {
   deviceId: string;
   external?: boolean;
   refreshRate?: number;
+  updateRate?: number;
   firmware?: string;
   logging?: string;
   connectionType?: string;
@@ -71,6 +72,7 @@ export interface devicesConfig extends device {
   webhook?: boolean;
   bot?: bot;
   meter?: meter;
+  iosensor?: iosensor;
   humidifier?: humidifier;
   curtain?: curtain;
   blindTilt?: blindTilt;
@@ -90,6 +92,11 @@ export type meter = {
   hide_humidity?: boolean;
 };
 
+export type iosensor = {
+  hide_temperature?: boolean;
+  hide_humidity?: boolean;
+};
+
 export type bot = {
   mode?: string;
   deviceType?: string;
@@ -109,7 +116,6 @@ export type curtain = {
   hide_lightsensor?: boolean;
   set_minLux?: number;
   set_maxLux?: number;
-  updateRate?: number;
   set_max?: number;
   set_min?: number;
   set_minStep?: number;
@@ -122,7 +128,6 @@ export type blindTilt = {
   hide_lightsensor?: boolean;
   set_minLux?: number;
   set_maxLux?: number;
-  updateRate?: number;
   set_max?: number;
   set_min?: number;
   set_minStep?: number;
@@ -268,6 +273,10 @@ export type device = {
   version?: number;
   //BLE Mac Address
   bleMac?: string;
+  //Device Model
+  model?: string;
+  //Device BLE Model
+  bleModel?: string;
 };
 
 //a list of virtual infrared remote devices.
@@ -280,9 +289,16 @@ export type irdevice = {
   deviceName: string; //device name
   remoteType: string; //device type
   hubDeviceId: string; //remote device's parent Hub ID
+  model: string; //device model
 };
 
 export type deviceStatus = {
+  statusCode: number;
+  message: string;
+  body: deviceStatusBody;
+};
+
+export type deviceStatusBody = {
   //v1.1 of API
   deviceId: string; //device ID. (Used by the following deviceTypes: Bot, Curtain, Meter, Meter Plus, Lock, Keypad, Keypad Touch, Motion Sensor, Contact Sensor, Ceiling Light, Ceiling Light Pro, Plug Mini (US), Plug Mini (JP), Strip Light, Color Bulb, Robot Vacuum Cleaner S1, Robot Vacuum Cleaner S1 Plus, Humidifier, Blind Tilt)
   deviceType: string; //device type. (Used by the following deviceTypes: Bot, Curtain, Meter, Meter Plus, Lock, Keypad, Keypad Touch, Motion Sensor, Contact Sensor, Ceiling Light, Ceiling Light Pro, Plug Mini (US), Plug Mini (JP), Strip Light, Color Bulb, Robot Vacuum Cleaner S1, Robot Vacuum Cleaner S1 Plus, Humidifier, Blind Tilt)
@@ -323,6 +339,7 @@ export type deviceStatus = {
   shakeCenter?: string; //the fan's swing direction. (Used by the following deviceTypes: Smart Fan)
   shakeRange?: string; //the fan's swing range, 0~120°. (Used by the following deviceTypes: Smart Fan)
   status?: number //the leak status. 0 for no leak, 1 for leak. (Used by the following deviceTypes: Water Detector)
+  lightLevel?: number; //the light level. (Used by the following deviceTypes: Hub)
 };
 
 export type ad = {
@@ -359,7 +376,7 @@ export type serviceData = {
   battery?: number;
   //Humidifier's humidity level percentage
   percentage?: boolean | string;
-  //Humidifier's humidity level percentage
+  //Humidifier's state
   onState?: boolean;
   //Humidifier's AutoMode
   autoMode?: boolean;

package/src/utils.ts

@@ -2,6 +2,77 @@
  *
  * util.ts: @switchbot/homebridge-switchbot platform class.
  */
+export enum SwitchBotModel {
+  HubMini = 'W0202200',
+  HubPlus = 'SwitchBot Hub S1',
+  Hub2 = 'W3202100',
+  Bot = 'SwitchBot S1',
+  Curtain = 'W0701600',
+  Curtain3 = 'W2400000',
+  Humidifier = 'W0801800',
+  Plug = 'SP11', // Currently only available in Japan
+  Meter = 'SwitchBot MeterTH S1',
+  MeterPlusJP = 'W2201500',
+  MeterPlusUS = 'W2301500',
+  OutdoorMeter = 'W3400010',
+  MotionSensor = 'W1101500',
+  ContactSensor = 'W1201500',
+  ColorBulb = 'W1401400',
+  StripLight = 'W1701100',
+  PlugMiniUS = 'W1901400',
+  PlugMiniJP = 'W2001400',
+  Lock = 'W1601700',
+  LockPro = 'W3500000',
+  Keypad = 'W2500010',
+  KeypadTouch = 'W2500020',
+  K10 = 'K10+',
+  WoSweeper = 'WoSweeper',
+  WoSweeperMini = 'WoSweeperMini',
+  RobotVacuumCleanerS1 = 'W3011000', // Currently only available in Japan.
+  RobotVacuumCleanerS1Plus = 'W3011010', // Currently only available in Japan.
+  Remote = 'Remote',
+  UniversalRemote = 'UniversalRemote',
+  CeilingLight = 'W2612230', // Currently only available in Japan.
+  CeilingLightPro = 'W2612210', // Currently only available in Japan.
+  IndoorCam = 'W1301200',
+  PanTiltCam = 'W1801200',
+  PanTiltCam2K = 'W3101100',
+  BlindTilt = 'W2701600',
+  BatteryCirculatorFan = 'W3800510',
+  WaterDetector = 'WoWaterDetector',
+  Unknown = 'Unknown',
+}
+
+export enum SwitchBotBLEModel {
+  Bot = 'H',
+  Curtain = 'c',
+  Curtain3 = '{',
+  Humidifier = 'e',
+  Meter = 'T',
+  MeterPlus = 'i',
+  OutdoorMeter = 'w',
+  MotionSensor = 's',
+  ContactSensor = 'd',
+  ColorBulb = 'u',
+  StripLight = 'r',
+  PlugMiniUS = 'g',
+  PlugMiniJP = 'j',
+  Lock = 'o',
+  Remote = '',
+  CeilingLight = 'q', // Currently only available in Japan.
+  CeilingLightPro = 'n', // Currently only available in Japan.
+  BlindTilt = 'x',
+  Unknown = 'Unknown',
+}
+
+export enum BlindTiltMappingMode {
+  OnlyUp = 'only_up',
+  OnlyDown = 'only_down',
+  DownAndUp = 'down_and_up',
+  UpAndDown = 'up_and_down',
+  UseTiltForDirection = 'use_tilt_for_direction',
+}
+
 export function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }