tsvesync 1.0.70 → 1.0.72

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;
+}

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/humidifier.d.ts

@@ -85,4 +85,24 @@ export declare class VeSyncHumidifier extends VeSyncFan {
      * Provides access to the current humidity reading
      */
     get currentHumidity(): 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;
+    /**
+     * Check if humidity is higher than target
+     * Returns true if current humidity is higher than target humidity
+     */
+    get humidityHigh(): boolean;
+    /**
+     * Check if automatic stop is active
+     * Returns true if automatic stop is currently active
+     */
+    get automaticStop(): boolean;
 }

package/dist/lib/fans/humidifier.js

@@ -391,5 +391,33 @@ class VeSyncHumidifier extends vesyncFan_1.VeSyncFan {
     get currentHumidity() {
         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() {
+        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() {
+        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() {
+        return this.details.humidity_high || false;
+    }
+    /**
+     * Check if automatic stop is active
+     * Returns true if automatic stop is currently active
+     */
+    get automaticStop() {
+        return this.details.automatic_stop || false;
+    }
 }
 exports.VeSyncHumidifier = VeSyncHumidifier;

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