tsvesync 1.0.71 → 1.0.73

package/dist/lib/fans/airBypass.js

@@ -314,6 +314,12 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
                 return false;
             }
         }
+        // Special handling for Core200S auto mode
+        if (this.deviceType.includes('Core200S') && mode === 'auto') {
+            // Core200S doesn't support auto mode, so we'll set it to manual mode
+            logger_1.logger.warn(`Auto mode not supported for ${this.deviceType}, using manual mode instead`);
+            return this.setMode('manual');
+        }
         // Standard implementation for other devices
         const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
             ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
@@ -328,20 +334,29 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
             }
         }, helpers_1.Helpers.reqHeaderBypass());
         const success = this.checkResponse([response, status], 'setMode');
-        if (!success) {
+        if (success) {
+            this.details.mode = mode;
+            return true;
+        }
+        else {
             logger_1.logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+            return false;
         }
-        return success;
     }
     /**
      * Set display status
      */
     async setDisplay(enabled) {
+        var _a;
         if (!this.hasFeature('display')) {
             const error = 'Display control not supported';
             logger_1.logger.error(`${error} for device: ${this.deviceName}`);
             throw new Error(error);
         }
+        // Check if device is in sleep mode - display control may not work in sleep mode
+        if (this.details.mode === 'sleep') {
+            logger_1.logger.warn(`Device ${this.deviceName} is in sleep mode, display control may not work`);
+        }
         logger_1.logger.debug(`Setting display to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
         // Special handling for LV series
         if (this.deviceType.startsWith('LV-')) {
@@ -384,23 +399,34 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
             }
         }, helpers_1.Helpers.reqHeaderBypass());
         const success = this.checkResponse([response, status], 'setDisplay');
+        // Check for error code 11018000 (operation not supported in current mode)
+        if (((_a = response === null || response === void 0 ? void 0 : response.result) === null || _a === void 0 ? void 0 : _a.code) === 11018000) {
+            logger_1.logger.warn(`Display control not supported in current mode for device: ${this.deviceName}`);
+            return false;
+        }
         if (success) {
             this.details.screenStatus = enabled ? 'on' : 'off';
+            return true;
         }
         else {
             logger_1.logger.error(`Failed to set display to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+            return false;
         }
-        return success;
     }
     /**
      * Set child lock
      */
     async setChildLock(enabled) {
+        var _a;
         if (!this.hasFeature('child_lock')) {
             const error = 'Child lock not supported';
             logger_1.logger.error(`${error} for device: ${this.deviceName}`);
             throw new Error(error);
         }
+        // Check if device is in sleep mode - child lock may not work in sleep mode
+        if (this.details.mode === 'sleep') {
+            logger_1.logger.warn(`Device ${this.deviceName} is in sleep mode, child lock control may not work`);
+        }
         logger_1.logger.debug(`Setting child lock to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
         // Special handling for LV series
         if (this.deviceType.startsWith('LV-')) {
@@ -425,6 +451,11 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
                 return true;
             }
             else {
+                // Check for error code 11000000 (feature not supported)
+                if ((response === null || response === void 0 ? void 0 : response.code) === 11000000) {
+                    logger_1.logger.warn(`Child lock control not supported via API for device: ${this.deviceName}`);
+                    return false;
+                }
                 logger_1.logger.error(`Failed to set child lock to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
                 return false;
             }
@@ -443,18 +474,25 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
             }
         }, helpers_1.Helpers.reqHeaderBypass());
         const success = this.checkResponse([response, status], 'setChildLock');
+        // Check for error code 11000000 (feature not supported)
+        if ((response === null || response === void 0 ? void 0 : response.code) === 11000000 || (((_a = response === null || response === void 0 ? void 0 : response.result) === null || _a === void 0 ? void 0 : _a.code) === 11000000)) {
+            logger_1.logger.warn(`Child lock control not supported via API for device: ${this.deviceName}`);
+            return false;
+        }
         if (success) {
-            this.details.child_lock = enabled;
+            this.details.childLock = enabled;
+            return true;
         }
         else {
             logger_1.logger.error(`Failed to set child lock to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+            return false;
         }
-        return success;
     }
     /**
      * Set timer
      */
     async setTimer(hours) {
+        var _a, _b;
         if (!this.hasFeature('timer')) {
             const error = 'Timer not supported';
             logger_1.logger.error(`${error} for device: ${this.deviceName}`);
@@ -480,10 +518,14 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
                 'tz': this.manager.timeZone
             });
             const success = this.checkResponse([response, status], 'setTimer');
-            if (!success) {
+            if (success) {
+                this.timer = { duration: hours * 3600, action: 'off' };
+                return true;
+            }
+            else {
                 logger_1.logger.error(`Failed to set timer to ${hours} hours for device: ${this.deviceName}`);
+                return false;
             }
-            return success;
         }
         // Standard implementation for other devices
         const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
@@ -500,20 +542,37 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
             }
         }, helpers_1.Helpers.reqHeaderBypass());
         const success = this.checkResponse([response, status], 'setTimer');
-        if (!success) {
+        // Check for successful response with timer ID
+        if (success && ((_b = (_a = response === null || response === void 0 ? void 0 : response.result) === null || _a === void 0 ? void 0 : _a.result) === null || _b === void 0 ? void 0 : _b.id)) {
+            this.timer = { duration: hours * 3600, action: 'off' };
+            return true;
+        }
+        else if (success) {
+            // API call succeeded but no timer ID returned
+            logger_1.logger.warn(`Timer API call succeeded but no timer ID returned for device: ${this.deviceName}`);
+            this.timer = { duration: hours * 3600, action: 'off' };
+            return true;
+        }
+        else {
             logger_1.logger.error(`Failed to set timer to ${hours} hours for device: ${this.deviceName}`);
+            return false;
         }
-        return success;
     }
     /**
      * Clear timer
      */
     async clearTimer() {
+        var _a;
         if (!this.hasFeature('timer')) {
             const error = 'Timer not supported';
             logger_1.logger.error(`${error} for device: ${this.deviceName}`);
             throw new Error(error);
         }
+        // If no timer is set, return success
+        if (!this.timer) {
+            logger_1.logger.debug(`No timer to clear for device: ${this.deviceName}`);
+            return true;
+        }
         logger_1.logger.debug(`Clearing timer for device: ${this.deviceName}`);
         // Special handling for LV series
         if (this.deviceType.startsWith('LV-')) {
@@ -532,10 +591,14 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
                 'tz': this.manager.timeZone
             });
             const success = this.checkResponse([response, status], 'clearTimer');
-            if (!success) {
+            if (success) {
+                this.timer = null;
+                return true;
+            }
+            else {
                 logger_1.logger.error(`Failed to clear timer for device: ${this.deviceName}`);
+                return false;
             }
-            return success;
         }
         // Standard implementation for other devices
         const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
@@ -549,10 +612,20 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
             }
         }, helpers_1.Helpers.reqHeaderBypass());
         const success = this.checkResponse([response, status], 'clearTimer');
-        if (!success) {
+        // Check for error code 11000000 (feature not supported or no timer to clear)
+        if ((response === null || response === void 0 ? void 0 : response.code) === 11000000 || (((_a = response === null || response === void 0 ? void 0 : response.result) === null || _a === void 0 ? void 0 : _a.code) === 11000000)) {
+            logger_1.logger.warn(`No timer to clear or timer control not supported via API for device: ${this.deviceName}`);
+            this.timer = null;
+            return true;
+        }
+        if (success) {
+            this.timer = null;
+            return true;
+        }
+        else {
             logger_1.logger.error(`Failed to clear timer for device: ${this.deviceName}`);
+            return false;
         }
-        return success;
     }
     /**
      * Turn automatic stop on

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

@@ -0,0 +1,70 @@
+import { VeSyncHumid200300S } from './humid200300S';
+import { VeSync } from '../vesync';
+/**
+ * VeSync Humid1000S Humidifier Class
+ * Implementation based on PyVeSync's VeSyncHumid1000S class
+ * For OASISMIST1000S models (LUH-M101S-WUS and LUH-M101S-WEUR)
+ */
+export declare class VeSyncHumid1000S extends VeSyncHumid200300S {
+    protected readonly _apiModes: string[];
+    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 night light
+     */
+    setNightLight(enabled: boolean, brightness?: number): Promise<boolean>;
+    /**
+     * Get night light status
+     * Returns the night light status (on/off)
+     */
+    get nightLightStatus(): string;
+    /**
+     * Get night light brightness
+     * Returns the night light brightness (0-100)
+     */
+    get nightLightBrightness(): number;
+    /**
+     * Set automatic stop
+     * Enable or disable automatic stop when target humidity is reached
+     */
+    setAutomaticStop(enabled: boolean): Promise<boolean>;
+    /**
+     * Turn automatic stop on
+     * Enable automatic stop when target humidity is reached
+     */
+    automaticStopOn(): Promise<boolean>;
+    /**
+     * Turn automatic stop off
+     * Disable automatic stop when target humidity is reached
+     */
+    automaticStopOff(): Promise<boolean>;
+    /**
+     * Get target humidity
+     * Returns the target humidity setting
+     */
+    get targetHumidity(): number;
+    /**
+     * Get automatic stop setting
+     * Returns whether automatic stop is enabled
+     */
+    get automaticStop(): boolean;
+}

package/dist/lib/fans/humid1000S.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeSyncHumid1000S = void 0;
+const humid200300S_1 = require("./humid200300S");
+const helpers_1 = require("../helpers");
+const logger_1 = require("../logger");
+/**
+ * VeSync Humid1000S Humidifier Class
+ * Implementation based on PyVeSync's VeSyncHumid1000S class
+ * For OASISMIST1000S models (LUH-M101S-WUS and LUH-M101S-WEUR)
+ */
+class VeSyncHumid1000S extends humid200300S_1.VeSyncHumid200300S {
+    constructor(details, manager) {
+        super(details, manager);
+        this._apiModes = [
+            'getHumidifierStatus',
+            'setSwitch',
+            'setVirtualLevel',
+            'setTargetHumidity',
+            'setHumidityMode',
+            'setDisplay',
+            'setNightLight',
+            'setAutoStopSwitch',
+        ];
+        // Update config for Humid1000S
+        this.config = {
+            module: 'VeSyncHumid1000S',
+            features: ['display', 'humidity', 'mist', 'timer', 'auto_mode', 'night_light'],
+            levels: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+        };
+        logger_1.logger.debug(`Initialized VeSyncHumid1000S device: ${this.deviceName}`);
+    }
+    /**
+     * Build API dictionary for humidifier
+     */
+    buildApiDict(method) {
+        if (!this._apiModes.includes(method)) {
+            logger_1.logger.debug(`Invalid mode - ${method}`);
+            throw new Error(`Invalid mode - ${method}`);
+        }
+        const head = helpers_1.Helpers.reqHeaderBypass();
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                method: method,
+                source: 'APP',
+                data: {}
+            }
+        };
+        return [head, body];
+    }
+    /**
+     * Get device details
+     */
+    async getDetails() {
+        var _a;
+        logger_1.logger.debug(`Getting details for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('getHumidifierStatus');
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        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 powerSwitch field
+            this.deviceStatus = result.powerSwitch === 1 ? 'on' : 'off';
+            // Build details object with Humid1000S specific fields
+            this.details = {
+                mode: result.workMode || '',
+                humidity: result.humidity || 0,
+                target_humidity: result.targetHumidity || 0,
+                mist_level: result.mistLevel || 0,
+                mist_virtual_level: result.virtualLevel || 0,
+                water_lacks: result.waterLacksState || false,
+                water_tank_lifted: result.waterTankLifted || false,
+                display: result.screenSwitch === 1,
+                night_light_status: result.nightLightStatus || 'off',
+                night_light_brightness: result.nightLightBrightness || 0,
+                connection_status: result.connectionStatus || null,
+                configuration: result.configuration || {}
+            };
+            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 [head, body] = this.buildApiDict('setSwitch');
+        body.payload.data = {
+            powerSwitch: enabled ? 1 : 0,
+            switchIdx: 0
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'toggleSwitch');
+        if (success) {
+            this.deviceStatus = enabled ? 'on' : 'off';
+            return true;
+        }
+        logger_1.logger.error(`Failed to set device power to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+        return false;
+    }
+    /**
+     * Set night light
+     */
+    async setNightLight(enabled, brightness) {
+        if (!this.hasFeature('night_light')) {
+            logger_1.logger.error(`Night light feature not supported for device: ${this.deviceName}`);
+            return false;
+        }
+        logger_1.logger.debug(`Setting night light to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('setNightLight');
+        body.payload.data = {
+            nightLightSwitch: enabled ? 1 : 0
+        };
+        // Add brightness if provided
+        if (enabled && brightness !== undefined) {
+            if (brightness < 1 || brightness > 100) {
+                logger_1.logger.error(`Invalid night light brightness: ${brightness}. Must be between 1 and 100.`);
+                return false;
+            }
+            body.payload.data.nightLightBrightness = brightness;
+        }
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setNightLight');
+        if (success) {
+            this.details.night_light_status = enabled ? 'on' : 'off';
+            if (enabled && brightness !== undefined) {
+                this.details.night_light_brightness = brightness;
+            }
+            return true;
+        }
+        // Check for API error code 11000000 (feature not supported)
+        if ((response === null || response === void 0 ? void 0 : response.code) === 11000000) {
+            logger_1.logger.warn(`Night light control not supported via API for device: ${this.deviceName}`);
+            return false;
+        }
+        logger_1.logger.error(`Failed to set night light for device: ${this.deviceName}`);
+        return false;
+    }
+    // Connection status is available in details.connection_status
+    /**
+     * Get night light status
+     * Returns the night light status (on/off)
+     */
+    get nightLightStatus() {
+        return this.details.night_light_status || 'off';
+    }
+    /**
+     * Get night light brightness
+     * Returns the night light brightness (0-100)
+     */
+    get nightLightBrightness() {
+        return this.details.night_light_brightness || 0;
+    }
+    /**
+     * Set automatic stop
+     * Enable or disable automatic stop when target humidity is reached
+     */
+    async setAutomaticStop(enabled) {
+        logger_1.logger.debug(`Setting automatic stop to ${enabled ? 'enabled' : 'disabled'} for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('setAutoStopSwitch');
+        body.payload.data = {
+            autoStopSwitch: enabled ? 1 : 0
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setAutomaticStop');
+        if (success) {
+            if (!this.details.configuration) {
+                this.details.configuration = {};
+            }
+            this.details.configuration.automatic_stop = enabled;
+            return true;
+        }
+        logger_1.logger.error(`Failed to set automatic stop for device: ${this.deviceName}`);
+        return false;
+    }
+    /**
+     * Turn automatic stop on
+     * Enable automatic stop when target humidity is reached
+     */
+    async automaticStopOn() {
+        return this.setAutomaticStop(true);
+    }
+    /**
+     * Turn automatic stop off
+     * Disable automatic stop when target humidity is reached
+     */
+    async automaticStopOff() {
+        return this.setAutomaticStop(false);
+    }
+    /**
+     * Get target humidity
+     * Returns the target humidity setting
+     */
+    get targetHumidity() {
+        return this.details.target_humidity || 0;
+    }
+    /**
+     * Get automatic stop setting
+     * Returns whether automatic stop is enabled
+     */
+    get automaticStop() {
+        var _a;
+        return ((_a = this.details.configuration) === null || _a === void 0 ? void 0 : _a.automatic_stop) || false;
+    }
+}
+exports.VeSyncHumid1000S = VeSyncHumid1000S;

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

@@ -0,0 +1,52 @@
+import { VeSyncHumidifier } from './humidifier';
+import { VeSync } from '../vesync';
+/**
+ * VeSync Humid200S Humidifier Class
+ * Implementation based on PyVeSync's VeSyncHumid200S class
+ * For Classic200S models
+ */
+export declare class VeSyncHumid200S extends VeSyncHumidifier {
+    protected readonly modes: readonly ["auto", "manual", "sleep"];
+    protected readonly features: string[];
+    protected readonly mistLevels: number[];
+    protected readonly humidityRange: {
+        min: number;
+        max: number;
+    };
+    constructor(details: Record<string, any>, manager: VeSync);
+    /**
+     * Get device details
+     */
+    getDetails(): Promise<Boolean>;
+    /**
+     * Set display
+     * Override to use setIndicatorLightSwitch method
+     */
+    setDisplay(enabled: boolean): Promise<boolean>;
+    /**
+     * Set mist level
+     */
+    setMistLevel(level: number): Promise<boolean>;
+    /**
+     * Get current humidity
+     * Provides access to the current humidity reading
+     */
+    get currentHumidity(): number;
+    /**
+     * Get target humidity
+     */
+    get targetHumidity(): number;
+    /**
+     * Get water lacks status
+     */
+    get waterLacks(): boolean;
+    /**
+     * Get water tank lifted status
+     */
+    get waterTankLifted(): boolean;
+    /**
+     * Return JSON details for humidifier
+     * Override to include current humidity and target humidity
+     */
+    displayJSON(): string;
+}