tsvesync 1.0.70 → 1.0.72

package/src/lib/fans/humid1000S.ts

@@ -0,0 +1,276 @@
+import { VeSyncHumid200300S } from './humid200300S';
+import { VeSync } from '../vesync';
+import { Helpers } from '../helpers';
+import { logger } from '../logger';
+
+/**
+ * VeSync Humid1000S Humidifier Class
+ * Implementation based on PyVeSync's VeSyncHumid1000S class
+ * For OASISMIST1000S models (LUH-M101S-WUS and LUH-M101S-WEUR)
+ */
+export class VeSyncHumid1000S extends VeSyncHumid200300S {
+    protected readonly _apiModes = [
+        'getHumidifierStatus',
+        'setSwitch',
+        'setVirtualLevel',
+        'setTargetHumidity',
+        'setHumidityMode',
+        'setDisplay',
+        'setNightLight',
+        'setAutoStopSwitch',
+    ];
+
+    constructor(details: Record<string, any>, manager: VeSync) {
+        super(details, manager);
+        
+        // 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.debug(`Initialized VeSyncHumid1000S device: ${this.deviceName}`);
+    }
+
+    /**
+     * Build API dictionary for humidifier
+     */
+    protected buildApiDict(method: string): [Record<string, any>, Record<string, any>] {
+        if (!this._apiModes.includes(method)) {
+            logger.debug(`Invalid mode - ${method}`);
+            throw new Error(`Invalid mode - ${method}`);
+        }
+        
+        const head = Helpers.reqHeaderBypass();
+        const body = {
+            ...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(): Promise<Boolean> {
+        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 && response?.result?.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.debug(`Successfully got details for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+
+    /**
+     * Turn device on
+     */
+    async turnOn(): Promise<boolean> {
+        return this.toggleSwitch(true);
+    }
+
+    /**
+     * Turn device off
+     */
+    async turnOff(): Promise<boolean> {
+        return this.toggleSwitch(false);
+    }
+
+    /**
+     * Toggle device power
+     */
+    async toggleSwitch(enabled: boolean): Promise<boolean> {
+        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.error(`Failed to set device power to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+        return false;
+    }
+
+    /**
+     * Set night light
+     */
+    async setNightLight(enabled: boolean, brightness?: number): Promise<boolean> {
+        if (!this.hasFeature('night_light')) {
+            logger.error(`Night light feature not supported for device: ${this.deviceName}`);
+            return false;
+        }
+
+        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.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?.code === 11000000) {
+            logger.warn(`Night light control not supported via API for device: ${this.deviceName}`);
+            return false;
+        }
+        
+        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(): string {
+        return this.details.night_light_status || 'off';
+    }
+
+    /**
+     * Get night light brightness
+     * Returns the night light brightness (0-100)
+     */
+    get nightLightBrightness(): number {
+        return this.details.night_light_brightness || 0;
+    }
+    
+    /**
+     * Set automatic stop
+     * Enable or disable automatic stop when target humidity is reached
+     */
+    async setAutomaticStop(enabled: boolean): Promise<boolean> {
+        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.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(): Promise<boolean> {
+        return this.setAutomaticStop(true);
+    }
+
+    /**
+     * Turn automatic stop off
+     * Disable automatic stop when target humidity is reached
+     */
+    async automaticStopOff(): Promise<boolean> {
+        return this.setAutomaticStop(false);
+    }
+
+    /**
+     * Get target humidity
+     * Returns the target humidity setting
+     */
+    get targetHumidity(): number {
+        return this.details.target_humidity || 0;
+    }
+
+    /**
+     * Get automatic stop setting
+     * Returns whether automatic stop is enabled
+     */
+    get automaticStop(): boolean {
+        return this.details.configuration?.automatic_stop || false;
+    }
+}

package/src/lib/fans/humid200S.ts

@@ -0,0 +1,199 @@
+import { VeSyncHumidifier } from './humidifier';
+import { VeSync } from '../vesync';
+import { Helpers } from '../helpers';
+import { logger } from '../logger';
+
+/**
+ * VeSync Humid200S Humidifier Class
+ * Implementation based on PyVeSync's VeSyncHumid200S class
+ * For Classic200S models
+ */
+export class VeSyncHumid200S extends VeSyncHumidifier {
+    protected readonly modes = ['auto', 'manual', 'sleep'] as const;
+    protected readonly features = ['humidity', 'mist', 'display', 'timer', 'auto_mode'];
+    protected readonly mistLevels = [1, 2, 3];
+    protected readonly humidityRange = { min: 30, max: 80 };
+
+    constructor(details: Record<string, any>, manager: VeSync) {
+        super(details, manager);
+        
+        // Update config for Humid200S
+        this.config = {
+            module: 'VeSyncHumid200S',
+            features: ['display', 'humidity', 'mist', 'timer', 'auto_mode'],
+            levels: [1, 2, 3]
+        };
+        
+        logger.debug(`Initialized VeSyncHumid200S device: ${this.deviceName}`);
+    }
+
+    /**
+     * Get device details
+     */
+    async getDetails(): Promise<Boolean> {
+        logger.debug(`Getting details for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            {
+                ...Helpers.reqBody(this.manager, 'bypassV2'),
+                cid: this.cid,
+                configModule: this.configModule,
+                payload: {
+                    data: {},
+                    method: 'getHumidifierStatus',
+                    source: 'APP'
+                }
+            },
+            Helpers.reqHeaderBypass()
+        );
+
+        const success = this.checkResponse([response, status], 'getDetails');
+        if (success && response?.result?.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: result.configuration?.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: result.configuration?.automatic_stop || false,
+                auto_target_humidity: result.configuration?.auto_target_humidity || 0,
+                configuration: result.configuration || {}
+            };
+
+            logger.debug(`Successfully got details for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+
+    /**
+     * Set display
+     * Override to use setIndicatorLightSwitch method
+     */
+    async setDisplay(enabled: boolean): Promise<boolean> {
+        logger.info(`Setting display to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            {
+                ...Helpers.reqBody(this.manager, 'bypassV2'),
+                cid: this.cid,
+                configModule: this.configModule,
+                payload: {
+                    data: {
+                        enabled: enabled
+                    },
+                    method: 'setIndicatorLightSwitch',
+                    source: 'APP'
+                }
+            },
+            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.debug(`Device state after display change: ${JSON.stringify(this.details)}`);
+        } else {
+            logger.error(`Failed to set display to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+
+    /**
+     * Set mist level
+     */
+    async setMistLevel(level: number): Promise<boolean> {
+        if (!this.mistLevels.includes(level)) {
+            const error = `Invalid mist level: ${level}. Must be one of: ${this.mistLevels.join(', ')}`;
+            logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+
+        logger.info(`Setting mist level to ${level} for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            {
+                ...Helpers.reqBody(this.manager, 'bypassV2'),
+                cid: this.cid,
+                configModule: this.configModule,
+                payload: {
+                    data: {
+                        level: level
+                    },
+                    method: 'setMistLevel',  // Use setMistLevel for Classic200S
+                    source: 'APP'
+                }
+            },
+            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.debug(`Device state after mist level change: ${JSON.stringify(this.details)}`);
+        } else {
+            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(): number {
+        return this.details.humidity || 0;
+    }
+
+    /**
+     * Get target humidity
+     */
+    get targetHumidity(): number {
+        return this.details.target_humidity || 0;
+    }
+
+    /**
+     * Get water lacks status
+     */
+    get waterLacks(): boolean {
+        return this.details.water_lacks || false;
+    }
+
+    /**
+     * Get water tank lifted status
+     */
+    get waterTankLifted(): boolean {
+        return this.details.water_tank_lifted || false;
+    }
+
+    /**
+     * Return JSON details for humidifier
+     * Override to include current humidity and target humidity
+     */
+    displayJSON(): string {
+        const baseInfo = JSON.parse(super.displayJSON());
+        
+        // Add current humidity from details
+        baseInfo['Humidity'] = this.details.humidity?.toString() || '0';
+        
+        // Add target humidity from configuration
+        baseInfo['Target Humidity'] = this.details.target_humidity?.toString() || '0';
+        
+        return JSON.stringify(baseInfo, null, 4);
+    }
+}

package/src/lib/fans/humidifier.ts

@@ -475,4 +475,36 @@ export class VeSyncHumidifier extends VeSyncFan {
     get currentHumidity(): number {
         return this.details.humidity || 0;
     }
+
+    /**
+     * Check if water tank is empty
+     * Returns true if water tank is empty and needs to be refilled
+     */
+    get waterLacks(): boolean {
+        return this.details.water_lacks || false;
+    }
+
+    /**
+     * Check if water tank is lifted
+     * Returns true if water tank is lifted/removed from the device
+     */
+    get waterTankLifted(): boolean {
+        return this.details.water_tank_lifted || false;
+    }
+
+    /**
+     * Check if humidity is higher than target
+     * Returns true if current humidity is higher than target humidity
+     */
+    get humidityHigh(): boolean {
+        return this.details.humidity_high || false;
+    }
+
+    /**
+     * Check if automatic stop is active
+     * Returns true if automatic stop is currently active
+     */
+    get automaticStop(): boolean {
+        return this.details.automatic_stop || false;
+    }
 }

package/src/lib/fans/index.ts

@@ -4,6 +4,9 @@ import { VeSyncTowerFan } from './towerFan';
 import { VeSyncHumidifier } from './humidifier';
 import { VeSyncWarmHumidifier } from './warmHumidifier';
 import { VeSyncHumid200300S } from './humid200300S';
+import { VeSyncSuperior6000S } from './superior6000S';
+import { VeSyncHumid1000S } from './humid1000S';
+import { VeSyncHumid200S } from './humid200S';
 import { VeSyncFan } from '../vesyncFan';
 import { VeSync } from '../vesync';
 
@@ -14,6 +17,9 @@ 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 fan modules dictionary
 export const fanModules: Record<string, new (details: Record<string, any>, manager: VeSync) => VeSyncFan> = {
@@ -66,7 +72,7 @@ export const fanModules: Record<string, new (details: Record<string, any>, manag
     
     // Classic Series
     'Classic300S': VeSyncHumidifier,
-    'Classic200S': VeSyncHumidifier,
+    'Classic200S': VeSyncHumid200S,
     
     // Dual Series
     'Dual200S': VeSyncHumidifier,
@@ -88,12 +94,12 @@ export const fanModules: Record<string, new (details: Record<string, any>, manag
     'LUH-O451S-WUSR': VeSyncHumid200300S,
     'LUH-O601S-WUS': VeSyncHumid200300S,
     'LUH-O601S-KUS': VeSyncHumid200300S,
-    'LUH-M101S-WUS': VeSyncHumid200300S,
-    'LUH-M101S-WEUR': VeSyncHumid200300S,
+    'LUH-M101S-WUS': VeSyncHumid1000S,
+    'LUH-M101S-WEUR': VeSyncHumid1000S,
     
-    // LEH Series
-    'LEH-S601S-WUS': VeSyncHumid200300S,
-    'LEH-S601S-WUSR': VeSyncHumid200300S,
+    // LEH Series - Superior 6000S
+    'LEH-S601S-WUS': VeSyncSuperior6000S,
+    'LEH-S601S-WUSR': VeSyncSuperior6000S,
     
     // LV Series
     'LV-PUR131S': VeSyncAirBypass,