node-switchbot 3.5.0-beta.0 → 3.5.0-beta.1

package/dist/device.js

@@ -1,8 +1,171 @@
 import { Buffer } from 'node:buffer';
+import * as Crypto from 'node:crypto';
 import { EventEmitter } from 'node:events';
-import { Advertising } from './advertising.js';
 import { parameterChecker } from './parameter-checker.js';
-import { CHAR_UUID_DEVICE, CHAR_UUID_NOTIFY, CHAR_UUID_WRITE, READ_TIMEOUT_MSEC, SERV_UUID_PRIMARY, WRITE_TIMEOUT_MSEC } from './settings.js';
+import { CHAR_UUID_DEVICE, CHAR_UUID_NOTIFY, CHAR_UUID_WRITE, READ_TIMEOUT_MSEC, SERV_UUID_PRIMARY, WoSmartLockCommands, WoSmartLockProCommands, WRITE_TIMEOUT_MSEC } from './settings.js';
+const HUMIDIFIER_COMMAND_HEADER = '5701';
+const TURN_ON_KEY = `${HUMIDIFIER_COMMAND_HEADER}0101`;
+const TURN_OFF_KEY = `${HUMIDIFIER_COMMAND_HEADER}0102`;
+const INCREASE_KEY = `${HUMIDIFIER_COMMAND_HEADER}0103`;
+const DECREASE_KEY = `${HUMIDIFIER_COMMAND_HEADER}0104`;
+const SET_AUTO_MODE_KEY = `${HUMIDIFIER_COMMAND_HEADER}0105`;
+const SET_MANUAL_MODE_KEY = `${HUMIDIFIER_COMMAND_HEADER}0106`;
+export var SwitchBotModel;
+(function (SwitchBotModel) {
+    SwitchBotModel["HubMini"] = "W0202200";
+    SwitchBotModel["HubPlus"] = "SwitchBot Hub S1";
+    SwitchBotModel["Hub2"] = "W3202100";
+    SwitchBotModel["Bot"] = "SwitchBot S1";
+    SwitchBotModel["Curtain"] = "W0701600";
+    SwitchBotModel["Curtain3"] = "W2400000";
+    SwitchBotModel["Humidifier"] = "W0801800";
+    SwitchBotModel["Humidifier2"] = "WXXXXXXX";
+    SwitchBotModel["Plug"] = "SP11";
+    SwitchBotModel["Meter"] = "SwitchBot MeterTH S1";
+    SwitchBotModel["MeterPlusJP"] = "W2201500";
+    SwitchBotModel["MeterPlusUS"] = "W2301500";
+    SwitchBotModel["MeterPro"] = "W4900000";
+    SwitchBotModel["MeterProCO2"] = "W4900010";
+    SwitchBotModel["OutdoorMeter"] = "W3400010";
+    SwitchBotModel["MotionSensor"] = "W1101500";
+    SwitchBotModel["ContactSensor"] = "W1201500";
+    SwitchBotModel["ColorBulb"] = "W1401400";
+    SwitchBotModel["StripLight"] = "W1701100";
+    SwitchBotModel["PlugMiniUS"] = "W1901400/W1901401";
+    SwitchBotModel["PlugMiniJP"] = "W2001400/W2001401";
+    SwitchBotModel["Lock"] = "W1601700";
+    SwitchBotModel["LockPro"] = "W3500000";
+    SwitchBotModel["Keypad"] = "W2500010";
+    SwitchBotModel["KeypadTouch"] = "W2500020";
+    SwitchBotModel["K10"] = "K10+";
+    SwitchBotModel["K10Pro"] = "K10+ Pro";
+    SwitchBotModel["WoSweeper"] = "WoSweeper";
+    SwitchBotModel["WoSweeperMini"] = "WoSweeperMini";
+    SwitchBotModel["RobotVacuumCleanerS1"] = "W3011000";
+    SwitchBotModel["RobotVacuumCleanerS1Plus"] = "W3011010";
+    SwitchBotModel["RobotVacuumCleanerS10"] = "W3211800";
+    SwitchBotModel["Remote"] = "Remote";
+    SwitchBotModel["UniversalRemote"] = "UniversalRemote";
+    SwitchBotModel["CeilingLight"] = "W2612230/W2612240";
+    SwitchBotModel["CeilingLightPro"] = "W2612210/W2612220";
+    SwitchBotModel["IndoorCam"] = "W1301200";
+    SwitchBotModel["PanTiltCam"] = "W1801200";
+    SwitchBotModel["PanTiltCam2K"] = "W3101100";
+    SwitchBotModel["BlindTilt"] = "W2701600";
+    SwitchBotModel["BatteryCirculatorFan"] = "W3800510";
+    SwitchBotModel["CirculatorFan"] = "W3800511";
+    SwitchBotModel["WaterDetector"] = "W4402000";
+    SwitchBotModel["RelaySwitch1"] = "W5502300";
+    SwitchBotModel["RelaySwitch1PM"] = "W5502310";
+    SwitchBotModel["Unknown"] = "Unknown";
+})(SwitchBotModel || (SwitchBotModel = {}));
+export var SwitchBotBLEModel;
+(function (SwitchBotBLEModel) {
+    SwitchBotBLEModel["Bot"] = "H";
+    SwitchBotBLEModel["Curtain"] = "c";
+    SwitchBotBLEModel["Curtain3"] = "{";
+    SwitchBotBLEModel["Humidifier"] = "e";
+    SwitchBotBLEModel["Humidifier2"] = "#";
+    SwitchBotBLEModel["Meter"] = "T";
+    SwitchBotBLEModel["MeterPlus"] = "i";
+    SwitchBotBLEModel["MeterPro"] = "4";
+    SwitchBotBLEModel["MeterProCO2"] = "5";
+    SwitchBotBLEModel["Hub2"] = "v";
+    SwitchBotBLEModel["OutdoorMeter"] = "w";
+    SwitchBotBLEModel["MotionSensor"] = "s";
+    SwitchBotBLEModel["ContactSensor"] = "d";
+    SwitchBotBLEModel["ColorBulb"] = "u";
+    SwitchBotBLEModel["StripLight"] = "r";
+    SwitchBotBLEModel["PlugMiniUS"] = "g";
+    SwitchBotBLEModel["PlugMiniJP"] = "j";
+    SwitchBotBLEModel["Lock"] = "o";
+    SwitchBotBLEModel["LockPro"] = "$";
+    SwitchBotBLEModel["CeilingLight"] = "q";
+    SwitchBotBLEModel["CeilingLightPro"] = "n";
+    SwitchBotBLEModel["BlindTilt"] = "x";
+    SwitchBotBLEModel["Leak"] = "&";
+    SwitchBotBLEModel["Keypad"] = "y";
+    SwitchBotBLEModel["RelaySwitch1"] = ";";
+    SwitchBotBLEModel["RelaySwitch1PM"] = "<";
+    SwitchBotBLEModel["Remote"] = "b";
+    SwitchBotBLEModel["Unknown"] = "Unknown";
+})(SwitchBotBLEModel || (SwitchBotBLEModel = {}));
+export var SwitchBotBLEModelName;
+(function (SwitchBotBLEModelName) {
+    SwitchBotBLEModelName["Bot"] = "WoHand";
+    SwitchBotBLEModelName["Hub2"] = "WoHub2";
+    SwitchBotBLEModelName["ColorBulb"] = "WoBulb";
+    SwitchBotBLEModelName["Curtain"] = "WoCurtain";
+    SwitchBotBLEModelName["Curtain3"] = "WoCurtain3";
+    SwitchBotBLEModelName["Humidifier"] = "WoHumi";
+    SwitchBotBLEModelName["Humidifier2"] = "WoHumi2";
+    SwitchBotBLEModelName["Meter"] = "WoSensorTH";
+    SwitchBotBLEModelName["MeterPlus"] = "WoSensorTHPlus";
+    SwitchBotBLEModelName["MeterPro"] = "WoSensorTHP";
+    SwitchBotBLEModelName["MeterProCO2"] = "WoSensorTHPc";
+    SwitchBotBLEModelName["Lock"] = "WoSmartLock";
+    SwitchBotBLEModelName["LockPro"] = "WoSmartLockPro";
+    SwitchBotBLEModelName["PlugMini"] = "WoPlugMini";
+    SwitchBotBLEModelName["StripLight"] = "WoStrip";
+    SwitchBotBLEModelName["OutdoorMeter"] = "WoIOSensorTH";
+    SwitchBotBLEModelName["ContactSensor"] = "WoContact";
+    SwitchBotBLEModelName["MotionSensor"] = "WoMotion";
+    SwitchBotBLEModelName["BlindTilt"] = "WoBlindTilt";
+    SwitchBotBLEModelName["CeilingLight"] = "WoCeilingLight";
+    SwitchBotBLEModelName["CeilingLightPro"] = "WoCeilingLightPro";
+    SwitchBotBLEModelName["Leak"] = "WoLeakDetector";
+    SwitchBotBLEModelName["Keypad"] = "WoKeypad";
+    SwitchBotBLEModelName["RelaySwitch1"] = "WoRelaySwitch1Plus";
+    SwitchBotBLEModelName["RelaySwitch1PM"] = "WoRelaySwitch1PM";
+    SwitchBotBLEModelName["Remote"] = "WoRemote";
+    SwitchBotBLEModelName["Unknown"] = "Unknown";
+})(SwitchBotBLEModelName || (SwitchBotBLEModelName = {}));
+export var SwitchBotBLEModelFriendlyName;
+(function (SwitchBotBLEModelFriendlyName) {
+    SwitchBotBLEModelFriendlyName["Bot"] = "Bot";
+    SwitchBotBLEModelFriendlyName["Hub2"] = "Hub 2";
+    SwitchBotBLEModelFriendlyName["ColorBulb"] = "Color Bulb";
+    SwitchBotBLEModelFriendlyName["Curtain"] = "Curtain";
+    SwitchBotBLEModelFriendlyName["Curtain3"] = "Curtain 3";
+    SwitchBotBLEModelFriendlyName["Humidifier"] = "Humidifier";
+    SwitchBotBLEModelFriendlyName["Humidifier2"] = "Humidifier2";
+    SwitchBotBLEModelFriendlyName["Meter"] = "Meter";
+    SwitchBotBLEModelFriendlyName["Lock"] = "Lock";
+    SwitchBotBLEModelFriendlyName["LockPro"] = "Lock Pro";
+    SwitchBotBLEModelFriendlyName["PlugMini"] = "Plug Mini";
+    SwitchBotBLEModelFriendlyName["StripLight"] = "Strip Light";
+    SwitchBotBLEModelFriendlyName["MeterPlus"] = "Meter Plus";
+    SwitchBotBLEModelFriendlyName["MeterPro"] = "Meter Pro";
+    SwitchBotBLEModelFriendlyName["MeterProCO2"] = "Meter Pro CO2";
+    SwitchBotBLEModelFriendlyName["BatteryCirculatorFan"] = "Battery Circulator Fan";
+    SwitchBotBLEModelFriendlyName["CirculatorFan"] = "Circulator Fan";
+    SwitchBotBLEModelFriendlyName["OutdoorMeter"] = "Outdoor Meter";
+    SwitchBotBLEModelFriendlyName["ContactSensor"] = "Contact Sensor";
+    SwitchBotBLEModelFriendlyName["MotionSensor"] = "Motion Sensor";
+    SwitchBotBLEModelFriendlyName["BlindTilt"] = "Blind Tilt";
+    SwitchBotBLEModelFriendlyName["CeilingLight"] = "Ceiling Light";
+    SwitchBotBLEModelFriendlyName["CeilingLightPro"] = "Ceiling Light Pro";
+    SwitchBotBLEModelFriendlyName["Leak"] = "Water Detector";
+    SwitchBotBLEModelFriendlyName["Keypad"] = "Keypad";
+    SwitchBotBLEModelFriendlyName["RelaySwitch1"] = "Relay Switch 1";
+    SwitchBotBLEModelFriendlyName["RelaySwitch1PM"] = "Relay Switch 1PM";
+    SwitchBotBLEModelFriendlyName["Remote"] = "Remote";
+    SwitchBotBLEModelFriendlyName["Unknown"] = "Unknown";
+})(SwitchBotBLEModelFriendlyName || (SwitchBotBLEModelFriendlyName = {}));
+/**
+ * Enum for log levels.
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["SUCCESS"] = "success";
+    LogLevel["DEBUGSUCCESS"] = "debugsuccess";
+    LogLevel["WARN"] = "warn";
+    LogLevel["DEBUGWARN"] = "debugwarn";
+    LogLevel["ERROR"] = "error";
+    LogLevel["DEBUGERROR"] = "debugerror";
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["INFO"] = "info";
+})(LogLevel || (LogLevel = {}));
 /**
  * Represents a Switchbot Device.
  */
@@ -343,4 +506,2317 @@ export class SwitchbotDevice extends EventEmitter {
         }
     }
 }
+/**
+ * Represents the advertising data parser for SwitchBot devices.
+ */
+export class Advertising {
+    constructor() { }
+    /**
+     * Parses the advertisement data coming from SwitchBot device.
+     *
+     * This function processes advertising packets received from SwitchBot devices
+     * and extracts relevant information based on the device type.
+     *
+     * @param {NobleTypes['peripheral']} peripheral - The peripheral device object from noble.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<Ad | null>} - An object containing parsed data specific to the SwitchBot device type, or `null` if the device is not recognized.
+     */
+    static async parse(peripheral, emitLog) {
+        const ad = peripheral.advertisement;
+        if (!ad || !ad.serviceData) {
+            return null;
+        }
+        const serviceData = ad.serviceData[0]?.data;
+        const manufacturerData = ad.manufacturerData;
+        if (!Advertising.validateBuffer(serviceData) || !Advertising.validateBuffer(manufacturerData)) {
+            return null;
+        }
+        const model = serviceData.subarray(0, 1).toString('utf8');
+        const sd = await Advertising.parseServiceData(model, serviceData, manufacturerData, emitLog);
+        if (!sd) {
+            // emitLog('debugerror', `[parseAdvertising.${peripheral.id}.${model}] return null, parsed serviceData empty!`)
+            return null;
+        }
+        const address = Advertising.formatAddress(peripheral);
+        const data = {
+            id: peripheral.id,
+            address,
+            rssi: peripheral.rssi,
+            serviceData: {
+                model,
+                modelName: sd.modelName || '',
+                modelFriendlyName: sd.modelFriendlyName || '',
+                ...sd,
+            },
+        };
+        emitLog('debug', `[parseAdvertising.${peripheral.id}.${model}] return ${JSON.stringify(data)}`);
+        return data;
+    }
+    /**
+     * Validates if the buffer is a valid Buffer object with a minimum length.
+     *
+     * @param {any} buffer - The buffer to validate.
+     * @returns {boolean} - True if the buffer is valid, false otherwise.
+     */
+    static validateBuffer(buffer) {
+        return buffer && Buffer.isBuffer(buffer) && buffer.length >= 3;
+    }
+    /**
+     * Parses the service data based on the device model.
+     *
+     * @param {string} model - The device model.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<any>} - The parsed service data.
+     */
+    static async parseServiceData(model, serviceData, manufacturerData, emitLog) {
+        switch (model) {
+            case SwitchBotBLEModel.Bot:
+                return WoHand.parseServiceData(serviceData, emitLog);
+            case SwitchBotBLEModel.Curtain:
+            case SwitchBotBLEModel.Curtain3:
+                return WoCurtain.parseServiceData(serviceData, manufacturerData, emitLog);
+            case SwitchBotBLEModel.Humidifier:
+                return WoHumi.parseServiceData(serviceData, emitLog);
+            case SwitchBotBLEModel.Humidifier2:
+                return WoHumi2.parseServiceData(serviceData, emitLog);
+            case SwitchBotBLEModel.Meter:
+                return WoSensorTH.parseServiceData(serviceData, emitLog);
+            case SwitchBotBLEModel.MeterPlus:
+                return WoSensorTHPlus.parseServiceData(serviceData, emitLog);
+            case SwitchBotBLEModel.MeterPro:
+                return WoSensorTHPro.parseServiceData(serviceData, emitLog);
+            case SwitchBotBLEModel.MeterProCO2:
+                return WoSensorTHProCO2.parseServiceData(serviceData, manufacturerData, emitLog);
+            case SwitchBotBLEModel.Hub2:
+                return WoHub2.parseServiceData(manufacturerData, emitLog);
+            case SwitchBotBLEModel.OutdoorMeter:
+                return WoIOSensorTH.parseServiceData(serviceData, manufacturerData, emitLog);
+            case SwitchBotBLEModel.MotionSensor:
+                return WoPresence.parseServiceData(serviceData, emitLog);
+            case SwitchBotBLEModel.ContactSensor:
+                return WoContact.parseServiceData(serviceData, emitLog);
+            case SwitchBotBLEModel.Remote:
+                return WoRemote.parseServiceData(serviceData, emitLog);
+            case SwitchBotBLEModel.ColorBulb:
+                return WoBulb.parseServiceData(serviceData, manufacturerData, emitLog);
+            case SwitchBotBLEModel.CeilingLight:
+                return WoCeilingLight.parseServiceData(manufacturerData, emitLog);
+            case SwitchBotBLEModel.CeilingLightPro:
+                return WoCeilingLight.parseServiceData_Pro(manufacturerData, emitLog);
+            case SwitchBotBLEModel.StripLight:
+                return WoStrip.parseServiceData(serviceData, emitLog);
+            case SwitchBotBLEModel.PlugMiniUS:
+                return WoPlugMiniUS.parseServiceData(manufacturerData, emitLog);
+            case SwitchBotBLEModel.PlugMiniJP:
+                return WoPlugMiniJP.parseServiceData(manufacturerData, emitLog);
+            case SwitchBotBLEModel.Lock:
+                return WoSmartLock.parseServiceData(serviceData, manufacturerData, emitLog);
+            case SwitchBotBLEModel.LockPro:
+                return WoSmartLockPro.parseServiceData(serviceData, manufacturerData, emitLog);
+            case SwitchBotBLEModel.BlindTilt:
+                return WoBlindTilt.parseServiceData(serviceData, manufacturerData, emitLog);
+            case SwitchBotBLEModel.Leak:
+                return WoLeak.parseServiceData(serviceData, manufacturerData, emitLog);
+            case SwitchBotBLEModel.RelaySwitch1:
+                return WoRelaySwitch1.parseServiceData(serviceData, manufacturerData, emitLog);
+            case SwitchBotBLEModel.RelaySwitch1PM:
+                return WoRelaySwitch1PM.parseServiceData(serviceData, manufacturerData, emitLog);
+            default:
+                emitLog('debug', `[parseAdvertising.${model}] return null, model "${model}" not available!`);
+                return null;
+        }
+    }
+    /**
+     * Formats the address of the peripheral.
+     *
+     * @param {NobleTypes['peripheral']} peripheral - The peripheral device object from noble.
+     * @returns {string} - The formatted address.
+     */
+    static formatAddress(peripheral) {
+        let address = peripheral.address || '';
+        if (address === '') {
+            const str = peripheral.advertisement.manufacturerData?.toString('hex').slice(4, 16) || '';
+            if (str !== '') {
+                address = str.match(/.{1,2}/g)?.join(':') || '';
+            }
+        }
+        else {
+            address = address.replace(/-/g, ':');
+        }
+        return address;
+    }
+}
+/**
+ * Class representing a WoBlindTilt device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/curtain.md
+ */
+export class WoBlindTilt extends SwitchbotDevice {
+    reverse = false;
+    /**
+     * Parses the service data and manufacturer data for the WoBlindTilt device.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @param {boolean} [reverse] - Whether to reverse the tilt percentage.
+     * @returns {Promise<blindTiltServiceData | null>} - The parsed data object or null if the data is invalid.
+     */
+    static async parseServiceData(serviceData, manufacturerData, emitLog, reverse = false) {
+        if (![5, 6].includes(manufacturerData.length)) {
+            emitLog('debugerror', `[parseServiceDataForWoBlindTilt] Buffer length ${manufacturerData.length} !== 5 or 6!`);
+            return null;
+        }
+        const byte2 = serviceData.readUInt8(2);
+        const byte6 = manufacturerData.subarray(6);
+        const tilt = Math.max(Math.min(byte6.readUInt8(2) & 0b01111111, 100), 0);
+        const inMotion = !!(byte2 & 0b10000000);
+        const lightLevel = (byte6.readUInt8(1) >> 4) & 0b00001111;
+        const calibration = !!(byte6.readUInt8(1) & 0b00000001);
+        const sequenceNumber = byte6.readUInt8(0);
+        const battery = serviceData.length > 2 ? byte2 & 0b01111111 : 0;
+        const data = {
+            model: SwitchBotBLEModel.BlindTilt,
+            modelName: SwitchBotBLEModelName.BlindTilt,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.BlindTilt,
+            calibration,
+            battery,
+            inMotion,
+            tilt: reverse ? 100 - tilt : tilt,
+            lightLevel,
+            sequenceNumber,
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Opens the blind tilt to the fully open position.
+     * @returns {Promise<void>}
+     */
+    async open() {
+        await this.operateBlindTilt([0x57, 0x0F, 0x45, 0x01, 0x05, 0xFF, 0x32]);
+    }
+    /**
+     * Closes the blind tilt up to the nearest endpoint.
+     * @returns {Promise<void>}
+     */
+    async closeUp() {
+        await this.operateBlindTilt([0x57, 0x0F, 0x45, 0x01, 0x05, 0xFF, 0x64]);
+    }
+    /**
+     * Closes the blind tilt down to the nearest endpoint.
+     * @returns {Promise<void>}
+     */
+    async closeDown() {
+        await this.operateBlindTilt([0x57, 0x0F, 0x45, 0x01, 0x05, 0xFF, 0x00]);
+    }
+    /**
+     * Closes the blind tilt to the nearest endpoint.
+     * @returns {Promise<void>}
+     */
+    async close() {
+        const position = await this.getPosition();
+        if (position > 50) {
+            await this.closeUp();
+        }
+        else {
+            await this.closeDown();
+        }
+    }
+    /**
+     * Retrieves the current position of the blind tilt.
+     * @returns {Promise<number>} - The current position of the blind tilt (0-100).
+     */
+    async getPosition() {
+        const tiltPosition = await this._getAdvValue('tilt');
+        return Math.max(0, Math.min(tiltPosition, 100));
+    }
+    /**
+     * Retrieves the advertised value for a given key.
+     * @param {string} key - The key for the advertised value.
+     * @returns {Promise<number>} - The advertised value.
+     * @private
+     */
+    async _getAdvValue(key) {
+        if (key === 'tilt') {
+            return 50; // Example value
+        }
+        throw new Error(`Unknown key: ${key}`);
+    }
+    /**
+     * Retrieves the basic information of the blind tilt.
+     * @returns {Promise<object | null>} - A promise that resolves to an object containing the basic information of the blind tilt.
+     */
+    async getBasicInfo() {
+        const data = await this.getBasicInfo();
+        if (!data) {
+            return null;
+        }
+        const tilt = Math.max(Math.min(data[6], 100), 0);
+        const moving = Boolean(data[5] & 0b00000011);
+        let opening = false;
+        let closing = false;
+        let up = false;
+        if (moving) {
+            opening = Boolean(data[5] & 0b00000010);
+            closing = !opening && Boolean(data[5] & 0b00000001);
+            if (opening) {
+                const flag = Boolean(data[5] & 0b00000001);
+                up = flag ? this.reverse : !flag;
+            }
+            else {
+                up = tilt < 50 ? this.reverse : tilt > 50;
+            }
+        }
+        return {
+            battery: data[1],
+            firmware: data[2] / 10.0,
+            light: Boolean(data[4] & 0b00100000),
+            fault: Boolean(data[4] & 0b00001000),
+            solarPanel: Boolean(data[5] & 0b00001000),
+            calibration: Boolean(data[5] & 0b00000100),
+            calibrated: Boolean(data[5] & 0b00000100),
+            inMotion: moving,
+            motionDirection: {
+                opening: moving && opening,
+                closing: moving && closing,
+                up: moving && up,
+                down: moving && !up,
+            },
+            tilt: this.reverse ? 100 - tilt : tilt,
+            timers: data[7],
+        };
+    }
+    /**
+     * Pauses the blind tilt operation.
+     * @returns {Promise<void>}
+     */
+    async pause() {
+        await this.operateBlindTilt([0x57, 0x0F, 0x45, 0x01, 0x00, 0xFF]);
+    }
+    /**
+     * Runs the blind tilt to the specified position.
+     * @param {number} percent - The target position percentage (0-100).
+     * @param {number} mode - The running mode (0 or 1).
+     * @returns {Promise<void>}
+     */
+    async runToPos(percent, mode) {
+        if (typeof percent !== 'number' || percent < 0 || percent > 100) {
+            throw new RangeError('Percent must be a number between 0 and 100');
+        }
+        if (typeof mode !== 'number' || mode < 0 || mode > 1) {
+            throw new RangeError('Mode must be a number between 0 and 1');
+        }
+        await this.operateBlindTilt([0x57, 0x0F, 0x45, 0x01, 0x05, mode, percent]);
+    }
+    /**
+     * Sends a command to operate the blind tilt and handles the response.
+     * @param {number[]} bytes - The byte array representing the command to be sent to the device.
+     * @returns {Promise<void>}
+     * @private
+     */
+    async operateBlindTilt(bytes) {
+        const reqBuf = Buffer.from(bytes);
+        const resBuf = await this.command(reqBuf);
+        if (resBuf.length !== 3 || resBuf.readUInt8(0) !== 0x01) {
+            throw new Error(`The device returned an error: 0x${resBuf.toString('hex')}`);
+        }
+    }
+}
+/**
+ * Class representing a WoBulb device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/colorbulb.md
+ */
+export class WoBulb extends SwitchbotDevice {
+    /**
+     * Parses the service data for WoBulb.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<colorBulbServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, manufacturerData, 
+    // eslint-disable-next-line unused-imports/no-unused-vars
+    emitLog) {
+        if (serviceData.length !== 18) {
+            // emitLog('debugerror', `[parseServiceDataForWoBulb] Buffer length ${serviceData.length} !== 18!`)
+            return null;
+        }
+        if (manufacturerData.length !== 13) {
+            // emitLog('debugerror', `[parseServiceDataForWoBulb] Buffer length ${manufacturerData.length} !== 13!`)
+            return null;
+        }
+        const [, byte1, , byte3, byte4, byte5, byte6, byte7, byte8, byte9, byte10,] = manufacturerData;
+        const data = {
+            model: SwitchBotBLEModel.ColorBulb,
+            modelName: SwitchBotBLEModelName.ColorBulb,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.ColorBulb,
+            power: !!byte1,
+            red: byte3,
+            green: byte4,
+            blue: byte5,
+            color_temperature: byte6,
+            state: !!(byte7 & 0b01111111),
+            brightness: byte7 & 0b01111111,
+            delay: (byte8 & 0b10000000) >> 7,
+            preset: (byte8 & 0b00001000) >> 3,
+            color_mode: byte8 & 0b00000111,
+            speed: byte9 & 0b01111111,
+            loop_index: byte10 & 0b11111110,
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Reads the state of the bulb.
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the bulb is ON (true) or OFF (false).
+     */
+    async readState() {
+        return this.operateBulb([0x57, 0x0F, 0x48, 0x01]);
+    }
+    /**
+     * Sets the state of the bulb.
+     * @param {number[]} reqByteArray - The request byte array.
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the operation was successful.
+     * @private
+     */
+    async setState(reqByteArray) {
+        const base = [0x57, 0x0F, 0x47, 0x01];
+        return this.operateBulb(base.concat(reqByteArray));
+    }
+    /**
+     * Turns on the bulb.
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the bulb is ON (true).
+     */
+    async turnOn() {
+        return this.setState([0x01, 0x01]);
+    }
+    /**
+     * Turns off the bulb.
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the bulb is OFF (false).
+     */
+    async turnOff() {
+        return this.setState([0x01, 0x02]);
+    }
+    /**
+     * Sets the brightness of the bulb.
+     * @param {number} brightness - The brightness percentage (0-100).
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the operation was successful.
+     */
+    async setBrightness(brightness) {
+        if (brightness < 0 || brightness > 100) {
+            throw new RangeError('Brightness must be between 0 and 100');
+        }
+        return this.setState([0x02, 0x14, brightness]);
+    }
+    /**
+     * Sets the color temperature of the bulb.
+     * @param {number} color_temperature - The color temperature percentage (0-100).
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the operation was successful.
+     */
+    async setColorTemperature(color_temperature) {
+        if (color_temperature < 0 || color_temperature > 100) {
+            throw new RangeError('Color temperature must be between 0 and 100');
+        }
+        return this.setState([0x02, 0x17, color_temperature]);
+    }
+    /**
+     * Sets the RGB color of the bulb.
+     * @param {number} brightness - The brightness percentage (0-100).
+     * @param {number} red - The red color value (0-255).
+     * @param {number} green - The green color value (0-255).
+     * @param {number} blue - The blue color value (0-255).
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the operation was successful.
+     */
+    async setRGB(brightness, red, green, blue) {
+        if (brightness < 0 || brightness > 100 || red < 0 || red > 255 || green < 0 || green > 255 || blue < 0 || blue > 255) {
+            throw new RangeError('Invalid RGB or brightness values');
+        }
+        return this.setState([0x02, 0x12, brightness, red, green, blue]);
+    }
+    /**
+     * Sends a command to the bulb.
+     * @param {number[]} bytes - The command bytes.
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the operation was successful.
+     * @private
+     */
+    async operateBulb(bytes) {
+        const reqBuf = Buffer.from(bytes);
+        const resBuf = await this.command(reqBuf);
+        if (resBuf.length === 2) {
+            const code = resBuf.readUInt8(1);
+            if (code === 0x00 || code === 0x80) {
+                return code === 0x80;
+            }
+            throw new Error(`The device returned an error: 0x${resBuf.toString('hex')}`);
+        }
+        throw new Error(`Expecting a 2-byte response, got instead: 0x${resBuf.toString('hex')}`);
+    }
+}
+/**
+ * Class representing a WoCeilingLight device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/colorbulb.md
+ */
+export class WoCeilingLight extends SwitchbotDevice {
+    /**
+     * Parses the service data for WoCeilingLight.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<ceilingLightServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(manufacturerData, emitLog) {
+        if (manufacturerData.length !== 13) {
+            emitLog('debugerror', `[parseServiceDataForWoCeilingLight] Buffer length ${manufacturerData.length} !== 13!`);
+            return null;
+        }
+        const [, byte1, , byte3, byte4, byte5, byte6, byte7, byte8, byte9, byte10,] = manufacturerData;
+        const data = {
+            model: SwitchBotBLEModel.CeilingLight,
+            modelName: SwitchBotBLEModelName.CeilingLight,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.CeilingLight,
+            power: !!byte1,
+            red: byte3,
+            green: byte4,
+            blue: byte5,
+            color_temperature: byte6,
+            state: !!(byte7 & 0b01111111),
+            brightness: byte7 & 0b01111111,
+            delay: (byte8 & 0b10000000) ? 1 : 0,
+            preset: (byte8 & 0b00001000) ? 1 : 0,
+            color_mode: byte8 & 0b00000111,
+            speed: byte9 & 0b01111111,
+            loop_index: byte10 & 0b11111110,
+        };
+        return data;
+    }
+    /**
+     * Parses the service data for WoCeilingLight Pro.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<ceilingLightProServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData_Pro(manufacturerData, emitLog) {
+        if (manufacturerData.length !== 13) {
+            emitLog('debugerror', `[parseServiceDataForWoCeilingLightPro] Buffer length ${manufacturerData.length} !== 13!`);
+            return null;
+        }
+        const [, byte1, , byte3, byte4, byte5, byte6, byte7, byte8, byte9, byte10,] = manufacturerData;
+        const data = {
+            model: SwitchBotBLEModel.CeilingLightPro,
+            modelName: SwitchBotBLEModelName.CeilingLightPro,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.CeilingLightPro,
+            power: !!byte1,
+            red: byte3,
+            green: byte4,
+            blue: byte5,
+            color_temperature: byte6,
+            state: !!(byte7 & 0b01111111),
+            brightness: byte7 & 0b01111111,
+            delay: (byte8 & 0b10000000) ? 1 : 0,
+            preset: (byte8 & 0b00001000) ? 1 : 0,
+            color_mode: byte8 & 0b00000111,
+            speed: byte9 & 0b01111111,
+            loop_index: byte10 & 0b11111110,
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Reads the state of the ceiling light.
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the light is ON (true) or OFF (false).
+     */
+    async readState() {
+        return this.operateCeilingLight([0x57, 0x0F, 0x48, 0x01]);
+    }
+    /**
+     * Sets the state of the ceiling light.
+     * @param {number[]} reqByteArray - The request byte array.
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the operation was successful.
+     */
+    async setState(reqByteArray) {
+        const base = [0x57, 0x0F, 0x47, 0x01];
+        return this.operateCeilingLight(base.concat(reqByteArray));
+    }
+    /**
+     * Turns on the ceiling light.
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the light is ON (true).
+     */
+    async turnOn() {
+        return this.setState([0x01, 0x01]);
+    }
+    /**
+     * Turns off the ceiling light.
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the light is OFF (false).
+     */
+    async turnOff() {
+        return this.setState([0x01, 0x02]);
+    }
+    /**
+     * Sets the brightness of the ceiling light.
+     * @param {number} brightness - The brightness percentage (0-100).
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the operation was successful.
+     */
+    async setBrightness(brightness) {
+        if (typeof brightness !== 'number' || brightness < 0 || brightness > 100) {
+            throw new TypeError(`Invalid brightness value: ${brightness}`);
+        }
+        return this.setState([0x02, 0x14, brightness]);
+    }
+    /**
+     * Sets the color temperature of the ceiling light.
+     * @param {number} color_temperature - The color temperature percentage (0-100).
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the operation was successful.
+     */
+    async setColorTemperature(color_temperature) {
+        if (typeof color_temperature !== 'number' || color_temperature < 0 || color_temperature > 100) {
+            throw new TypeError(`Invalid color temperature value: ${color_temperature}`);
+        }
+        return this.setState([0x02, 0x17, color_temperature]);
+    }
+    /**
+     * Sets the RGB color of the ceiling light.
+     * @param {number} brightness - The brightness percentage (0-100).
+     * @param {number} red - The red color value (0-255).
+     * @param {number} green - The green color value (0-255).
+     * @param {number} blue - The blue color value (0-255).
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the operation was successful.
+     */
+    async setRGB(brightness, red, green, blue) {
+        if (typeof brightness !== 'number' || brightness < 0 || brightness > 100
+            || typeof red !== 'number' || red < 0 || red > 255
+            || typeof green !== 'number' || green < 0 || green > 255
+            || typeof blue !== 'number' || blue < 0 || blue > 255) {
+            throw new TypeError('Invalid RGB or brightness values');
+        }
+        return this.setState([0x02, 0x12, brightness, red, green, blue]);
+    }
+    /**
+     * Sends a command to the ceiling light.
+     * @param {number[]} bytes - The command bytes.
+     * @returns {Promise<boolean>} - Resolves with a boolean indicating whether the operation was successful.
+     */
+    async operateCeilingLight(bytes) {
+        const reqBuf = Buffer.from(bytes);
+        const resBuf = await this.command(reqBuf);
+        if (resBuf.length === 2) {
+            const code = resBuf.readUInt8(1);
+            if (code === 0x00 || code === 0x80) {
+                return code === 0x80;
+            }
+            throw new Error(`The device returned an error: 0x${resBuf.toString('hex')}`);
+        }
+        throw new Error(`Expecting a 2-byte response, got instead: 0x${resBuf.toString('hex')}`);
+    }
+}
+/**
+ * Class representing a WoContact device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/contactsensor.md
+ */
+export class WoContact extends SwitchbotDevice {
+    /**
+     * Parses the service data for WoContact.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<contactSensorServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, emitLog) {
+        if (serviceData.length !== 9) {
+            emitLog('debugerror', `[parseServiceDataForWoContact] Buffer length ${serviceData.length} !== 9!`);
+            return null;
+        }
+        const [byte1, byte2, byte3, , , , , , byte8] = serviceData;
+        const hallState = (byte3 >> 1) & 0b00000011;
+        const tested = Boolean(byte1 & 0b10000000);
+        const movement = Boolean(byte1 & 0b01000000);
+        const battery = byte2 & 0b01111111;
+        const contact_open = Boolean(byte3 & 0b00000010);
+        const contact_timeout = Boolean(byte3 & 0b00000100);
+        const lightLevel = byte3 & 0b00000001 ? 'bright' : 'dark';
+        const button_count = byte8 & 0b00001111;
+        const doorState = hallState === 0 ? 'close' : hallState === 1 ? 'open' : 'timeout no closed';
+        const data = {
+            model: SwitchBotBLEModel.ContactSensor,
+            modelName: SwitchBotBLEModelName.ContactSensor,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.ContactSensor,
+            movement,
+            tested,
+            battery,
+            contact_open,
+            contact_timeout,
+            lightLevel,
+            button_count,
+            doorState,
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+}
+/**
+ * Class representing a WoCurtain device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/curtain.md
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/curtain3.md
+ */
+export class WoCurtain extends SwitchbotDevice {
+    /**
+     * Parses the service data for WoCurtain.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @param {boolean} [reverse] - Whether to reverse the position.
+     * @returns {Promise<curtainServiceData | curtain3ServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, manufacturerData, emitLog, reverse = false) {
+        if (![5, 6].includes(serviceData.length)) {
+            emitLog('debugerror', `[parseServiceDataForWoCurtain] Buffer length ${serviceData.length} !== 5 or 6!`);
+            return null;
+        }
+        const byte1 = serviceData.readUInt8(1);
+        const byte2 = serviceData.readUInt8(2);
+        let deviceData;
+        let batteryData = null;
+        if (manufacturerData.length >= 13) {
+            deviceData = manufacturerData.subarray(8, 11);
+            batteryData = manufacturerData.readUInt8(12);
+        }
+        else if (manufacturerData.length >= 11) {
+            deviceData = manufacturerData.subarray(8, 11);
+            batteryData = byte2;
+        }
+        else {
+            deviceData = serviceData.subarray(3, 6);
+            batteryData = byte2;
+        }
+        const model = serviceData.subarray(0, 1).toString('utf8') ? SwitchBotBLEModel.Curtain : SwitchBotBLEModel.Curtain3;
+        const calibration = Boolean(byte1 & 0b01000000);
+        if (model === SwitchBotBLEModel.Curtain) {
+            const byte3 = serviceData.readUInt8(3);
+            const byte4 = serviceData.readUInt8(4);
+            const position = byte3 & 0b01111111;
+            const inMotion = Boolean(byte3 & 0b10000000);
+            const lightLevel = (byte4 >> 4) & 0b00001111;
+            const deviceChain = byte4 & 0b00000111;
+            const battery = byte2 & 0b01111111;
+            const data = {
+                model: SwitchBotBLEModel.Curtain,
+                modelName: SwitchBotBLEModelName.Curtain,
+                modelFriendlyName: SwitchBotBLEModelFriendlyName.Curtain,
+                calibration,
+                battery: battery ?? 0,
+                inMotion,
+                position: reverse ? 100 - position : position,
+                lightLevel,
+                deviceChain,
+            };
+            return data;
+        }
+        else {
+            const position = Math.max(Math.min(deviceData.readUInt8(0) & 0b01111111, 100), 0);
+            const inMotion = Boolean(deviceData.readUInt8(0) & 0b10000000);
+            const lightLevel = (deviceData.readUInt8(1) >> 4) & 0b00001111;
+            const deviceChain = deviceData.readUInt8(1) & 0b00000111;
+            const battery = batteryData !== null ? batteryData & 0b01111111 : 0;
+            const data = {
+                model: SwitchBotBLEModel.Curtain3,
+                modelName: SwitchBotBLEModelName.Curtain3,
+                modelFriendlyName: SwitchBotBLEModelFriendlyName.Curtain3,
+                calibration,
+                battery,
+                inMotion,
+                position: reverse ? 100 - position : position,
+                lightLevel,
+                deviceChain,
+            };
+            return data;
+        }
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Opens the curtain.
+     * @param {number} [mode] - Running mode (0x01 = QuietDrift, 0xFF = Default).
+     * @returns {Promise<void>}
+     */
+    async open(mode = 0xFF) {
+        await this.runToPos(0, mode);
+    }
+    /**
+     * Closes the curtain.
+     * @param {number} [mode] - Running mode (0x01 = QuietDrift, 0xFF = Default).
+     * @returns {Promise<void>}
+     */
+    async close(mode = 0xFF) {
+        await this.runToPos(100, mode);
+    }
+    /**
+     * Pauses the curtain.
+     * @returns {Promise<void>}
+     */
+    async pause() {
+        await this.operateCurtain([0x57, 0x0F, 0x45, 0x01, 0x00, 0xFF]);
+    }
+    /**
+     * Runs the curtain to the target position.
+     * @param {number} percent - The percentage of the target position.
+     * @param {number} [mode] - Running mode (0x01 = QuietDrift, 0xFF = Default).
+     * @returns {Promise<void>}
+     */
+    async runToPos(percent, mode = 0xFF) {
+        if (typeof percent !== 'number' || typeof mode !== 'number') {
+            throw new TypeError('Invalid type for percent or mode');
+        }
+        percent = Math.max(0, Math.min(100, percent));
+        await this.operateCurtain([0x57, 0x0F, 0x45, 0x01, 0x05, mode, percent]);
+    }
+    /**
+     * Sends a command to the curtain.
+     * @param {number[]} bytes - The command bytes.
+     * @returns {Promise<void>}
+     */
+    async operateCurtain(bytes) {
+        const reqBuf = Buffer.from(bytes);
+        const resBuf = await this.command(reqBuf);
+        const code = resBuf.readUInt8(0);
+        if (resBuf.length !== 3 || code !== 0x01) {
+            throw new Error(`The device returned an error: 0x${resBuf.toString('hex')}`);
+        }
+    }
+}
+/**
+ * Class representing a WoHand device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/bot.md
+ */
+export class WoHand extends SwitchbotDevice {
+    /**
+     * Parses the service data for WoHand.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<botServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, emitLog) {
+        if (!serviceData || serviceData.length < 3) {
+            emitLog('debugerror', `[parseServiceData] Service Data Buffer length ${serviceData?.length ?? 0} < 3!`);
+            return null;
+        }
+        const byte1 = serviceData.readUInt8(1);
+        const byte2 = serviceData.readUInt8(2);
+        const data = {
+            model: SwitchBotBLEModel.Bot,
+            modelName: SwitchBotBLEModelName.Bot,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.Bot,
+            mode: !!(byte1 & 0b10000000), // Whether the light switch Add-on is used or not. 0 = press, 1 = switch
+            state: !!(byte1 & 0b01000000), // Whether the switch status is ON or OFF. 0 = on, 1 = off
+            battery: byte2 & 0b01111111, // %
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Sends a command to the bot.
+     * @param {Buffer} reqBuf - The command buffer.
+     * @returns {Promise<void>}
+     */
+    async sendCommand(reqBuf) {
+        const resBuf = await this.command(reqBuf);
+        const code = resBuf.readUInt8(0);
+        if (resBuf.length !== 3 || (code !== 0x01 && code !== 0x05)) {
+            throw new Error(`The device returned an error: 0x${resBuf.toString('hex')}`);
+        }
+    }
+    /**
+     * Presses the bot.
+     * @returns {Promise<void>}
+     */
+    async press() {
+        await this.sendCommand(Buffer.from([0x57, 0x01, 0x00]));
+    }
+    /**
+     * Turns on the bot.
+     * @returns {Promise<void>}
+     */
+    async turnOn() {
+        await this.sendCommand(Buffer.from([0x57, 0x01, 0x01]));
+    }
+    /**
+     * Turns off the bot.
+     * @returns {Promise<void>}
+     */
+    async turnOff() {
+        await this.sendCommand(Buffer.from([0x57, 0x01, 0x02]));
+    }
+    /**
+     * Moves the bot down.
+     * @returns {Promise<void>}
+     */
+    async down() {
+        await this.sendCommand(Buffer.from([0x57, 0x01, 0x03]));
+    }
+    /**
+     * Moves the bot up.
+     * @returns {Promise<void>}
+     */
+    async up() {
+        await this.sendCommand(Buffer.from([0x57, 0x01, 0x04]));
+    }
+}
+/**
+ * Class representing a WoHub2 device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/meter.md
+ */
+export class WoHub2 extends SwitchbotDevice {
+    /**
+     * Parses the service data for WoHub2.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<hub2ServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(manufacturerData, emitLog) {
+        if (manufacturerData.length !== 16) {
+            emitLog('debugerror', `[parseServiceDataForWoHub2] Buffer length ${manufacturerData.length} !== 16!`);
+            return null;
+        }
+        const [byte0, byte1, byte2, , , , , , , , , , byte12] = manufacturerData;
+        const tempSign = byte1 & 0b10000000 ? 1 : -1;
+        const tempC = tempSign * ((byte1 & 0b01111111) + (byte0 & 0b00001111) / 10);
+        const tempF = Math.round(((tempC * 9) / 5 + 32) * 10) / 10;
+        const lightLevel = byte12 & 0b11111;
+        const data = {
+            model: SwitchBotBLEModel.Hub2,
+            modelName: SwitchBotBLEModelName.Hub2,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.Hub2,
+            celsius: tempC,
+            fahrenheit: tempF,
+            fahrenheit_mode: !!(byte2 & 0b10000000),
+            humidity: byte2 & 0b01111111,
+            lightLevel,
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+}
+/**
+ * Class representing a WoHumi device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/tree/latest/devicetypes
+ */
+export class WoHumi extends SwitchbotDevice {
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Parses the service data for WoHumi.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<humidifierServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, emitLog) {
+        if (serviceData.length !== 8) {
+            emitLog('debugerror', `[parseServiceDataForWoHumi] Buffer length ${serviceData.length} !== 8!`);
+            return null;
+        }
+        const byte1 = serviceData.readUInt8(1);
+        const byte4 = serviceData.readUInt8(4);
+        const onState = !!(byte1 & 0b10000000); // 1 - on
+        const autoMode = !!(byte4 & 0b10000000); // 1 - auto
+        const percentage = byte4 & 0b01111111; // 0-100%, 101/102/103 - Quick gear 1/2/3
+        const humidity = autoMode ? 0 : percentage === 101 ? 33 : percentage === 102 ? 66 : percentage === 103 ? 100 : percentage;
+        const data = {
+            model: SwitchBotBLEModel.Humidifier,
+            modelName: SwitchBotBLEModelName.Humidifier,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.Humidifier,
+            onState,
+            autoMode,
+            percentage: autoMode ? 0 : percentage,
+            humidity,
+        };
+        return data;
+    }
+    /**
+     * Sends a command to the humidifier.
+     * @param {Buffer} reqBuf - The command buffer.
+     * @returns {Promise<void>}
+     */
+    async operateHumi(reqBuf) {
+        const resBuf = await this.command(reqBuf);
+        const code = resBuf.readUInt8(0);
+        if (resBuf.length !== 3 || (code !== 0x01 && code !== 0x05)) {
+            throw new Error(`The device returned an error: 0x${resBuf.toString('hex')}`);
+        }
+    }
+    /**
+     * Turns on the humidifier.
+     * @returns {Promise<void>}
+     */
+    async turnOn() {
+        await this.operateHumi(Buffer.from(TURN_ON_KEY, 'hex'));
+    }
+    /**
+     * Turns off the humidifier.
+     * @returns {Promise<void>}
+     */
+    async turnOff() {
+        await this.operateHumi(Buffer.from(TURN_OFF_KEY, 'hex'));
+    }
+    /**
+     * Increases the humidifier setting.
+     * @returns {Promise<void>}
+     */
+    async increase() {
+        await this.operateHumi(Buffer.from(INCREASE_KEY, 'hex'));
+    }
+    /**
+     * Decreases the humidifier setting.
+     * @returns {Promise<void>}
+     */
+    async decrease() {
+        await this.operateHumi(Buffer.from(DECREASE_KEY, 'hex'));
+    }
+    /**
+     * Sets the humidifier to auto mode.
+     * @returns {Promise<void>}
+     */
+    async setAutoMode() {
+        await this.operateHumi(Buffer.from(SET_AUTO_MODE_KEY, 'hex'));
+    }
+    /**
+     * Sets the humidifier to manual mode.
+     * @returns {Promise<void>}
+     */
+    async setManualMode() {
+        await this.operateHumi(Buffer.from(SET_MANUAL_MODE_KEY, 'hex'));
+    }
+    /**
+     * Sets the humidifier level.
+     * @param {number} level - The level to set (0-100).
+     * @returns {Promise<void>}
+     */
+    async percentage(level) {
+        if (level < 0 || level > 100) {
+            throw new Error('Level must be between 0 and 100');
+        }
+        const levelKey = `${HUMIDIFIER_COMMAND_HEADER}0107${level.toString(16).padStart(2, '0')}`;
+        await this.operateHumi(Buffer.from(levelKey, 'hex'));
+    }
+}
+/**
+ * Class representing a WoHumi device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/tree/latest/devicetypes
+ */
+export class WoHumi2 extends SwitchbotDevice {
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Parses the service data for WoHumi.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<humidifier2ServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, emitLog) {
+        if (serviceData.length !== 8) {
+            emitLog('debugerror', `[parseServiceDataForWoHumi] Buffer length ${serviceData.length} !== 8!`);
+            return null;
+        }
+        const byte1 = serviceData.readUInt8(1);
+        const byte4 = serviceData.readUInt8(4);
+        const byte8 = serviceData.readUInt8(8);
+        const byte10 = serviceData.readUInt8(10);
+        const byte11 = serviceData.readUInt8(11);
+        const byte12 = serviceData.readUInt8(12);
+        const onState = !!(byte1 & 0b10000000); // 1 - on
+        const autoMode = !!(byte4 & 0b10000000); // 1 - auto
+        const percentage = byte4 & 0b01111111; // 0-100%, 101/102/103 - Quick gear 1/2/3
+        const humidity = autoMode ? 0 : percentage === 101 ? 33 : percentage === 102 ? 66 : percentage === 103 ? 100 : percentage;
+        const childLock = !!(byte8 & 0b00100000);
+        const overHumidifyProtection = !!(byte8 & 0b10000000);
+        const tankRemoved = !!(byte8 & 0b00000100);
+        const tiltedAlert = !!(byte8 & 0b00000010);
+        const filterMissing = !!(byte8 & 0b00000001);
+        const temperature = (byte10 & 0b01111111) + (byte11 >> 4) / 10;
+        const filterRunTime = byte12;
+        const filterAlert = filterRunTime >= 240;
+        const waterLevel = byte11 & 0b00000011;
+        const data = {
+            model: SwitchBotBLEModel.Humidifier2,
+            modelName: SwitchBotBLEModelName.Humidifier2,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.Humidifier2,
+            onState,
+            autoMode,
+            percentage: autoMode ? 0 : percentage,
+            humidity,
+            childLock,
+            overHumidifyProtection,
+            tankRemoved,
+            tiltedAlert,
+            filterMissing,
+            temperature,
+            filterRunTime,
+            filterAlert,
+            waterLevel,
+        };
+        return data;
+    }
+    /**
+     * Sends a command to the humidifier.
+     * @param {Buffer} reqBuf - The command buffer.
+     * @returns {Promise<void>}
+     */
+    async operateHumi(reqBuf) {
+        const resBuf = await this.command(reqBuf);
+        const code = resBuf.readUInt8(0);
+        if (resBuf.length !== 3 || (code !== 0x01 && code !== 0x05)) {
+            throw new Error(`The device returned an error: 0x${resBuf.toString('hex')}`);
+        }
+    }
+    /**
+     * Turns on the humidifier.
+     * @returns {Promise<void>}
+     */
+    async turnOn() {
+        await this.operateHumi(Buffer.from(TURN_ON_KEY, 'hex'));
+    }
+    /**
+     * Turns off the humidifier.
+     * @returns {Promise<void>}
+     */
+    async turnOff() {
+        await this.operateHumi(Buffer.from(TURN_OFF_KEY, 'hex'));
+    }
+    /**
+     * Increases the humidifier setting.
+     * @returns {Promise<void>}
+     */
+    async increase() {
+        await this.operateHumi(Buffer.from(INCREASE_KEY, 'hex'));
+    }
+    /**
+     * Decreases the humidifier setting.
+     * @returns {Promise<void>}
+     */
+    async decrease() {
+        await this.operateHumi(Buffer.from(DECREASE_KEY, 'hex'));
+    }
+    /**
+     * Sets the humidifier to auto mode.
+     * @returns {Promise<void>}
+     */
+    async setAutoMode() {
+        await this.operateHumi(Buffer.from(SET_AUTO_MODE_KEY, 'hex'));
+    }
+    /**
+     * Sets the humidifier to manual mode.
+     * @returns {Promise<void>}
+     */
+    async setManualMode() {
+        await this.operateHumi(Buffer.from(SET_MANUAL_MODE_KEY, 'hex'));
+    }
+    /**
+     * Sets the humidifier level.
+     * @param {number} level - The level to set (0-100).
+     * @returns {Promise<void>}
+     */
+    async percentage(level) {
+        if (level < 0 || level > 100) {
+            throw new Error('Level must be between 0 and 100');
+        }
+        const levelKey = `${HUMIDIFIER_COMMAND_HEADER}0107${level.toString(16).padStart(2, '0')}`;
+        await this.operateHumi(Buffer.from(levelKey, 'hex'));
+    }
+}
+/**
+ * Class representing a WoIOSensorTH device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/meter.md#outdoor-temperaturehumidity-sensor
+ */
+export class WoIOSensorTH extends SwitchbotDevice {
+    /**
+     * Parses the service data for WoIOSensorTH.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<outdoorMeterServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, manufacturerData, emitLog) {
+        if (serviceData.length !== 3) {
+            emitLog('debugerror', `[parseServiceDataForWoIOSensorTH] Service Data Buffer length ${serviceData.length} !== 3!`);
+            return null;
+        }
+        if (manufacturerData.length !== 14) {
+            emitLog('debugerror', `[parseServiceDataForWoIOSensorTH] Manufacturer Data Buffer length ${manufacturerData.length} !== 14!`);
+            return null;
+        }
+        const [mdByte10, mdByte11, mdByte12] = [
+            manufacturerData.readUInt8(10),
+            manufacturerData.readUInt8(11),
+            manufacturerData.readUInt8(12),
+        ];
+        const sdByte2 = serviceData.readUInt8(2);
+        const tempSign = mdByte11 & 0b10000000 ? 1 : -1;
+        const tempC = tempSign * ((mdByte11 & 0b01111111) + (mdByte10 & 0b00001111) / 10);
+        const tempF = Math.round(((tempC * 9) / 5 + 32) * 10) / 10;
+        const data = {
+            model: SwitchBotBLEModel.OutdoorMeter,
+            modelName: SwitchBotBLEModelName.OutdoorMeter,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.OutdoorMeter,
+            celsius: tempC,
+            fahrenheit: tempF,
+            fahrenheit_mode: !!(mdByte12 & 0b10000000),
+            humidity: mdByte12 & 0b01111111,
+            battery: sdByte2 & 0b01111111,
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+}
+/**
+ * Class representing a WoKeypad device.
+ */
+export class WoKeypad extends SwitchbotDevice {
+    /**
+     * Parses the service data for WoKeypad.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<keypadDetectorServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, manufacturerData, emitLog) {
+        if (!serviceData || serviceData.length < 3) {
+            emitLog('debugerror', `[parseServiceDataForWoKeypad] Service Data Buffer length ${serviceData?.length ?? 0} < 3!`);
+            return null;
+        }
+        if (!manufacturerData || manufacturerData.length < 2) {
+            emitLog('debugerror', `[parseServiceDataForWoKeypad] Manufacturer Data Buffer length ${manufacturerData?.length ?? 0} < 2!`);
+            return null;
+        }
+        const modelId = serviceData.readUInt8(0);
+        if (modelId !== 0x26) {
+            // Not a Keypad
+            emitLog('debugerror', `[parseServiceDataForWoKeypad] Model ID ${modelId} !== 0x26!`);
+            return null;
+        }
+        const eventFlags = serviceData.readUInt8(1);
+        const keypadEventDetected = !!(eventFlags & 0b00000001); // Bit 0
+        const deviceTampered = !!(eventFlags & 0b00000010); // Bit 1
+        const batteryInfo = serviceData.readUInt8(2);
+        const batteryLevel = batteryInfo & 0b01111111; // Bits 0-6
+        const lowBattery = !!(batteryInfo & 0b10000000); // Bit 7
+        // Manufacturer data can be processed here if needed
+        const data = {
+            model: SwitchBotBLEModel.Keypad,
+            modelName: SwitchBotBLEModelName.Keypad,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.Keypad,
+            event: keypadEventDetected,
+            tampered: deviceTampered,
+            battery: batteryLevel,
+            low_battery: lowBattery,
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+}
+/**
+ * Class representing a WoLeak device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/meter.md#outdoor-temperaturehumidity-sensor
+ */
+export class WoLeak extends SwitchbotDevice {
+    /**
+     * Parses the service data for WoLeak.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<leakServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, manufacturerData, emitLog) {
+        if (!serviceData || serviceData.length < 3) {
+            emitLog('debugerror', `[parseServiceDataForWoLeakDetector] Service Data Buffer length ${serviceData?.length ?? 0} < 3!`);
+            return null;
+        }
+        if (!manufacturerData || manufacturerData.length < 2) {
+            emitLog('debugerror', `[parseServiceDataForWoLeakDetector] Manufacturer Data Buffer length ${manufacturerData?.length ?? 0} < 2!`);
+            return null;
+        }
+        const waterLeakDetected = !!(manufacturerData.readUInt8(8) & 0b00000001); // Bit 0
+        const deviceTampered = !!(manufacturerData.readUInt8(8) & 0b00000010); // Bit 1
+        const batteryLevel = manufacturerData.readUInt8(7) & 0b01111111; // Bits 0-6
+        const lowBattery = !!(manufacturerData.readUInt8(7) & 0b10000000); // Bit 7
+        // Manufacturer data can be processed here if needed
+        const data = {
+            model: SwitchBotBLEModel.Leak,
+            modelName: SwitchBotBLEModelName.Leak,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.Leak,
+            leak: waterLeakDetected,
+            tampered: deviceTampered,
+            battery: batteryLevel,
+            low_battery: lowBattery,
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+}
+/**
+ * Class representing a WoPlugMini device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/plugmini.md
+ */
+export class WoPlugMiniJP extends SwitchbotDevice {
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Parses the service data for WoPlugMini JP.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<plugMiniJPServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(manufacturerData, emitLog) {
+        if (manufacturerData.length !== 14) {
+            emitLog('debugerror', `[parseServiceDataForWoPlugMiniJP] Buffer length ${manufacturerData.length} should be 14`);
+            return null;
+        }
+        const [byte9, byte10, byte11, byte12, byte13] = [
+            manufacturerData.readUInt8(9),
+            manufacturerData.readUInt8(10),
+            manufacturerData.readUInt8(11),
+            manufacturerData.readUInt8(12),
+            manufacturerData.readUInt8(13),
+        ];
+        const state = byte9 === 0x00 ? 'off' : byte9 === 0x80 ? 'on' : null;
+        const delay = !!(byte10 & 0b00000001);
+        const timer = !!(byte10 & 0b00000010);
+        const syncUtcTime = !!(byte10 & 0b00000100);
+        const wifiRssi = byte11;
+        const overload = !!(byte12 & 0b10000000);
+        const currentPower = (((byte12 & 0b01111111) << 8) + byte13) / 10; // in watt
+        const data = {
+            model: SwitchBotBLEModel.PlugMiniJP,
+            modelName: SwitchBotBLEModelName.PlugMini,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.PlugMini,
+            state: state ?? 'unknown',
+            delay,
+            timer,
+            syncUtcTime,
+            wifiRssi,
+            overload,
+            currentPower,
+        };
+        return data;
+    }
+    /**
+     * Reads the state of the plug.
+     * @returns {Promise<boolean>} - Resolves with a boolean that tells whether the plug is ON (true) or OFF (false).
+     */
+    async readState() {
+        return this.operatePlug([0x57, 0x0F, 0x51, 0x01]);
+    }
+    /**
+     * Sets the state of the plug.
+     * @private
+     * @param {number[]} reqByteArray - The request byte array.
+     * @returns {Promise<boolean>} - Resolves with a boolean that tells whether the plug is ON (true) or OFF (false).
+     */
+    async setState(reqByteArray) {
+        const base = [0x57, 0x0F, 0x50, 0x01];
+        return this.operatePlug([...base, ...reqByteArray]);
+    }
+    /**
+     * Turns on the plug.
+     * @returns {Promise<boolean>} - Resolves with a boolean that tells whether the plug is ON (true) or OFF (false).
+     */
+    async turnOn() {
+        return this.setState([0x01, 0x80]);
+    }
+    /**
+     * Turns off the plug.
+     * @returns {Promise<boolean>} - Resolves with a boolean that tells whether the plug is ON (true) or OFF (false).
+     */
+    async turnOff() {
+        return this.setState([0x01, 0x00]);
+    }
+    /**
+     * Toggles the state of the plug.
+     * @returns {Promise<boolean>} - Resolves with a boolean that tells whether the plug is ON (true) or OFF (false).
+     */
+    async toggle() {
+        return this.setState([0x02, 0x80]);
+    }
+    /**
+     * Operates the plug with the given bytes.
+     * @param {number[]} bytes - The byte array to send to the plug.
+     * @returns {Promise<boolean>} - Resolves with a boolean that tells whether the plug is ON (true) or OFF (false).
+     */
+    async operatePlug(bytes) {
+        const reqBuf = Buffer.from(bytes);
+        const resBytes = await this.command(reqBuf);
+        const resBuf = Buffer.from(resBytes);
+        if (resBuf.length !== 2) {
+            throw new Error(`Expecting a 2-byte response, got instead: 0x${resBuf.toString('hex')}`);
+        }
+        const code = resBuf.readUInt8(1);
+        if (code === 0x00 || code === 0x80) {
+            return code === 0x80;
+        }
+        else {
+            throw new Error(`The device returned an error: 0x${resBuf.toString('hex')}`);
+        }
+    }
+}
+/**
+ * Class representing a WoPlugMini device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/plugmini.md
+ */
+export class WoPlugMiniUS extends SwitchbotDevice {
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Parses the service data for WoPlugMini US.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<plugMiniUSServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(manufacturerData, emitLog) {
+        if (manufacturerData.length !== 14) {
+            emitLog('debugerror', `[parseServiceDataForWoPlugMini] Buffer length ${manufacturerData.length} should be 14`);
+            return null;
+        }
+        const [byte9, byte10, byte11, byte12, byte13] = [
+            manufacturerData.readUInt8(9),
+            manufacturerData.readUInt8(10),
+            manufacturerData.readUInt8(11),
+            manufacturerData.readUInt8(12),
+            manufacturerData.readUInt8(13),
+        ];
+        const state = byte9 === 0x00 ? 'off' : byte9 === 0x80 ? 'on' : null;
+        const delay = !!(byte10 & 0b00000001);
+        const timer = !!(byte10 & 0b00000010);
+        const syncUtcTime = !!(byte10 & 0b00000100);
+        const wifiRssi = byte11;
+        const overload = !!(byte12 & 0b10000000);
+        const currentPower = (((byte12 & 0b01111111) << 8) + byte13) / 10; // in watt
+        const data = {
+            model: SwitchBotBLEModel.PlugMiniUS,
+            modelName: SwitchBotBLEModelName.PlugMini,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.PlugMini,
+            state: state ?? 'unknown',
+            delay,
+            timer,
+            syncUtcTime,
+            wifiRssi,
+            overload,
+            currentPower,
+        };
+        return data;
+    }
+    /**
+     * Reads the state of the plug.
+     * @returns {Promise<boolean>} - Resolves with a boolean that tells whether the plug is ON (true) or OFF (false).
+     */
+    async readState() {
+        return this.operatePlug([0x57, 0x0F, 0x51, 0x01]);
+    }
+    /**
+     * Sets the state of the plug.
+     * @private
+     * @param {number[]} reqByteArray - The request byte array.
+     * @returns {Promise<boolean>} - Resolves with a boolean that tells whether the plug is ON (true) or OFF (false).
+     */
+    async setState(reqByteArray) {
+        const base = [0x57, 0x0F, 0x50, 0x01];
+        return this.operatePlug([...base, ...reqByteArray]);
+    }
+    /**
+     * Turns on the plug.
+     * @returns {Promise<boolean>} - Resolves with a boolean that tells whether the plug is ON (true) or OFF (false).
+     */
+    async turnOn() {
+        return this.setState([0x01, 0x80]);
+    }
+    /**
+     * Turns off the plug.
+     * @returns {Promise<boolean>} - Resolves with a boolean that tells whether the plug is ON (true) or OFF (false).
+     */
+    async turnOff() {
+        return this.setState([0x01, 0x00]);
+    }
+    /**
+     * Toggles the state of the plug.
+     * @returns {Promise<boolean>} - Resolves with a boolean that tells whether the plug is ON (true) or OFF (false).
+     */
+    async toggle() {
+        return this.setState([0x02, 0x80]);
+    }
+    /**
+     * Operates the plug with the given bytes.
+     * @param {number[]} bytes - The byte array to send to the plug.
+     * @returns {Promise<boolean>} - Resolves with a boolean that tells whether the plug is ON (true) or OFF (false).
+     */
+    async operatePlug(bytes) {
+        const reqBuf = Buffer.from(bytes);
+        const resBytes = await this.command(reqBuf);
+        const resBuf = Buffer.from(resBytes);
+        if (resBuf.length !== 2) {
+            throw new Error(`Expecting a 2-byte response, got instead: 0x${resBuf.toString('hex')}`);
+        }
+        const code = resBuf.readUInt8(1);
+        if (code === 0x00 || code === 0x80) {
+            return code === 0x80;
+        }
+        else {
+            throw new Error(`The device returned an error: 0x${resBuf.toString('hex')}`);
+        }
+    }
+}
+/**
+ * Class representing a WoPresence device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/meter.md
+ */
+export class WoPresence extends SwitchbotDevice {
+    /**
+     * Parses the service data for WoPresence.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<motionSensorServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, emitLog) {
+        if (serviceData.length !== 6) {
+            emitLog('debugerror', `[parseServiceDataForWoPresence] Buffer length ${serviceData.length} !== 6!`);
+            return null;
+        }
+        const [byte1, byte2, , , , byte5] = serviceData;
+        const data = {
+            model: SwitchBotBLEModel.MotionSensor,
+            modelName: SwitchBotBLEModelName.MotionSensor,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.MotionSensor,
+            tested: !!(byte1 & 0b10000000),
+            movement: !!(byte1 & 0b01000000),
+            battery: byte2 & 0b01111111,
+            led: (byte5 & 0b00100000) >> 5,
+            iot: (byte5 & 0b00010000) >> 4,
+            sense_distance: (byte5 & 0b00001100) >> 2,
+            lightLevel: (byte5 & 0b00000011) === 1 ? 'dark' : (byte5 & 0b00000011) === 2 ? 'bright' : 'unknown',
+            is_light: !!(byte5 & 0b00000010),
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+}
+/**
+ * Class representing a WoRelaySwitch1 device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/
+ */
+export class WoRelaySwitch1 extends SwitchbotDevice {
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Parses the service data for WoRelaySwitch1.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<relaySwitch1ServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, manufacturerData, emitLog) {
+        if (serviceData.length < 8 || manufacturerData.length === null) {
+            emitLog('debugerror', `[parseServiceDataForWoRelaySwitch1Plus] Buffer length ${serviceData.length} < 8!`);
+            return null;
+        }
+        const data = {
+            model: SwitchBotBLEModel.RelaySwitch1,
+            modelName: SwitchBotBLEModelName.RelaySwitch1,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.RelaySwitch1,
+            mode: true, // for compatibility, useless
+            state: !!(manufacturerData[7] & 0b10000000),
+            sequence_number: manufacturerData[6],
+        };
+        return data;
+    }
+    /**
+     * Sends a command to the bot.
+     * @param {Buffer} reqBuf - The command buffer.
+     * @returns {Promise<void>}
+     */
+    async sendCommand(reqBuf) {
+        const resBuf = await this.command(reqBuf);
+        const code = resBuf.readUInt8(0);
+        if (resBuf.length !== 3 || (code !== 0x01 && code !== 0x05)) {
+            throw new Error(`The device returned an error: 0x${resBuf.toString('hex')}`);
+        }
+    }
+    /**
+     * Turns on the bot.
+     * @returns {Promise<void>}
+     */
+    async turnOn() {
+        await this.sendCommand(Buffer.from([0x57, 0x01, 0x01]));
+    }
+    /**
+     * Turns off the bot.
+     * @returns {Promise<void>}
+     */
+    async turnOff() {
+        await this.sendCommand(Buffer.from([0x57, 0x01, 0x02]));
+    }
+}
+/**
+ * Class representing a WoRelaySwitch1PM device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/
+ */
+export class WoRelaySwitch1PM extends SwitchbotDevice {
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Parses the service data for WoRelaySwitch1PM.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<relaySwitch1PMServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, manufacturerData, emitLog) {
+        if (serviceData.length < 8 || manufacturerData.length === 0) {
+            emitLog('debugerror', `[parseServiceDataForWoRelaySwitch1PM] Buffer length ${serviceData.length} < 8!`);
+            return null;
+        }
+        const data = {
+            model: SwitchBotBLEModel.RelaySwitch1PM,
+            modelName: SwitchBotBLEModelName.RelaySwitch1PM,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.RelaySwitch1PM,
+            mode: true, // for compatibility, useless
+            state: !!(manufacturerData[7] & 0b10000000),
+            sequence_number: manufacturerData[6],
+            power: ((manufacturerData[10] << 8) + manufacturerData[11]) / 10,
+            voltage: 0,
+            current: 0,
+        };
+        return data;
+    }
+    /**
+     * Sends a command to the bot.
+     * @param {Buffer} reqBuf - The command buffer.
+     * @returns {Promise<void>}
+     */
+    async sendCommand(reqBuf) {
+        const resBuf = await this.command(reqBuf);
+        const code = resBuf.readUInt8(0);
+        if (resBuf.length !== 3 || (code !== 0x01 && code !== 0x05)) {
+            throw new Error(`The device returned an error: 0x${resBuf.toString('hex')}`);
+        }
+    }
+    /**
+     * Turns on the bot.
+     * @returns {Promise<void>}
+     */
+    async turnOn() {
+        await this.sendCommand(Buffer.from([0x57, 0x01, 0x01]));
+    }
+    /**
+     * Turns off the bot.
+     * @returns {Promise<void>}
+     */
+    async turnOff() {
+        await this.sendCommand(Buffer.from([0x57, 0x01, 0x02]));
+    }
+}
+/**
+ * Class representing a WoRemote device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/
+ */
+export class WoRemote extends SwitchbotDevice {
+    /**
+     * Parses the service data for WoRemote.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<remoteServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, emitLog) {
+        if (serviceData.length !== 9) {
+            emitLog('debugerror', `[parseServiceDataForWoRemote] Buffer length ${serviceData.length} !== 9!`);
+            return null;
+        }
+        const [byte2] = serviceData;
+        const battery = byte2 & 0b01111111;
+        const data = {
+            model: SwitchBotBLEModel.Remote,
+            modelName: SwitchBotBLEModelName.Remote,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.Remote,
+            battery,
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+}
+/**
+ * Class representing a WoSensorTH device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/meter.md
+ */
+export class WoSensorTH extends SwitchbotDevice {
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    static async parseServiceData(serviceData, emitLog) {
+        if (serviceData.length !== 6) {
+            emitLog('debugerror', `[parseServiceData] Buffer length ${serviceData.length} !== 6!`);
+            return null;
+        }
+        const [byte2, byte3, byte4, byte5] = [
+            serviceData.readUInt8(2),
+            serviceData.readUInt8(3),
+            serviceData.readUInt8(4),
+            serviceData.readUInt8(5),
+        ];
+        const tempSign = byte4 & 0b10000000 ? 1 : -1;
+        const tempC = tempSign * ((byte4 & 0b01111111) + (byte3 & 0b00001111) / 10);
+        const tempF = Math.round(((tempC * 9) / 5 + 32) * 10) / 10;
+        const data = {
+            model: SwitchBotBLEModel.Meter,
+            modelName: SwitchBotBLEModelName.Meter,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.Meter,
+            celsius: tempC,
+            fahrenheit: tempF,
+            fahrenheit_mode: !!(byte5 & 0b10000000),
+            humidity: byte5 & 0b01111111,
+            battery: byte2 & 0b01111111,
+        };
+        return data;
+    }
+}
+/**
+ * Class representing a WoSensorTH device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/meter.md
+ */
+export class WoSensorTHPlus extends SwitchbotDevice {
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    static async parseServiceData(serviceData, emitLog) {
+        if (serviceData.length !== 6) {
+            emitLog('debugerror', `[parseServiceData] Buffer length ${serviceData.length} !== 6 or 7!`);
+            return null;
+        }
+        const [byte2, byte3, byte4, byte5] = [
+            serviceData.readUInt8(2),
+            serviceData.readUInt8(3),
+            serviceData.readUInt8(4),
+            serviceData.readUInt8(5),
+        ];
+        const tempSign = byte4 & 0b10000000 ? 1 : -1;
+        const tempC = tempSign * ((byte4 & 0b01111111) + (byte3 & 0b00001111) / 10);
+        const tempF = Math.round(((tempC * 9) / 5 + 32) * 10) / 10;
+        const data = {
+            model: SwitchBotBLEModel.MeterPlus,
+            modelName: SwitchBotBLEModelName.MeterPlus,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.MeterPlus,
+            celsius: tempC,
+            fahrenheit: tempF,
+            fahrenheit_mode: !!(byte5 & 0b10000000),
+            humidity: byte5 & 0b01111111,
+            battery: byte2 & 0b01111111,
+        };
+        return data;
+    }
+}
+/**
+ * Class representing a WoSensorTH device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/meter.md
+ */
+export class WoSensorTHPro extends SwitchbotDevice {
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    static async parseServiceData(serviceData, emitLog) {
+        if (serviceData.length !== 6) {
+            emitLog('debugerror', `[parseServiceData] Buffer length ${serviceData.length} !== 6 or 7!`);
+            return null;
+        }
+        const [byte2, byte3, byte4, byte5] = [
+            serviceData.readUInt8(2),
+            serviceData.readUInt8(3),
+            serviceData.readUInt8(4),
+            serviceData.readUInt8(5),
+        ];
+        const tempSign = byte4 & 0b10000000 ? 1 : -1;
+        const tempC = tempSign * ((byte4 & 0b01111111) + (byte3 & 0b00001111) / 10);
+        const tempF = Math.round(((tempC * 9) / 5 + 32) * 10) / 10;
+        const data = {
+            model: SwitchBotBLEModel.MeterPro,
+            modelName: SwitchBotBLEModelName.MeterPro,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.MeterPro,
+            celsius: tempC,
+            fahrenheit: tempF,
+            fahrenheit_mode: !!(byte5 & 0b10000000),
+            humidity: byte5 & 0b01111111,
+            battery: byte2 & 0b01111111,
+        };
+        return data;
+    }
+}
+/**
+ * Class representing a WoSensorTH device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/meter.md
+ */
+export class WoSensorTHProCO2 extends SwitchbotDevice {
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    static async parseServiceData(serviceData, manufacturerData, emitLog) {
+        if (serviceData.length !== 7) {
+            emitLog('debugerror', `[parseServiceData] Buffer length ${serviceData.length} !== 7!`);
+            return null;
+        }
+        const [byte2, byte3, byte4, byte5, byte6] = [
+            serviceData.readUInt8(2),
+            serviceData.readUInt8(3),
+            serviceData.readUInt8(4),
+            serviceData.readUInt8(5),
+            manufacturerData.readUInt16BE(6),
+        ];
+        const tempSign = byte4 & 0b10000000 ? 1 : -1;
+        const tempC = tempSign * ((byte4 & 0b01111111) + (byte3 & 0b00001111) / 10);
+        const tempF = Math.round(((tempC * 9) / 5 + 32) * 10) / 10;
+        const data = {
+            model: SwitchBotBLEModel.MeterProCO2,
+            modelName: SwitchBotBLEModelName.MeterProCO2,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.MeterProCO2,
+            celsius: tempC,
+            fahrenheit: tempF,
+            fahrenheit_mode: !!(byte5 & 0b10000000),
+            humidity: byte5 & 0b01111111,
+            battery: byte2 & 0b01111111,
+            co2: byte6,
+        };
+        return data;
+    }
+}
+/**
+ * Class representing a WoSmartLock device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/lock.md
+ */
+export class WoSmartLock extends SwitchbotDevice {
+    iv = null;
+    key_id = '';
+    encryption_key = null;
+    static Result = {
+        ERROR: 0x00,
+        SUCCESS: 0x01,
+        SUCCESS_LOW_BATTERY: 0x06,
+    };
+    static async validateResponse(res) {
+        if (res.length >= 3) {
+            const result = res.readUInt8(0);
+            if (result === WoSmartLock.Result.SUCCESS || result === WoSmartLock.Result.SUCCESS_LOW_BATTERY) {
+                return result;
+            }
+        }
+        return WoSmartLock.Result.ERROR;
+    }
+    static getLockStatus(code) {
+        const statusMap = {
+            0b0000000: 'LOCKED',
+            0b0010000: 'UNLOCKED',
+            0b0100000: 'LOCKING',
+            0b0110000: 'UNLOCKING',
+            0b1000000: 'LOCKING_STOP',
+            0b1010000: 'UNLOCKING_STOP',
+            0b1100000: 'NOT_FULLY_LOCKED', // Only EU lock type
+        };
+        return statusMap[code] || 'UNKNOWN';
+    }
+    /**
+     * Parses the service data from the SwitchBot Strip Light.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<lockServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, manufacturerData, emitLog) {
+        if (manufacturerData.length < 11) {
+            emitLog('debugerror', `[parseServiceDataForWoSmartLock] Buffer length ${manufacturerData.length} is too short!`);
+            return null;
+        }
+        const byte2 = serviceData.readUInt8(2);
+        const byte15 = manufacturerData.readUInt8(9);
+        const byte16 = manufacturerData.readUInt8(10);
+        const data = {
+            model: SwitchBotBLEModel.Lock,
+            modelName: SwitchBotBLEModelName.Lock,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.Lock,
+            battery: byte2 & 0b01111111,
+            calibration: !!(byte15 & 0b10000000),
+            status: WoSmartLock.getLockStatus(byte15 & 0b01110000),
+            update_from_secondary_lock: !!(byte15 & 0b00001000),
+            door_open: !!(byte15 & 0b00000100),
+            double_lock_mode: !!(byte16 & 0b10000000),
+            unclosed_alarm: !!(byte16 & 0b00100000),
+            unlocked_alarm: !!(byte16 & 0b00010000),
+            auto_lock_paused: !!(byte16 & 0b00000010),
+            night_latch: !!(manufacturerData.length > 11 && manufacturerData.readUInt8(11) & 0b00000001),
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Initializes the encryption key info for valid lock communication.
+     * @param {string} keyId - The key ID.
+     * @param {string} encryptionKey - The encryption key.
+     */
+    async setKey(keyId, encryptionKey) {
+        this.iv = null;
+        this.key_id = keyId;
+        this.encryption_key = Buffer.from(encryptionKey, 'hex');
+    }
+    /**
+     * Unlocks the Smart Lock.
+     * @returns {Promise<number>} - The result of the unlock operation.
+     */
+    async unlock() {
+        const resBuf = await this.operateLock(WoSmartLockCommands.UNLOCK);
+        return resBuf ? WoSmartLock.validateResponse(resBuf) : WoSmartLock.Result.ERROR;
+    }
+    /**
+     * Unlocks the Smart Lock without unlatching the door.
+     * @returns {Promise<number>} - The result of the unlock operation.
+     */
+    async unlockNoUnlatch() {
+        const resBuf = await this.operateLock(WoSmartLockCommands.UNLOCK_NO_UNLATCH);
+        return resBuf ? WoSmartLock.validateResponse(resBuf) : WoSmartLock.Result.ERROR;
+    }
+    /**
+     * Locks the Smart Lock.
+     * @returns {Promise<number>} - The result of the lock operation.
+     */
+    async lock() {
+        const resBuf = await this.operateLock(WoSmartLockCommands.LOCK);
+        return resBuf ? WoSmartLock.validateResponse(resBuf) : WoSmartLock.Result.ERROR;
+    }
+    /**
+     * Gets general state info from the Smart Lock.
+     * @returns {Promise<object | null>} - The state object or null if an error occurred.
+     */
+    async info() {
+        const resBuf = await this.operateLock(WoSmartLockCommands.LOCK_INFO);
+        if (resBuf) {
+            return {
+                calibration: Boolean(resBuf[1] & 0b10000000),
+                status: WoSmartLock.getLockStatus((resBuf[1] & 0b01110000)),
+                door_open: Boolean(resBuf[1] & 0b00000100),
+                unclosed_alarm: Boolean(resBuf[2] & 0b00100000),
+                unlocked_alarm: Boolean(resBuf[2] & 0b00010000),
+            };
+        }
+        return null;
+    }
+    /**
+     * Encrypts a string using AES-128-CTR.
+     * @param {string} str - The string to encrypt.
+     * @returns {Promise<string>} - The encrypted string in hex format.
+     */
+    async encrypt(str) {
+        const cipher = Crypto.createCipheriv('aes-128-ctr', this.encryption_key, this.iv);
+        return Buffer.concat([cipher.update(str, 'hex'), cipher.final()]).toString('hex');
+    }
+    /**
+     * Decrypts a buffer using AES-128-CTR.
+     * @param {Buffer} data - The data to decrypt.
+     * @returns {Promise<Buffer>} - The decrypted data.
+     */
+    async decrypt(data) {
+        const decipher = Crypto.createDecipheriv('aes-128-ctr', this.encryption_key, this.iv);
+        return Buffer.concat([decipher.update(data), decipher.final()]);
+    }
+    /**
+     * Retrieves the IV from the device.
+     * @returns {Promise<Buffer>} - The IV buffer.
+     */
+    async getIv() {
+        if (!this.iv) {
+            const res = await this.operateLock(WoSmartLockCommands.GET_CKIV + this.key_id, false);
+            if (res) {
+                this.iv = res.subarray(4);
+            }
+            else {
+                throw new Error('Failed to retrieve IV from the device.');
+            }
+        }
+        return this.iv;
+    }
+    /**
+     * Sends an encrypted command to the device.
+     * @param {string} key - The command key.
+     * @returns {Promise<Buffer>} - The response buffer.
+     */
+    async encryptedCommand(key) {
+        const iv = await this.getIv();
+        const req = Buffer.from(key.substring(0, 2) + this.key_id + Buffer.from(iv.subarray(0, 2)).toString('hex') + await this.encrypt(key.substring(2)), 'hex');
+        const bytes = await this.command(req);
+        const buf = Buffer.from(bytes);
+        const code = WoSmartLock.validateResponse(buf);
+        if (await code !== WoSmartLock.Result.ERROR) {
+            return Buffer.concat([buf.subarray(0, 1), await this.decrypt(buf.subarray(4))]);
+        }
+        else {
+            throw new Error(`The device returned an error: 0x${buf.toString('hex')}`);
+        }
+    }
+    /**
+     * Operates the lock with the given command.
+     * @param {string} key - The command key.
+     * @param {boolean} [encrypt] - Whether to encrypt the command.
+     * @returns {Promise<Buffer>} - The response buffer.
+     */
+    async operateLock(key, encrypt = true) {
+        if (encrypt) {
+            return this.encryptedCommand(key);
+        }
+        const req = Buffer.from(`${key.substring(0, 2)}000000${key.substring(2)}`, 'hex');
+        const bytes = await this.command(req);
+        const buf = Buffer.from(bytes);
+        const code = WoSmartLock.validateResponse(buf);
+        if (await code === WoSmartLock.Result.ERROR) {
+            throw new Error(`The device returned an error: 0x${buf.toString('hex')}`);
+        }
+        return buf;
+    }
+}
+/**
+ * Class representing a WoSmartLockPro device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/lock.md
+ */
+export class WoSmartLockPro extends SwitchbotDevice {
+    iv = null;
+    key_id = '';
+    encryption_key = null;
+    static Result = {
+        ERROR: 0x00,
+        SUCCESS: 0x01,
+        SUCCESS_LOW_BATTERY: 0x06,
+    };
+    static async validateResponse(res) {
+        if (res.length >= 3) {
+            const result = res.readUInt8(0);
+            if (result === WoSmartLockPro.Result.SUCCESS || result === WoSmartLockPro.Result.SUCCESS_LOW_BATTERY) {
+                return result;
+            }
+        }
+        return WoSmartLockPro.Result.ERROR;
+    }
+    static getLockStatus(code) {
+        const statusMap = {
+            0b0000000: 'LOCKED',
+            0b0010000: 'UNLOCKED',
+            0b0100000: 'LOCKING',
+            0b0110000: 'UNLOCKING',
+            0b1000000: 'LOCKING_STOP',
+            0b1010000: 'UNLOCKING_STOP',
+            0b01100000: 'NOT_FULLY_LOCKED', // Only EU lock type
+        };
+        return statusMap[code] || 'UNKNOWN';
+    }
+    /**
+     * Parses the service data from the SwitchBot Strip Light.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Buffer} manufacturerData - The manufacturer data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<lockProServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, manufacturerData, emitLog) {
+        if (manufacturerData.length < 11) {
+            emitLog('debugerror', `[parseServiceDataForWoSmartLockPro] Buffer length ${manufacturerData.length} is too short!`);
+            return null;
+        }
+        const byte2 = serviceData.readUInt8(2);
+        const byte7 = manufacturerData.readUInt8(7);
+        const byte8 = manufacturerData.readUInt8(8);
+        const byte9 = manufacturerData.readUInt8(9);
+        const byte11 = manufacturerData.readUInt8(11);
+        const data = {
+            model: SwitchBotBLEModel.LockPro,
+            modelName: SwitchBotBLEModelName.LockPro,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.LockPro,
+            battery: byte2 & 0b01111111,
+            calibration: !!(byte7 & 0b10000000),
+            status: WoSmartLockPro.getLockStatus((byte7 & 0b00111000) >> 3),
+            door_open: !!(byte8 & 0b01100000),
+            update_from_secondary_lock: false,
+            double_lock_mode: false,
+            unclosed_alarm: !!(byte11 & 0b10000000),
+            unlocked_alarm: !!(byte11 & 0b01000000),
+            auto_lock_paused: !!(byte8 & 0b100000),
+            night_latch: !!(byte9 & 0b00000001),
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Initializes the encryption key info for valid lock communication.
+     * @param {string} keyId - The key ID.
+     * @param {string} encryptionKey - The encryption key.
+     */
+    async setKey(keyId, encryptionKey) {
+        this.iv = null;
+        this.key_id = keyId;
+        this.encryption_key = Buffer.from(encryptionKey, 'hex');
+    }
+    /**
+     * Unlocks the Smart Lock.
+     * @returns {Promise<number>} - The result of the unlock operation.
+     */
+    async unlock() {
+        const resBuf = await this.operateLockPro(WoSmartLockProCommands.UNLOCK);
+        return resBuf ? WoSmartLockPro.validateResponse(resBuf) : WoSmartLockPro.Result.ERROR;
+    }
+    /**
+     * Unlocks the Smart Lock without unlatching the door.
+     * @returns {Promise<number>} - The result of the unlock operation.
+     */
+    async unlockNoUnlatch() {
+        const resBuf = await this.operateLockPro(WoSmartLockProCommands.UNLOCK_NO_UNLATCH);
+        return resBuf ? WoSmartLockPro.validateResponse(resBuf) : WoSmartLockPro.Result.ERROR;
+    }
+    /**
+     * Locks the Smart Lock.
+     * @returns {Promise<number>} - The result of the lock operation.
+     */
+    async lock() {
+        const resBuf = await this.operateLockPro(WoSmartLockProCommands.LOCK);
+        return resBuf ? WoSmartLockPro.validateResponse(resBuf) : WoSmartLockPro.Result.ERROR;
+    }
+    /**
+     * Gets general state info from the Smart Lock.
+     * @returns {Promise<object | null>} - The state object or null if an error occurred.
+     */
+    async info() {
+        const resBuf = await this.operateLockPro(WoSmartLockProCommands.LOCK_INFO);
+        if (resBuf) {
+            return {
+                calibration: Boolean(resBuf[0] & 0b10000000),
+                status: WoSmartLockPro.getLockStatus((resBuf[0] & 0b01110000) >> 4),
+                door_open: Boolean(resBuf[0] & 0b00000100),
+                unclosed_alarm: Boolean(resBuf[1] & 0b00100000),
+                unlocked_alarm: Boolean(resBuf[1] & 0b00010000),
+            };
+        }
+        return null;
+    }
+    /**
+     * Encrypts a string using AES-128-CTR.
+     * @param {string} str - The string to encrypt.
+     * @returns {Promise<string>} - The encrypted string in hex format.
+     */
+    async encrypt(str) {
+        const cipher = Crypto.createCipheriv('aes-128-ctr', this.encryption_key, this.iv);
+        return Buffer.concat([cipher.update(str, 'hex'), cipher.final()]).toString('hex');
+    }
+    /**
+     * Decrypts a buffer using AES-128-CTR.
+     * @param {Buffer} data - The data to decrypt.
+     * @returns {Promise<Buffer>} - The decrypted data.
+     */
+    async decrypt(data) {
+        const decipher = Crypto.createDecipheriv('aes-128-ctr', this.encryption_key, this.iv);
+        return Buffer.concat([decipher.update(data), decipher.final()]);
+    }
+    /**
+     * Retrieves the IV from the device.
+     * @returns {Promise<Buffer>} - The IV buffer.
+     */
+    async getIv() {
+        if (!this.iv) {
+            const res = await this.operateLockPro(WoSmartLockProCommands.GET_CKIV + this.key_id, false);
+            if (res) {
+                this.iv = res.subarray(4);
+            }
+            else {
+                throw new Error('Failed to retrieve IV from the device.');
+            }
+        }
+        return this.iv;
+    }
+    /**
+     * Sends an encrypted command to the device.
+     * @param {string} key - The command key.
+     * @returns {Promise<Buffer>} - The response buffer.
+     */
+    async encryptedCommand(key) {
+        const iv = await this.getIv();
+        const req = Buffer.from(key.substring(0, 2) + this.key_id + Buffer.from(iv.subarray(0, 2)).toString('hex') + await this.encrypt(key.substring(2)), 'hex');
+        const bytes = await this.command(req);
+        const buf = Buffer.from(bytes);
+        const code = WoSmartLockPro.validateResponse(buf);
+        if (await code !== WoSmartLockPro.Result.ERROR) {
+            return Buffer.concat([buf.subarray(0, 1), await this.decrypt(buf.subarray(4))]);
+        }
+        else {
+            throw new Error(`The device returned an error: 0x${buf.toString('hex')}`);
+        }
+    }
+    /**
+     * Operates the lock with the given command.
+     * @param {string} key - The command key.
+     * @param {boolean} [encrypt] - Whether to encrypt the command.
+     * @returns {Promise<Buffer>} - The response buffer.
+     */
+    async operateLockPro(key, encrypt = true) {
+        if (encrypt) {
+            return this.encryptedCommand(key);
+        }
+        const req = Buffer.from(`${key.substring(0, 2)}000000${key.substring(2)}`, 'hex');
+        const bytes = await this.command(req);
+        const buf = Buffer.from(bytes);
+        const code = WoSmartLockPro.validateResponse(buf);
+        if (await code === WoSmartLockPro.Result.ERROR) {
+            throw new Error(`The device returned an error: 0x${buf.toString('hex')}`);
+        }
+        return buf;
+    }
+}
+/**
+ * Class representing a WoStrip device.
+ * @see https://github.com/OpenWonderLabs/SwitchBotAPI-BLE/blob/latest/devicetypes/ledstriplight.md
+ */
+export class WoStrip extends SwitchbotDevice {
+    /**
+     * Parses the service data from the SwitchBot Strip Light.
+     * @param {Buffer} serviceData - The service data buffer.
+     * @param {Function} emitLog - The function to emit log messages.
+     * @returns {Promise<stripLightServiceData | null>} - Parsed service data or null if invalid.
+     */
+    static async parseServiceData(serviceData, emitLog) {
+        if (serviceData.length !== 18) {
+            emitLog('debugerror', `[parseServiceDataForWoStrip] Buffer length ${serviceData.length} !== 18!`);
+            return null;
+        }
+        const [byte3, byte4, byte5, byte7, byte8, byte9, byte10] = [
+            serviceData.readUInt8(3),
+            serviceData.readUInt8(4),
+            serviceData.readUInt8(5),
+            serviceData.readUInt8(7),
+            serviceData.readUInt8(8),
+            serviceData.readUInt8(9),
+            serviceData.readUInt8(10),
+        ];
+        const data = {
+            model: SwitchBotBLEModel.StripLight,
+            modelName: SwitchBotBLEModelName.StripLight,
+            modelFriendlyName: SwitchBotBLEModelFriendlyName.StripLight,
+            power: !!(byte7 & 0b10000000),
+            state: !!(byte7 & 0b10000000),
+            brightness: byte7 & 0b01111111,
+            red: byte3,
+            green: byte4,
+            blue: byte5,
+            delay: byte8 & 0b10000000,
+            preset: byte8 & 0b00001000,
+            color_mode: byte8 & 0b00000111,
+            speed: byte9 & 0b01111111,
+            loop_index: byte10 & 0b11111110,
+        };
+        return data;
+    }
+    constructor(peripheral, noble) {
+        super(peripheral, noble);
+    }
+    /**
+     * Reads the state of the strip light.
+     * @returns {Promise<boolean>} - Resolves with true if the strip light is ON, false otherwise.
+     */
+    async readState() {
+        return this.operateStripLight([0x57, 0x0F, 0x4A, 0x01]);
+    }
+    /**
+     * Sets the state of the strip light.
+     * @public
+     * @param {number[]} reqByteArray - The request byte array.
+     * @returns {Promise<boolean>} - Resolves with true if the operation was successful.
+     */
+    async setState(reqByteArray) {
+        const base = [0x57, 0x0F, 0x49, 0x01];
+        return this.operateStripLight([...base, ...reqByteArray]);
+    }
+    /**
+     * Turns the strip light on.
+     * @returns {Promise<boolean>} - Resolves with true if the strip light is ON.
+     */
+    async turnOn() {
+        return this.setState([0x01, 0x01]);
+    }
+    /**
+     * Turns the strip light off.
+     * @returns {Promise<boolean>} - Resolves with true if the strip light is OFF.
+     */
+    async turnOff() {
+        return this.setState([0x01, 0x02]);
+    }
+    /**
+     * Sets the brightness of the strip light.
+     * @param {number} brightness - The brightness percentage (0-100).
+     * @returns {Promise<boolean>} - Resolves with true if the operation was successful.
+     */
+    async setBrightness(brightness) {
+        if (typeof brightness !== 'number' || brightness < 0 || brightness > 100) {
+            throw new TypeError(`Invalid brightness value: ${brightness}`);
+        }
+        return this.setState([0x02, 0x14, brightness]);
+    }
+    /**
+     * Sets the RGB values of the strip light.
+     * @param {number} brightness - The brightness percentage (0-100).
+     * @param {number} red - The red value (0-255).
+     * @param {number} green - The green value (0-255).
+     * @param {number} blue - The blue value (0-255).
+     * @returns {Promise<boolean>} - Resolves with true if the operation was successful.
+     */
+    async setRGB(brightness, red, green, blue) {
+        if (![brightness, red, green, blue].every(val => typeof val === 'number')) {
+            throw new TypeError('Invalid RGB or brightness value');
+        }
+        brightness = Math.max(0, Math.min(100, brightness));
+        red = Math.max(0, Math.min(255, red));
+        green = Math.max(0, Math.min(255, green));
+        blue = Math.max(0, Math.min(255, blue));
+        return this.setState([0x02, 0x12, brightness, red, green, blue]);
+    }
+    /**
+     * Operates the strip light with the given byte array.
+     * @public
+     * @param {number[]} bytes - The byte array to send.
+     * @returns {Promise<boolean>} - Resolves with true if the operation was successful.
+     */
+    async operateStripLight(bytes) {
+        const req_buf = Buffer.from(bytes);
+        const res_buf = await this.command(req_buf);
+        if (res_buf.length !== 2) {
+            throw new Error(`Expecting a 2-byte response, got instead: 0x${res_buf.toString('hex')}`);
+        }
+        const code = res_buf.readUInt8(1);
+        if (code === 0x00 || code === 0x80) {
+            return code === 0x80;
+        }
+        else {
+            throw new Error(`The device returned an error: 0x${res_buf.toString('hex')}`);
+        }
+    }
+}
 //# sourceMappingURL=device.js.map