tsvesync 1.0.64 → 1.0.66

package/dist/lib/fans/humidifier.d.ts

@@ -0,0 +1,83 @@
+import { VeSyncFan } from '../vesyncFan';
+import { VeSync } from '../vesync';
+/**
+ * VeSync Humidifier Base Class
+ */
+export declare class VeSyncHumidifier extends VeSyncFan {
+    protected readonly modes: readonly ["auto", "manual", "sleep"];
+    protected readonly mistLevels: number[];
+    protected readonly displayModes: readonly ["on", "off"];
+    protected readonly humidityRange: {
+        min: number;
+        max: number;
+    };
+    constructor(details: Record<string, any>, manager: VeSync);
+    /**
+     * Get device details
+     */
+    getDetails(): Promise<Boolean>;
+    /**
+     * Turn device on
+     */
+    turnOn(): Promise<boolean>;
+    /**
+     * Turn device off
+     */
+    turnOff(): Promise<boolean>;
+    /**
+     * Toggle device power
+     */
+    toggleSwitch(enabled: boolean): Promise<boolean>;
+    /**
+     * Set mist level
+     */
+    setMistLevel(level: number): Promise<boolean>;
+    /**
+     * Change fan speed - Implemented to satisfy interface but redirects to setMistLevel
+     */
+    changeFanSpeed(speed: number): Promise<boolean>;
+    /**
+     * Set device mode
+     */
+    setMode(mode: string): Promise<boolean>;
+    /**
+     * Set target humidity
+     */
+    setHumidity(humidity: number): Promise<boolean>;
+    /**
+     * Set display status
+     */
+    setDisplay(enabled: boolean): Promise<boolean>;
+    /**
+     * Set timer
+     */
+    setTimer(hours: number): Promise<boolean>;
+    /**
+     * Clear timer
+     */
+    clearTimer(): Promise<boolean>;
+    /**
+     * Turn automatic stop on
+     */
+    automaticStopOn(): Promise<boolean>;
+    /**
+     * Turn automatic stop off
+     */
+    automaticStopOff(): Promise<boolean>;
+    /**
+     * Set auto mode
+     */
+    setAutoMode(): Promise<boolean>;
+    /**
+     * Set manual mode
+     */
+    setManualMode(): Promise<boolean>;
+    /**
+     * Turn off display
+     */
+    turnOffDisplay(): Promise<boolean>;
+    /**
+     * Turn on display
+     */
+    turnOnDisplay(): Promise<boolean>;
+}

package/dist/lib/fans/humidifier.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeSyncHumidifier = void 0;
+const vesyncFan_1 = require("../vesyncFan");
+const helpers_1 = require("../helpers");
+const logger_1 = require("../logger");
+/**
+ * VeSync Humidifier Base Class
+ */
+class VeSyncHumidifier extends vesyncFan_1.VeSyncFan {
+    constructor(details, manager) {
+        super(details, manager);
+        this.modes = ['auto', 'manual', 'sleep'];
+        this.displayModes = ['on', 'off'];
+        this.humidityRange = { min: 30, max: 80 };
+        // Set mist levels based on model
+        switch (this.deviceType) {
+            case 'Dual200S':
+            case 'LUH-D301S-WUSR':
+            case 'LUH-D301S-WJP':
+            case 'LUH-D301S-WEU':
+                this.mistLevels = [1, 2];
+                break;
+            default:
+                // All other models support levels 1-9
+                this.mistLevels = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        }
+        logger_1.logger.debug(`Initialized VeSyncHumidifier device: ${this.deviceName}`);
+    }
+    /**
+     * Get device details
+     */
+    async getDetails() {
+        var _a;
+        logger_1.logger.debug(`Getting details for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {},
+                method: 'getHumidifierStatus',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'getDetails');
+        if (success && ((_a = response === null || response === void 0 ? void 0 : response.result) === null || _a === void 0 ? void 0 : _a.result)) {
+            const result = response.result.result;
+            // Handle model-specific status fields
+            if (this.deviceType.startsWith('Classic') || this.deviceType === 'Dual200S') {
+                this.deviceStatus = result.enabled ? 'on' : 'off';
+            }
+            else {
+                this.deviceStatus = result.powerSwitch === 1 ? 'on' : 'off';
+            }
+            this.details = {
+                mode: result.mode || '',
+                humidity: result.humidity || 0,
+                mist_level: result.level || 0,
+                mist_virtual_level: result.virtualLevel || 0,
+                warm_level: result.level || 0,
+                water_lacks: result.waterLacks || false,
+                humidity_high: result.humidityHigh || false,
+                water_tank_lifted: result.waterTankLifted || false,
+                display: result.display || false,
+                automatic_stop: result.automaticStop || false,
+                configuration: result.configuration || {},
+                connection_status: result.connectionStatus || null
+            };
+            logger_1.logger.debug(`Successfully got details for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Turn device on
+     */
+    async turnOn() {
+        return this.toggleSwitch(true);
+    }
+    /**
+     * Turn device off
+     */
+    async turnOff() {
+        return this.toggleSwitch(false);
+    }
+    /**
+     * Toggle device power
+     */
+    async toggleSwitch(enabled) {
+        logger_1.logger.info(`Setting device power to ${enabled ? 'on' : 'off'}: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    enabled: enabled,
+                    id: 0
+                },
+                method: 'setSwitch',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'toggleSwitch');
+        if (success) {
+            this.deviceStatus = enabled ? 'on' : 'off';
+        }
+        else {
+            logger_1.logger.error(`Failed to set device power to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Set mist level
+     */
+    async setMistLevel(level) {
+        if (!this.mistLevels.includes(level)) {
+            const error = `Invalid mist level: ${level}. Must be one of: ${this.mistLevels.join(', ')}`;
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        logger_1.logger.info(`Setting mist level to ${level} for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    id: 0,
+                    level: level,
+                    type: 'mist'
+                },
+                method: 'setVirtualLevel',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'setMistLevel');
+        if (!success) {
+            logger_1.logger.error(`Failed to set mist level to ${level} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Change fan speed - Implemented to satisfy interface but redirects to setMistLevel
+     */
+    async changeFanSpeed(speed) {
+        logger_1.logger.debug(`Redirecting fan speed change to mist level for device: ${this.deviceName}`);
+        return this.setMistLevel(speed);
+    }
+    /**
+     * Set device mode
+     */
+    async setMode(mode) {
+        if (!this.modes.includes(mode)) {
+            const error = `Invalid mode: ${mode}. Must be one of: ${this.modes.join(', ')}`;
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        logger_1.logger.debug(`Setting mode to ${mode} for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    mode
+                },
+                method: 'setHumidityMode',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'setMode');
+        if (success) {
+            this.details.mode = mode;
+        }
+        else {
+            logger_1.logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Set target humidity
+     */
+    async setHumidity(humidity) {
+        if (!this.hasFeature('humidity')) {
+            const error = 'Humidity control not supported';
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        if (humidity < this.humidityRange.min || humidity > this.humidityRange.max) {
+            const error = `Invalid humidity: ${humidity}. Must be between ${this.humidityRange.min} and ${this.humidityRange.max}`;
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        logger_1.logger.debug(`Setting target humidity to ${humidity}% for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    target_humidity: humidity
+                },
+                method: 'setTargetHumidity',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'setHumidity');
+        if (!success) {
+            logger_1.logger.error(`Failed to set target humidity to ${humidity}% for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Set display status
+     */
+    async setDisplay(enabled) {
+        if (!this.hasFeature('display')) {
+            const error = 'Display control not supported';
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        logger_1.logger.debug(`Setting display to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    state: enabled
+                },
+                method: 'setDisplay',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'setDisplay');
+        if (!success) {
+            logger_1.logger.error(`Failed to set display to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Set timer
+     */
+    async setTimer(hours) {
+        if (!this.hasFeature('timer')) {
+            const error = 'Timer not supported';
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        logger_1.logger.debug(`Setting timer to ${hours} hours for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    action: 'off',
+                    total: hours * 3600
+                },
+                method: 'addTimer',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'setTimer');
+        if (!success) {
+            logger_1.logger.error(`Failed to set timer to ${hours} hours for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Clear timer
+     */
+    async clearTimer() {
+        if (!this.hasFeature('timer')) {
+            const error = 'Timer not supported';
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        logger_1.logger.debug(`Clearing timer for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {},
+                method: 'deleteTimer',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'clearTimer');
+        if (!success) {
+            logger_1.logger.error(`Failed to clear timer for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Turn automatic stop on
+     */
+    async automaticStopOn() {
+        logger_1.logger.debug(`Setting automatic stop on for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    enabled: true
+                },
+                method: 'setAutomaticStop',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'automaticStopOn');
+        if (!success) {
+            logger_1.logger.error(`Failed to set automatic stop on for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Turn automatic stop off
+     */
+    async automaticStopOff() {
+        logger_1.logger.debug(`Setting automatic stop off for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    enabled: false
+                },
+                method: 'setAutomaticStop',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'automaticStopOff');
+        if (!success) {
+            logger_1.logger.error(`Failed to set automatic stop off for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Set auto mode
+     */
+    async setAutoMode() {
+        logger_1.logger.debug(`Setting auto mode for device: ${this.deviceName}`);
+        const success = await this.setMode('auto');
+        if (!success) {
+            logger_1.logger.error(`Failed to set auto mode for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Set manual mode
+     */
+    async setManualMode() {
+        logger_1.logger.debug(`Setting manual mode for device: ${this.deviceName}`);
+        const success = await this.setMode('manual');
+        if (!success) {
+            logger_1.logger.error(`Failed to set manual mode for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Turn off display
+     */
+    async turnOffDisplay() {
+        logger_1.logger.debug(`Turning off display for device: ${this.deviceName}`);
+        const success = await this.setDisplay(false);
+        if (!success) {
+            logger_1.logger.error(`Failed to turn off display for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Turn on display
+     */
+    async turnOnDisplay() {
+        logger_1.logger.debug(`Turning on display for device: ${this.deviceName}`);
+        const success = await this.setDisplay(true);
+        if (!success) {
+            logger_1.logger.error(`Failed to turn on display for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+}
+exports.VeSyncHumidifier = VeSyncHumidifier;

package/dist/lib/fans/index.d.ts

@@ -0,0 +1,9 @@
+import { VeSyncFan } from '../vesyncFan';
+import { VeSync } from '../vesync';
+export { VeSyncAirBypass } from './airBypass';
+export { VeSyncAirBaseV2 } from './airBaseV2';
+export { VeSyncTowerFan } from './towerFan';
+export { VeSyncHumidifier } from './humidifier';
+export { VeSyncWarmHumidifier } from './warmHumidifier';
+export { VeSyncHumid200300S } from './humid200300S';
+export declare const fanModules: Record<string, new (details: Record<string, any>, manager: VeSync) => VeSyncFan>;

package/dist/lib/fans/index.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fanModules = exports.VeSyncHumid200300S = exports.VeSyncWarmHumidifier = exports.VeSyncHumidifier = exports.VeSyncTowerFan = exports.VeSyncAirBaseV2 = exports.VeSyncAirBypass = void 0;
+const airBypass_1 = require("./airBypass");
+const airBaseV2_1 = require("./airBaseV2");
+const towerFan_1 = require("./towerFan");
+const humidifier_1 = require("./humidifier");
+const humid200300S_1 = require("./humid200300S");
+// Re-export all classes
+var airBypass_2 = require("./airBypass");
+Object.defineProperty(exports, "VeSyncAirBypass", { enumerable: true, get: function () { return airBypass_2.VeSyncAirBypass; } });
+var airBaseV2_2 = require("./airBaseV2");
+Object.defineProperty(exports, "VeSyncAirBaseV2", { enumerable: true, get: function () { return airBaseV2_2.VeSyncAirBaseV2; } });
+var towerFan_2 = require("./towerFan");
+Object.defineProperty(exports, "VeSyncTowerFan", { enumerable: true, get: function () { return towerFan_2.VeSyncTowerFan; } });
+var humidifier_2 = require("./humidifier");
+Object.defineProperty(exports, "VeSyncHumidifier", { enumerable: true, get: function () { return humidifier_2.VeSyncHumidifier; } });
+var warmHumidifier_1 = require("./warmHumidifier");
+Object.defineProperty(exports, "VeSyncWarmHumidifier", { enumerable: true, get: function () { return warmHumidifier_1.VeSyncWarmHumidifier; } });
+var humid200300S_2 = require("./humid200300S");
+Object.defineProperty(exports, "VeSyncHumid200300S", { enumerable: true, get: function () { return humid200300S_2.VeSyncHumid200300S; } });
+// Export fan modules dictionary
+exports.fanModules = {
+    // Core Series
+    'Core200S': airBypass_1.VeSyncAirBypass,
+    'Core300S': airBypass_1.VeSyncAirBypass,
+    'Core400S': airBypass_1.VeSyncAirBypass,
+    'Core600S': airBypass_1.VeSyncAirBypass,
+    // LAP Series
+    'LAP-C201S-AUSR': airBypass_1.VeSyncAirBypass,
+    'LAP-C202S-WUSR': airBypass_1.VeSyncAirBypass,
+    'LAP-C301S-WJP': airBypass_1.VeSyncAirBypass,
+    'LAP-C302S-WUSB': airBypass_1.VeSyncAirBypass,
+    'LAP-C301S-WAAA': airBypass_1.VeSyncAirBypass,
+    'LAP-C401S-WJP': airBypass_1.VeSyncAirBypass,
+    'LAP-C401S-WUSR': airBypass_1.VeSyncAirBypass,
+    'LAP-C401S-WAAA': airBypass_1.VeSyncAirBypass,
+    'LAP-C601S-WUS': airBypass_1.VeSyncAirBypass,
+    'LAP-C601S-WUSR': airBypass_1.VeSyncAirBypass,
+    'LAP-C601S-WEU': airBypass_1.VeSyncAirBypass,
+    // Vital100S Series - Using VeSyncAirBaseV2
+    'LAP-V102S-AASR': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-V102S-WUS': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-V102S-WEU': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-V102S-AUSR': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-V102S-WJP': airBaseV2_1.VeSyncAirBaseV2,
+    // Vital200S Series - Using VeSyncAirBaseV2
+    'LAP-V201S-AASR': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-V201S-WJP': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-V201S-WEU': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-V201S-WUS': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-V201-AUSR': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-V201S-AUSR': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-V201S-AEUR': airBaseV2_1.VeSyncAirBaseV2,
+    // EverestAir Series - Using VeSyncAirBaseV2
+    'LAP-EL551S-AUS': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-EL551S-AEUR': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-EL551S-WEU': airBaseV2_1.VeSyncAirBaseV2,
+    'LAP-EL551S-WUS': airBaseV2_1.VeSyncAirBaseV2,
+    // LTF Series
+    'LTF-F422S-KEU': towerFan_1.VeSyncTowerFan,
+    'LTF-F422S-WUSR': towerFan_1.VeSyncTowerFan,
+    'LTF-F422_WJP': towerFan_1.VeSyncTowerFan,
+    'LTF-F422S-WUS': towerFan_1.VeSyncTowerFan,
+    // Classic Series
+    'Classic300S': humidifier_1.VeSyncHumidifier,
+    'Classic200S': humidifier_1.VeSyncHumidifier,
+    // Dual Series
+    'Dual200S': humidifier_1.VeSyncHumidifier,
+    // LUH Series
+    'LUH-A601S-WUSB': humid200300S_1.VeSyncHumid200300S,
+    'LUH-A601S-AUSW': humid200300S_1.VeSyncHumid200300S,
+    'LUH-D301S-WUSR': humid200300S_1.VeSyncHumid200300S,
+    'LUH-D301S-WJP': humid200300S_1.VeSyncHumid200300S,
+    'LUH-D301S-WEU': humid200300S_1.VeSyncHumid200300S,
+    'LUH-A602S-WUSR': humid200300S_1.VeSyncHumid200300S,
+    'LUH-A602S-WUS': humid200300S_1.VeSyncHumid200300S,
+    'LUH-A602S-WEUR': humid200300S_1.VeSyncHumid200300S,
+    'LUH-A602S-WEU': humid200300S_1.VeSyncHumid200300S,
+    'LUH-A602S-WJP': humid200300S_1.VeSyncHumid200300S,
+    'LUH-A602S-WUSC': humid200300S_1.VeSyncHumid200300S,
+    'LUH-O451S-WEU': humid200300S_1.VeSyncHumid200300S,
+    'LUH-O451S-WUS': humid200300S_1.VeSyncHumid200300S,
+    'LUH-O451S-WUSR': humid200300S_1.VeSyncHumid200300S,
+    'LUH-O601S-WUS': humid200300S_1.VeSyncHumid200300S,
+    'LUH-O601S-KUS': humid200300S_1.VeSyncHumid200300S,
+    'LUH-M101S-WUS': humid200300S_1.VeSyncHumid200300S,
+    'LUH-M101S-WEUR': humid200300S_1.VeSyncHumid200300S,
+    // LEH Series
+    'LEH-S601S-WUS': humid200300S_1.VeSyncHumid200300S,
+    'LEH-S601S-WUSR': humid200300S_1.VeSyncHumid200300S,
+    // LV Series
+    'LV-PUR131S': airBypass_1.VeSyncAirBypass,
+    'LV-RH131S': airBypass_1.VeSyncAirBypass
+};

package/dist/lib/fans/towerFan.d.ts

@@ -0,0 +1,105 @@
+import { VeSyncAirBaseV2 } from './airBaseV2';
+import { VeSync } from '../vesync';
+/**
+ * VeSync Tower Fan Implementation
+ */
+export declare class VeSyncTowerFan extends VeSyncAirBaseV2 {
+    protected readonly towerModes: readonly ["normal", "advancedSleep", "off"];
+    constructor(details: Record<string, any>, manager: VeSync);
+    /**
+     * Get device details
+     */
+    getDetails(): Promise<Boolean>;
+    /**
+     * Toggle device power
+     */
+    toggleSwitch(toggle: boolean): Promise<boolean>;
+    /**
+     * Turn device on
+     */
+    turnOn(): Promise<boolean>;
+    /**
+     * Turn device off
+     */
+    turnOff(): Promise<boolean>;
+    /**
+     * Set tower fan mode
+     */
+    mode_toggle(mode: string): Promise<boolean>;
+    /**
+     * Change fan speed
+     */
+    changeFanSpeed(speed: number): Promise<boolean>;
+    /**
+     * Set normal mode
+     */
+    normal_mode(): Promise<boolean>;
+    /**
+     * Set manual mode - adapter to set mode to normal
+     */
+    manual_mode(): Promise<boolean>;
+    /**
+     * Set advanced sleep mode
+     */
+    advanced_sleep_mode(): Promise<boolean>;
+    /**
+     * Set sleep mode - adapter for advanced sleep mode
+     */
+    sleep_mode(): Promise<boolean>;
+    /**
+     * Override setMode to handle tower fan specific modes
+     */
+    setMode(mode: string): Promise<boolean>;
+    /**
+     * Get current speed
+     */
+    get speed(): number;
+    /**
+     * Get display status
+     */
+    get displayState(): boolean;
+    /**
+     * Get oscillation status
+     */
+    get oscillationState(): boolean;
+    /**
+     * Get mute status
+     */
+    get muteState(): boolean;
+    /**
+     * Get temperature (in tenths of a degree)
+     */
+    get temperature(): number;
+    /**
+     * Get humidity percentage
+     */
+    get humidity(): number;
+    /**
+     * Get thermal comfort level
+     */
+    get thermalComfort(): number;
+    /**
+     * Get sleep preferences
+     */
+    get sleepPreference(): Record<string, any>;
+    /**
+     * Get schedule count
+     */
+    get scheduleCount(): number;
+    /**
+     * Get error code
+     */
+    get errorCode(): number;
+    /**
+     * Turn oscillation on
+     */
+    setOscillationOn(): Promise<boolean>;
+    /**
+     * Turn oscillation off
+     */
+    setOscillationOff(): Promise<boolean>;
+    /**
+     * Display device info
+     */
+    display(): void;
+}