tsvesync 1.0.71 → 1.0.73

package/dist/lib/fans/humid200S.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeSyncHumid200S = void 0;
+const humidifier_1 = require("./humidifier");
+const helpers_1 = require("../helpers");
+const logger_1 = require("../logger");
+/**
+ * VeSync Humid200S Humidifier Class
+ * Implementation based on PyVeSync's VeSyncHumid200S class
+ * For Classic200S models
+ */
+class VeSyncHumid200S extends humidifier_1.VeSyncHumidifier {
+    constructor(details, manager) {
+        super(details, manager);
+        this.modes = ['auto', 'manual', 'sleep'];
+        this.features = ['humidity', 'mist', 'display', 'timer', 'auto_mode'];
+        this.mistLevels = [1, 2, 3];
+        this.humidityRange = { min: 30, max: 80 };
+        // Update config for Humid200S
+        this.config = {
+            module: 'VeSyncHumid200S',
+            features: ['display', 'humidity', 'mist', 'timer', 'auto_mode'],
+            levels: [1, 2, 3]
+        };
+        logger_1.logger.debug(`Initialized VeSyncHumid200S device: ${this.deviceName}`);
+    }
+    /**
+     * Get device details
+     */
+    async getDetails() {
+        var _a, _b, _c, _d;
+        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;
+            // Update device status based on enabled field
+            this.deviceStatus = result.enabled ? 'on' : 'off';
+            this.details = {
+                mode: result.mode || '',
+                humidity: result.humidity || 0,
+                target_humidity: ((_b = result.configuration) === null || _b === void 0 ? void 0 : _b.auto_target_humidity) || result.target_humidity || 0,
+                mist_level: result.mist_level || 0,
+                water_lacks: result.water_lacks || false,
+                humidity_high: result.humidity_high || false,
+                water_tank_lifted: result.water_tank_lifted || false,
+                display: result.display || false,
+                automatic_stop: result.automatic_stop_reach_target || false,
+                automatic_stop_configured: ((_c = result.configuration) === null || _c === void 0 ? void 0 : _c.automatic_stop) || false,
+                auto_target_humidity: ((_d = result.configuration) === null || _d === void 0 ? void 0 : _d.auto_target_humidity) || 0,
+                configuration: result.configuration || {}
+            };
+            logger_1.logger.debug(`Successfully got details for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Set display
+     * Override to use setIndicatorLightSwitch method
+     */
+    async setDisplay(enabled) {
+        logger_1.logger.info(`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: {
+                    enabled: enabled
+                },
+                method: 'setIndicatorLightSwitch',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'setDisplay');
+        if (success) {
+            this.details.display = enabled;
+            // Get latest state and log it
+            await this.getDetails();
+            logger_1.logger.debug(`Device state after display change: ${JSON.stringify(this.details)}`);
+        }
+        else {
+            logger_1.logger.error(`Failed to set display 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: {
+                    level: level
+                },
+                method: 'setMistLevel', // Use setMistLevel for Classic200S
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'setMistLevel');
+        if (success) {
+            this.details.mist_level = level;
+            // Get latest state and log it
+            await this.getDetails();
+            logger_1.logger.debug(`Device state after mist level change: ${JSON.stringify(this.details)}`);
+        }
+        else {
+            logger_1.logger.error(`Failed to set mist level to ${level} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Get current humidity
+     * Provides access to the current humidity reading
+     */
+    get currentHumidity() {
+        return this.details.humidity || 0;
+    }
+    /**
+     * Get target humidity
+     */
+    get targetHumidity() {
+        return this.details.target_humidity || 0;
+    }
+    /**
+     * Get water lacks status
+     */
+    get waterLacks() {
+        return this.details.water_lacks || false;
+    }
+    /**
+     * Get water tank lifted status
+     */
+    get waterTankLifted() {
+        return this.details.water_tank_lifted || false;
+    }
+    /**
+     * Return JSON details for humidifier
+     * Override to include current humidity and target humidity
+     */
+    displayJSON() {
+        var _a, _b;
+        const baseInfo = JSON.parse(super.displayJSON());
+        // Add current humidity from details
+        baseInfo['Humidity'] = ((_a = this.details.humidity) === null || _a === void 0 ? void 0 : _a.toString()) || '0';
+        // Add target humidity from configuration
+        baseInfo['Target Humidity'] = ((_b = this.details.target_humidity) === null || _b === void 0 ? void 0 : _b.toString()) || '0';
+        return JSON.stringify(baseInfo, null, 4);
+    }
+}
+exports.VeSyncHumid200S = VeSyncHumid200S;

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

@@ -6,4 +6,7 @@ export { VeSyncTowerFan } from './towerFan';
 export { VeSyncHumidifier } from './humidifier';
 export { VeSyncWarmHumidifier } from './warmHumidifier';
 export { VeSyncHumid200300S } from './humid200300S';
+export { VeSyncSuperior6000S } from './superior6000S';
+export { VeSyncHumid1000S } from './humid1000S';
+export { VeSyncHumid200S } from './humid200S';
 export declare const fanModules: Record<string, new (details: Record<string, any>, manager: VeSync) => VeSyncFan>;

package/dist/lib/fans/index.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fanModules = exports.VeSyncHumid200300S = exports.VeSyncWarmHumidifier = exports.VeSyncHumidifier = exports.VeSyncTowerFan = exports.VeSyncAirBaseV2 = exports.VeSyncAirBypass = void 0;
+exports.fanModules = exports.VeSyncHumid200S = exports.VeSyncHumid1000S = exports.VeSyncSuperior6000S = 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");
+const superior6000S_1 = require("./superior6000S");
+const humid1000S_1 = require("./humid1000S");
+const humid200S_1 = require("./humid200S");
 // Re-export all classes
 var airBypass_2 = require("./airBypass");
 Object.defineProperty(exports, "VeSyncAirBypass", { enumerable: true, get: function () { return airBypass_2.VeSyncAirBypass; } });
@@ -19,6 +22,12 @@ 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; } });
+var superior6000S_2 = require("./superior6000S");
+Object.defineProperty(exports, "VeSyncSuperior6000S", { enumerable: true, get: function () { return superior6000S_2.VeSyncSuperior6000S; } });
+var humid1000S_2 = require("./humid1000S");
+Object.defineProperty(exports, "VeSyncHumid1000S", { enumerable: true, get: function () { return humid1000S_2.VeSyncHumid1000S; } });
+var humid200S_2 = require("./humid200S");
+Object.defineProperty(exports, "VeSyncHumid200S", { enumerable: true, get: function () { return humid200S_2.VeSyncHumid200S; } });
 // Export fan modules dictionary
 exports.fanModules = {
     // Core Series
@@ -64,7 +73,7 @@ exports.fanModules = {
     'LTF-F422S-WUS': towerFan_1.VeSyncTowerFan,
     // Classic Series
     'Classic300S': humidifier_1.VeSyncHumidifier,
-    'Classic200S': humidifier_1.VeSyncHumidifier,
+    'Classic200S': humid200S_1.VeSyncHumid200S,
     // Dual Series
     'Dual200S': humidifier_1.VeSyncHumidifier,
     // LUH Series
@@ -84,11 +93,11 @@ exports.fanModules = {
     '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,
+    'LUH-M101S-WUS': humid1000S_1.VeSyncHumid1000S,
+    'LUH-M101S-WEUR': humid1000S_1.VeSyncHumid1000S,
+    // LEH Series - Superior 6000S
+    'LEH-S601S-WUS': superior6000S_1.VeSyncSuperior6000S,
+    'LEH-S601S-WUSR': superior6000S_1.VeSyncSuperior6000S,
     // LV Series
     'LV-PUR131S': airBypass_1.VeSyncAirBypass,
     'LV-RH131S': airBypass_1.VeSyncAirBypass

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

@@ -0,0 +1,150 @@
+import { VeSyncFan } from '../vesyncFan';
+import { VeSync } from '../vesync';
+/**
+ * VeSync Superior 6000S Humidifier Class
+ * Implementation based on PyVeSync's VeSyncSuperior6000S class
+ */
+export declare class VeSyncSuperior6000S extends VeSyncFan {
+    protected readonly modes: readonly ["auto", "manual", "sleep", "humidity"];
+    protected readonly mistLevels: number[];
+    protected readonly humidityRange: {
+        min: number;
+        max: number;
+    };
+    protected readonly _apiModes: string[];
+    details: {
+        mode: string;
+        speed?: number;
+        filter_life?: number;
+        screen_status?: 'on' | 'off';
+        child_lock?: boolean;
+        humidity: number;
+        target_humidity: number;
+        mist_level: number;
+        mist_virtual_level: number;
+        water_lacks: boolean;
+        water_tank_lifted: boolean;
+        display: boolean;
+        filter_life_percentage: number;
+        temperature: number;
+        drying_mode: {
+            autoDryingSwitch?: number;
+            dryingState?: number;
+            dryingLevel?: number;
+            dryingRemain?: number;
+        };
+        configuration: Record<string, any>;
+        connection_status: string | null;
+    };
+    constructor(details: Record<string, any>, manager: VeSync);
+    /**
+     * Build API dictionary for humidifier
+     */
+    protected buildApiDict(method: string): [Record<string, any>, Record<string, any>];
+    /**
+     * 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 drying mode enabled
+     */
+    setDryingModeEnabled(enabled: boolean): Promise<boolean>;
+    /**
+     * Turn on display
+     */
+    turnOnDisplay(): Promise<boolean>;
+    /**
+     * Turn off display
+     */
+    turnOffDisplay(): Promise<boolean>;
+    /**
+     * Set auto mode
+     */
+    setAutoMode(): Promise<boolean>;
+    /**
+     * Set manual mode
+     */
+    setManualMode(): Promise<boolean>;
+    /**
+     * Get current humidity
+     * Provides access to the current humidity reading
+     */
+    get currentHumidity(): number;
+    /**
+     * Get target humidity
+     * Provides access to the target humidity setting
+     */
+    get targetHumidity(): number;
+    /**
+     * Get current temperature
+     * Provides access to the current temperature reading
+     */
+    get temperature(): number;
+    /**
+     * Check if water tank is empty
+     * Returns true if water tank is empty and needs to be refilled
+     */
+    get waterLacks(): boolean;
+    /**
+     * Check if water tank is lifted
+     * Returns true if water tank is lifted/removed from the device
+     */
+    get waterTankLifted(): boolean;
+    /**
+     * Get filter life percentage
+     * Returns the percentage of filter life remaining
+     */
+    get filterLifePercentage(): number;
+    /**
+     * Check if drying mode is enabled
+     * Returns true if drying mode is enabled
+     */
+    get dryingModeEnabled(): boolean;
+    /**
+     * Get drying mode state
+     * Returns 'on' if drying mode is active, 'off' if inactive, null if unknown
+     */
+    get dryingModeState(): string | null;
+    /**
+     * Get drying mode level
+     * Returns 'low' if level is 1, 'high' if level is 2, null if unknown
+     */
+    get dryingModeLevel(): string | null;
+    /**
+     * Get drying mode seconds remaining
+     * Returns the number of seconds remaining in drying mode
+     */
+    get dryingModeSecondsRemaining(): number;
+}