tsvesync 1.3.13 → 1.4.0

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

@@ -57,6 +57,14 @@ export declare class VeSyncAirBaseV2 extends VeSyncAirBypass {
      * Override setMode to send workMode payloads for bypassV2 purifiers.
      */
     setMode(mode: string): Promise<boolean>;
+    /**
+     * Convenience helper to enter turbo mode when supported.
+     */
+    turboMode(): Promise<boolean>;
+    /**
+     * Convenience helper to enter pet mode when supported.
+     */
+    petMode(): Promise<boolean>;
     /**
      * Override changeFanSpeed to use manualSpeedLevel for bypassV2 purifiers.
      */

package/dist/lib/fans/airBaseV2.js

@@ -13,11 +13,11 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
         this._lightDetection = false;
         this._lightDetectionState = false;
         this.setSpeedLevel = null;
-        this.autoPreferences = ['default', 'efficient', 'quiet'];
         this.enabled = false;
         this._mode = '';
         this._speed = 0;
         this._timer = null;
+        this.autoPreferences = [...this.getConfigAutoPreferences(['default', 'efficient', 'quiet'])];
         logger_1.logger.debug(`Initialized VeSyncAirBaseV2 device: ${this.deviceName}`);
     }
     buildConfigDict(configDict) {
@@ -265,28 +265,63 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
      * Override setMode to send workMode payloads for bypassV2 purifiers.
      */
     async setMode(mode) {
-        if (!this.modes.includes(mode)) {
+        var _a, _b;
+        const targetMode = mode.toLowerCase();
+        const supportedModes = this.modes.map(m => m.toLowerCase());
+        if (!supportedModes.includes(targetMode)) {
             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);
         }
         // Special handling for Core200S stays the same for all models
-        if (this.deviceType.includes('Core200S') && mode === 'auto') {
+        if (this.deviceType.includes('Core200S') && targetMode === 'auto') {
             logger_1.logger.warn(`Auto mode not supported for ${this.deviceType}, using manual mode instead`);
             return this.setMode('manual');
         }
+        // Manual mode should leverage changeFanSpeed to mirror pyvesync behaviour
+        if (targetMode === 'manual') {
+            const defaultLevel = this.config.levels && this.config.levels.length > 0
+                ? this.config.levels[0]
+                : 1;
+            const desiredLevel = (_b = (_a = this.details.manualSpeedLevel) !== null && _a !== void 0 ? _a : this.speed) !== null && _b !== void 0 ? _b : defaultLevel;
+            const success = await this.changeFanSpeed(desiredLevel);
+            if (success) {
+                this.details.mode = 'manual';
+                this.mode = 'manual';
+            }
+            return success;
+        }
         // BypassV2 purifiers need the workMode payload; other models use the base implementation
         if (this.requiresPowerSwitchPayload()) {
             logger_1.logger.debug(`Using bypassV2 mode payload for ${this.deviceName}`);
             const [head, body] = this.buildApiDict('setPurifierMode');
             body.payload.data = {
-                workMode: mode
+                workMode: targetMode
             };
             const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
             const success = this.checkV2Response(response, status, 'setMode');
             if (success) {
-                this.details.mode = mode;
-                this._mode = mode;
+                this.details.mode = targetMode;
+                this.mode = targetMode;
+                // Update cached speed snapshot for special modes
+                if (targetMode === 'sleep') {
+                    this.speed = 0;
+                    this.details.speed = 0;
+                }
+                else if (targetMode === 'turbo') {
+                    const maxSpeed = this.config.levels && this.config.levels.length > 0
+                        ? Math.max(...this.config.levels)
+                        : this.speed;
+                    if (typeof maxSpeed === 'number' && maxSpeed > 0) {
+                        this.speed = maxSpeed;
+                        this.details.speed = maxSpeed;
+                    }
+                }
+                else if (targetMode === 'auto') {
+                    this.speed = 0;
+                    this.details.speed = 0;
+                    this.details.isAutoSentinel = true;
+                }
                 // Force a details update to sync state
                 setTimeout(() => {
                     this.getDetails().catch(e => {
@@ -296,7 +331,7 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
                 return true;
             }
             else {
-                logger_1.logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+                logger_1.logger.error(`Failed to set mode to ${targetMode} for device: ${this.deviceName}`);
                 return false;
             }
         }
@@ -305,6 +340,26 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
             return super.setMode(mode);
         }
     }
+    /**
+     * Convenience helper to enter turbo mode when supported.
+     */
+    async turboMode() {
+        if (!this.modes.map(m => m.toLowerCase()).includes('turbo')) {
+            logger_1.logger.debug(`Turbo mode not supported for device: ${this.deviceName}`);
+            return false;
+        }
+        return this.setMode('turbo');
+    }
+    /**
+     * Convenience helper to enter pet mode when supported.
+     */
+    async petMode() {
+        if (!this.modes.map(m => m.toLowerCase()).includes('pet')) {
+            logger_1.logger.debug(`Pet mode not supported for device: ${this.deviceName}`);
+            return false;
+        }
+        return this.setMode('pet');
+    }
     /**
      * Override changeFanSpeed to use manualSpeedLevel for bypassV2 purifiers.
      */
@@ -331,6 +386,10 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
             if (success) {
                 this.speed = speed;
                 this.details.manualSpeedLevel = speed;
+                this.details.speed = speed;
+                this.details.mode = 'manual';
+                this.mode = 'manual';
+                this.details.isAutoSentinel = false;
                 // Force a details update to sync state
                 setTimeout(() => {
                     this.getDetails().catch(e => {
@@ -357,6 +416,10 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
             if (success) {
                 this.speed = speed;
                 this.details.manualSpeedLevel = speed;
+                this.details.speed = speed;
+                this.details.mode = 'manual';
+                this.mode = 'manual';
+                this.details.isAutoSentinel = false;
                 return true;
             }
             else {
@@ -370,7 +433,7 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
      */
     async setAutoPreference(preference = 'default', roomSize = 600) {
         if (!this.autoPreferences.includes(preference)) {
-            logger_1.logger.debug(`Invalid preference: ${preference} - valid preferences are default, efficient, quiet`);
+            logger_1.logger.debug(`Invalid preference: ${preference} - valid preferences are ${this.autoPreferences.join(', ')}`);
             return false;
         }
         const [head, body] = this.buildApiDict('setAutoPreference');

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

@@ -4,7 +4,7 @@ import { VeSync } from '../vesync';
  * VeSync Air Purifier with Bypass
  */
 export declare class VeSyncAirBypass extends VeSyncFan {
-    protected readonly modes: readonly ["auto", "manual", "sleep"];
+    protected get modes(): ReadonlyArray<string>;
     protected readonly displayModes: readonly ["on", "off"];
     protected readonly childLockModes: readonly ["on", "off"];
     constructor(details: Record<string, any>, manager: VeSync);

package/dist/lib/fans/airBypass.js

@@ -8,9 +8,11 @@ const logger_1 = require("../logger");
  * VeSync Air Purifier with Bypass
  */
 class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
+    get modes() {
+        return this.getConfigModes(['auto', 'manual', 'sleep']);
+    }
     constructor(details, manager) {
         super(details, manager);
-        this.modes = ['auto', 'manual', 'sleep'];
         this.displayModes = ['on', 'off'];
         this.childLockModes = ['on', 'off'];
         logger_1.logger.debug(`Initialized VeSyncAirBypass device: ${this.deviceName}`);
@@ -183,14 +185,17 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
      * Set device mode
      */
     async setMode(mode) {
-        if (!this.modes.includes(mode)) {
+        const requested = mode.toLowerCase();
+        const supported = this.modes.map(m => m.toLowerCase());
+        const allowsCore200AutoFallback = this.deviceType.includes('Core200S') && requested === 'auto';
+        if (!supported.includes(requested) && !allowsCore200AutoFallback) {
             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}`);
+        logger_1.logger.debug(`Setting mode to ${requested} for device: ${this.deviceName}`);
         // Special handling for Core200S auto mode
-        if (this.deviceType.includes('Core200S') && mode === 'auto') {
+        if (allowsCore200AutoFallback) {
             // 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');
@@ -202,7 +207,7 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
             configModule: this.configModule,
             payload: {
                 data: {
-                    mode
+                    mode: requested
                 },
                 method: 'setPurifierMode',
                 source: 'APP'
@@ -210,11 +215,11 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
         }, helpers_1.Helpers.reqHeaderBypass());
         const success = this.checkResponse([response, status], 'setMode');
         if (success) {
-            this.details.mode = mode;
+            this.details.mode = requested;
             return true;
         }
         else {
-            logger_1.logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+            logger_1.logger.error(`Failed to set mode to ${requested} for device: ${this.deviceName}`);
             return false;
         }
     }

package/dist/lib/vesyncFan.d.ts

@@ -3,12 +3,15 @@
  */
 import { VeSyncBaseDevice } from './vesyncBaseDevice';
 import { VeSync } from './vesync';
+interface FanConfigEntry {
+    module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2' | 'VeSyncSuperior6000S' | 'VeSyncHumid1000S' | 'VeSyncHumid200S' | 'VeSyncAir131';
+    features: string[];
+    levels?: number[];
+    modes?: ReadonlyArray<string>;
+    autoPreferences?: ReadonlyArray<string>;
+}
 interface FanConfig {
-    [key: string]: {
-        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2' | 'VeSyncSuperior6000S' | 'VeSyncHumid1000S' | 'VeSyncHumid200S' | 'VeSyncAir131';
-        features: string[];
-        levels?: number[];
-    };
+    [key: string]: FanConfigEntry;
 }
 export declare const fanConfig: FanConfig;
 /**
@@ -42,16 +45,28 @@ export declare abstract class VeSyncFan extends VeSyncBaseDevice {
         duration: number;
         action: string;
     } | null;
-    protected config: {
-        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2' | 'VeSyncSuperior6000S' | 'VeSyncHumid1000S' | 'VeSyncHumid200S' | 'VeSyncAir131';
-        features: string[];
-        levels?: number[];
-    };
+    protected config: FanConfigEntry;
     constructor(details: Record<string, any>, manager: VeSync);
     /**
      * Check if feature is supported
      */
     hasFeature(feature: string): boolean;
+    /**
+     * Get configured modes for the device, falling back to provided defaults.
+     */
+    protected getConfigModes(defaultModes?: ReadonlyArray<string>): ReadonlyArray<string>;
+    /**
+     * Get configured auto preferences for the device, falling back to provided defaults.
+     */
+    protected getConfigAutoPreferences(defaultPreferences?: ReadonlyArray<string>): ReadonlyArray<string>;
+    /**
+     * Public accessor for supported modes for consumers that need to inspect capability metadata.
+     */
+    getSupportedModes(defaultModes?: ReadonlyArray<string>): ReadonlyArray<string>;
+    /**
+     * Public accessor for supported auto preference profiles.
+     */
+    getSupportedAutoPreferences(defaultPreferences?: ReadonlyArray<string>): ReadonlyArray<string>;
     /**
      * Check if feature is supported in current mode
      */

package/dist/lib/vesyncFan.js

@@ -13,158 +13,217 @@ exports.fanConfig = {
     'Core200S': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4] // 4 levels including sleep mode, matching reference plugin
+        levels: [1, 2, 3, 4], // 4 levels including sleep mode, matching reference plugin
+        modes: ['sleep', 'manual']
     },
     'Core300S': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'Core400S': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'Core600S': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     // LAP Series
     'LAP-C201S-AUSR': {
         module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3]
+        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'sleep_mode', 'filter_life'],
+        levels: [1, 2, 3],
+        modes: ['sleep', 'manual']
     },
     'LAP-C202S-WUSR': {
         module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3]
+        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'sleep_mode', 'filter_life'],
+        levels: [1, 2, 3],
+        modes: ['sleep', 'manual']
     },
     'LAP-C301S-WJP': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C302S-WUSB': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C301S-WAAA': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C401S-WJP': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C401S-WUSR': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C401S-WAAA': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C601S-WUS': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C601S-WUSR': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C601S-WEU': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V102S-AASR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V102S-WUS': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V102S-WEU': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V102S-AUSR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V102S-WJP': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201S-AASR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201S-WJP': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201S-WEU': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201S-WUS': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201-AUSR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201S-AUSR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201S-AEUR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-EL551S-AUS': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'sleep_mode', 'turbo_mode', 'light_detection', 'filter_life'],
+        levels: [1, 2, 3],
+        modes: ['sleep', 'manual', 'auto', 'turbo'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-EL551S-AEUR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'sleep_mode', 'turbo_mode', 'light_detection', 'filter_life'],
+        levels: [1, 2, 3],
+        modes: ['sleep', 'manual', 'auto', 'turbo'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-EL551S-WEU': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'sleep_mode', 'turbo_mode', 'light_detection', 'filter_life'],
+        levels: [1, 2, 3],
+        modes: ['sleep', 'manual', 'auto', 'turbo'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-EL551S-WUS': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'sleep_mode', 'turbo_mode', 'light_detection', 'filter_life'],
+        levels: [1, 2, 3],
+        modes: ['sleep', 'manual', 'auto', 'turbo'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     // LTF Series
     'LTF-F422S-KEU': {
@@ -311,11 +370,25 @@ class VeSyncFan extends vesyncBaseDevice_1.VeSyncBaseDevice {
         this.speed_dict = {};
         this._timer = null;
         this.details = details;
-        this.config = exports.fanConfig[this.deviceType] || {
-            module: 'VeSyncAirBypass',
-            features: [],
-            levels: []
-        };
+        const entry = exports.fanConfig[this.deviceType];
+        if (entry) {
+            this.config = {
+                ...entry,
+                features: [...entry.features],
+                levels: entry.levels ? [...entry.levels] : undefined,
+                modes: entry.modes ? [...entry.modes] : undefined,
+                autoPreferences: entry.autoPreferences ? [...entry.autoPreferences] : undefined
+            };
+        }
+        else {
+            this.config = {
+                module: 'VeSyncAirBypass',
+                features: [],
+                levels: [],
+                modes: [],
+                autoPreferences: []
+            };
+        }
     }
     /**
      * Check if feature is supported
@@ -323,6 +396,36 @@ class VeSyncFan extends vesyncBaseDevice_1.VeSyncBaseDevice {
     hasFeature(feature) {
         return this.config.features.includes(feature);
     }
+    /**
+     * Get configured modes for the device, falling back to provided defaults.
+     */
+    getConfigModes(defaultModes = []) {
+        if (Array.isArray(this.config.modes) && this.config.modes.length > 0) {
+            return this.config.modes;
+        }
+        return defaultModes;
+    }
+    /**
+     * Get configured auto preferences for the device, falling back to provided defaults.
+     */
+    getConfigAutoPreferences(defaultPreferences = []) {
+        if (Array.isArray(this.config.autoPreferences) && this.config.autoPreferences.length > 0) {
+            return this.config.autoPreferences;
+        }
+        return defaultPreferences;
+    }
+    /**
+     * Public accessor for supported modes for consumers that need to inspect capability metadata.
+     */
+    getSupportedModes(defaultModes = []) {
+        return this.getConfigModes(defaultModes);
+    }
+    /**
+     * Public accessor for supported auto preference profiles.
+     */
+    getSupportedAutoPreferences(defaultPreferences = []) {
+        return this.getConfigAutoPreferences(defaultPreferences);
+    }
     /**
      * Check if feature is supported in current mode
      */
@@ -355,7 +458,10 @@ class VeSyncFan extends vesyncBaseDevice_1.VeSyncBaseDevice {
      * Get maximum fan speed level
      */
     getMaxFanSpeed() {
-        return this.config.levels ? Math.max(...this.config.levels) : 3;
+        if (this.config.levels && this.config.levels.length > 0) {
+            return Math.max(...this.config.levels);
+        }
+        return 3;
     }
     /**
      * Get current mode

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "tsvesync",
-  "version": "1.3.13",
+  "version": "1.4.0",
   "description": "A TypeScript library for interacting with VeSync smart home devices",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf dist",
+    "test:everest": "ts-node test/everest-air-parity.test.ts",
     "prepare": "npm run build",
     "version": "git add -A src",
     "postversion": "git push && git push --tags"

package/src/lib/fans/airBaseV2.ts

@@ -10,7 +10,7 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
     protected _lightDetection: boolean = false;
     protected _lightDetectionState: boolean = false;
     protected setSpeedLevel: number | null = null;
-    protected autoPreferences: string[] = ['default', 'efficient', 'quiet'];
+    protected autoPreferences: string[];
     protected enabled: boolean = false;
     protected _mode: string = '';
     protected _speed: number = 0;
@@ -18,6 +18,7 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
 
     constructor(details: Record<string, any>, manager: VeSync) {
         super(details, manager);
+        this.autoPreferences = [...this.getConfigAutoPreferences(['default', 'efficient', 'quiet'])];
         logger.debug(`Initialized VeSyncAirBaseV2 device: ${this.deviceName}`);
     }
 
@@ -310,24 +311,41 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
      * Override setMode to send workMode payloads for bypassV2 purifiers.
      */
     override async setMode(mode: string): Promise<boolean> {
-        if (!this.modes.includes(mode as any)) {
+        const targetMode = mode.toLowerCase();
+        const supportedModes = this.modes.map(m => m.toLowerCase());
+
+        if (!supportedModes.includes(targetMode)) {
             const error = `Invalid mode: ${mode}. Must be one of: ${this.modes.join(', ')}`;
             logger.error(`${error} for device: ${this.deviceName}`);
             throw new Error(error);
         }
 
         // Special handling for Core200S stays the same for all models
-        if (this.deviceType.includes('Core200S') && mode === 'auto') {
+        if (this.deviceType.includes('Core200S') && targetMode === 'auto') {
             logger.warn(`Auto mode not supported for ${this.deviceType}, using manual mode instead`);
             return this.setMode('manual');
         }
 
+        // Manual mode should leverage changeFanSpeed to mirror pyvesync behaviour
+        if (targetMode === 'manual') {
+            const defaultLevel = this.config.levels && this.config.levels.length > 0
+                ? this.config.levels[0]
+                : 1;
+            const desiredLevel = this.details.manualSpeedLevel ?? this.speed ?? defaultLevel;
+            const success = await this.changeFanSpeed(desiredLevel);
+            if (success) {
+                this.details.mode = 'manual';
+                this.mode = 'manual';
+            }
+            return success;
+        }
+
         // BypassV2 purifiers need the workMode payload; other models use the base implementation
         if (this.requiresPowerSwitchPayload()) {
             logger.debug(`Using bypassV2 mode payload for ${this.deviceName}`);
             const [head, body] = this.buildApiDict('setPurifierMode');
             body.payload.data = {
-                workMode: mode
+                workMode: targetMode
             };
 
             const [response, status] = await this.callApi(
@@ -339,8 +357,26 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
 
             const success = this.checkV2Response(response, status, 'setMode');
             if (success) {
-                this.details.mode = mode;
-                this._mode = mode;
+                this.details.mode = targetMode;
+                this.mode = targetMode;
+
+                // Update cached speed snapshot for special modes
+                if (targetMode === 'sleep') {
+                    this.speed = 0;
+                    this.details.speed = 0;
+                } else if (targetMode === 'turbo') {
+                    const maxSpeed = this.config.levels && this.config.levels.length > 0
+                        ? Math.max(...this.config.levels)
+                        : this.speed;
+                    if (typeof maxSpeed === 'number' && maxSpeed > 0) {
+                        this.speed = maxSpeed;
+                        this.details.speed = maxSpeed;
+                    }
+                } else if (targetMode === 'auto') {
+                    this.speed = 0;
+                    this.details.speed = 0;
+                    this.details.isAutoSentinel = true;
+                }
                 
                 // Force a details update to sync state
                 setTimeout(() => {
@@ -351,7 +387,7 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
                 
                 return true;
             } else {
-                logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+                logger.error(`Failed to set mode to ${targetMode} for device: ${this.deviceName}`);
                 return false;
             }
         } else {
@@ -360,6 +396,28 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
         }
     }
 
+    /**
+     * Convenience helper to enter turbo mode when supported.
+     */
+    async turboMode(): Promise<boolean> {
+        if (!this.modes.map(m => m.toLowerCase()).includes('turbo')) {
+            logger.debug(`Turbo mode not supported for device: ${this.deviceName}`);
+            return false;
+        }
+        return this.setMode('turbo');
+    }
+
+    /**
+     * Convenience helper to enter pet mode when supported.
+     */
+    async petMode(): Promise<boolean> {
+        if (!this.modes.map(m => m.toLowerCase()).includes('pet')) {
+            logger.debug(`Pet mode not supported for device: ${this.deviceName}`);
+            return false;
+        }
+        return this.setMode('pet');
+    }
+
     /**
      * Override changeFanSpeed to use manualSpeedLevel for bypassV2 purifiers.
      */
@@ -395,6 +453,10 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
             if (success) {
                 this.speed = speed;
                 this.details.manualSpeedLevel = speed;
+                this.details.speed = speed;
+                this.details.mode = 'manual';
+                this.mode = 'manual';
+                this.details.isAutoSentinel = false;
                 
                 // Force a details update to sync state
                 setTimeout(() => {
@@ -428,6 +490,10 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
             if (success) {
                 this.speed = speed;
                 this.details.manualSpeedLevel = speed;
+                this.details.speed = speed;
+                this.details.mode = 'manual';
+                this.mode = 'manual';
+                this.details.isAutoSentinel = false;
                 return true;
             } else {
                 logger.error(`Failed to change fan speed to ${speed} for device: ${this.deviceName}`);
@@ -441,7 +507,7 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
      */
     async setAutoPreference(preference: string = 'default', roomSize: number = 600): Promise<boolean> {
         if (!this.autoPreferences.includes(preference)) {
-            logger.debug(`Invalid preference: ${preference} - valid preferences are default, efficient, quiet`);
+            logger.debug(`Invalid preference: ${preference} - valid preferences are ${this.autoPreferences.join(', ')}`);
             return false;
         }
 

package/src/lib/fans/airBypass.ts

@@ -7,7 +7,9 @@ import { logger } from '../logger';
  * VeSync Air Purifier with Bypass
  */
 export class VeSyncAirBypass extends VeSyncFan {
-    protected readonly modes = ['auto', 'manual', 'sleep'] as const;
+    protected get modes(): ReadonlyArray<string> {
+        return this.getConfigModes(['auto', 'manual', 'sleep']);
+    }
     protected readonly displayModes = ['on', 'off'] as const;
     protected readonly childLockModes = ['on', 'off'] as const;
 
@@ -216,16 +218,20 @@ export class VeSyncAirBypass extends VeSyncFan {
      * Set device mode
      */
     async setMode(mode: string): Promise<boolean> {
-        if (!this.modes.includes(mode as any)) {
+        const requested = mode.toLowerCase();
+        const supported = this.modes.map(m => m.toLowerCase());
+        const allowsCore200AutoFallback = this.deviceType.includes('Core200S') && requested === 'auto';
+
+        if (!supported.includes(requested) && !allowsCore200AutoFallback) {
             const error = `Invalid mode: ${mode}. Must be one of: ${this.modes.join(', ')}`;
             logger.error(`${error} for device: ${this.deviceName}`);
             throw new Error(error);
         }
 
-        logger.debug(`Setting mode to ${mode} for device: ${this.deviceName}`);
+        logger.debug(`Setting mode to ${requested} for device: ${this.deviceName}`);
 
         // Special handling for Core200S auto mode
-        if (this.deviceType.includes('Core200S') && mode === 'auto') {
+        if (allowsCore200AutoFallback) {
             // Core200S doesn't support auto mode, so we'll set it to manual mode
             logger.warn(`Auto mode not supported for ${this.deviceType}, using manual mode instead`);
             return this.setMode('manual');
@@ -241,7 +247,7 @@ export class VeSyncAirBypass extends VeSyncFan {
                 configModule: this.configModule,
                 payload: {
                     data: {
-                        mode
+                        mode: requested
                     },
                     method: 'setPurifierMode',
                     source: 'APP'
@@ -252,10 +258,10 @@ export class VeSyncAirBypass extends VeSyncFan {
 
         const success = this.checkResponse([response, status], 'setMode');
         if (success) {
-            this.details.mode = mode;
+            this.details.mode = requested;
             return true;
         } else {
-            logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+            logger.error(`Failed to set mode to ${requested} for device: ${this.deviceName}`);
             return false;
         }
     }

package/src/lib/vesyncFan.ts

@@ -7,12 +7,16 @@ import { VeSync } from './vesync';
 import { logger } from './logger';
 import { Helpers } from './helpers';
 
+interface FanConfigEntry {
+    module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2' | 'VeSyncSuperior6000S' | 'VeSyncHumid1000S' | 'VeSyncHumid200S' | 'VeSyncAir131';
+    features: string[];
+    levels?: number[];
+    modes?: ReadonlyArray<string>;
+    autoPreferences?: ReadonlyArray<string>;
+}
+
 interface FanConfig {
-    [key: string]: {
-        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2' | 'VeSyncSuperior6000S' | 'VeSyncHumid1000S' | 'VeSyncHumid200S' | 'VeSyncAir131';
-        features: string[];
-        levels?: number[];
-    };
+    [key: string]: FanConfigEntry;
 }
 
 // Fan configuration
@@ -21,159 +25,218 @@ export const fanConfig: FanConfig = {
     'Core200S': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]  // 4 levels including sleep mode, matching reference plugin
+        levels: [1, 2, 3, 4],  // 4 levels including sleep mode, matching reference plugin
+        modes: ['sleep', 'manual']
     },
     'Core300S': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'Core400S': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'Core600S': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     
     // LAP Series
     'LAP-C201S-AUSR': {
         module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3]
+        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'sleep_mode', 'filter_life'],
+        levels: [1, 2, 3],
+        modes: ['sleep', 'manual']
     },
     'LAP-C202S-WUSR': {
         module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3]
+        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'sleep_mode', 'filter_life'],
+        levels: [1, 2, 3],
+        modes: ['sleep', 'manual']
     },
     'LAP-C301S-WJP': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C302S-WUSB': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C301S-WAAA': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C401S-WJP': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C401S-WUSR': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C401S-WAAA': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C601S-WUS': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C601S-WUSR': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-C601S-WEU': {
         module: 'VeSyncAirBypass',
         features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V102S-AASR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V102S-WUS': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V102S-WEU': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V102S-AUSR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V102S-WJP': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201S-AASR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201S-WJP': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201S-WEU': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201S-WUS': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201-AUSR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201S-AUSR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-V201S-AEUR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3, 4]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'light_detection', 'fan_speed', 'auto_mode', 'sleep_mode', 'pet_mode', 'filter_life'],
+        levels: [1, 2, 3, 4],
+        modes: ['sleep', 'manual', 'auto', 'pet'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-EL551S-AUS': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'sleep_mode', 'turbo_mode', 'light_detection', 'filter_life'],
+        levels: [1, 2, 3],
+        modes: ['sleep', 'manual', 'auto', 'turbo'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-EL551S-AEUR': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'sleep_mode', 'turbo_mode', 'light_detection', 'filter_life'],
+        levels: [1, 2, 3],
+        modes: ['sleep', 'manual', 'auto', 'turbo'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-EL551S-WEU': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'sleep_mode', 'turbo_mode', 'light_detection', 'filter_life'],
+        levels: [1, 2, 3],
+        modes: ['sleep', 'manual', 'auto', 'turbo'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     'LAP-EL551S-WUS': {
         module: 'VeSyncAirBaseV2',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'filter_life'],
-        levels: [1, 2, 3]
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode', 'sleep_mode', 'turbo_mode', 'light_detection', 'filter_life'],
+        levels: [1, 2, 3],
+        modes: ['sleep', 'manual', 'auto', 'turbo'],
+        autoPreferences: ['default', 'efficient', 'quiet']
     },
     
     // LTF Series
@@ -342,20 +405,29 @@ export abstract class VeSyncFan extends VeSyncBaseDevice {
     protected mode_dict: Record<string, any> = {};
     protected speed_dict: Record<string, any> = {};
     protected _timer: number | { duration: number; action: string } | null = null;
-    protected config: {
-        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2' | 'VeSyncSuperior6000S' | 'VeSyncHumid1000S' | 'VeSyncHumid200S' | 'VeSyncAir131';
-        features: string[];
-        levels?: number[];
-    };
+    protected config: FanConfigEntry;
 
     constructor(details: Record<string, any>, manager: VeSync) {
         super(details, manager);
         this.details = details;
-        this.config = fanConfig[this.deviceType] || { 
-            module: 'VeSyncAirBypass', 
-            features: [],
-            levels: []
-        };
+        const entry = fanConfig[this.deviceType];
+        if (entry) {
+            this.config = {
+                ...entry,
+                features: [...entry.features],
+                levels: entry.levels ? [...entry.levels] : undefined,
+                modes: entry.modes ? [...entry.modes] : undefined,
+                autoPreferences: entry.autoPreferences ? [...entry.autoPreferences] : undefined
+            };
+        } else {
+            this.config = {
+                module: 'VeSyncAirBypass',
+                features: [],
+                levels: [],
+                modes: [],
+                autoPreferences: []
+            };
+        }
     }
 
     /**
@@ -365,6 +437,40 @@ export abstract class VeSyncFan extends VeSyncBaseDevice {
         return this.config.features.includes(feature);
     }
 
+    /**
+     * Get configured modes for the device, falling back to provided defaults.
+     */
+    protected getConfigModes(defaultModes: ReadonlyArray<string> = []): ReadonlyArray<string> {
+        if (Array.isArray(this.config.modes) && this.config.modes.length > 0) {
+            return this.config.modes;
+        }
+        return defaultModes;
+    }
+
+    /**
+     * Get configured auto preferences for the device, falling back to provided defaults.
+     */
+    protected getConfigAutoPreferences(defaultPreferences: ReadonlyArray<string> = []): ReadonlyArray<string> {
+        if (Array.isArray(this.config.autoPreferences) && this.config.autoPreferences.length > 0) {
+            return this.config.autoPreferences;
+        }
+        return defaultPreferences;
+    }
+
+    /**
+     * Public accessor for supported modes for consumers that need to inspect capability metadata.
+     */
+    public getSupportedModes(defaultModes: ReadonlyArray<string> = []): ReadonlyArray<string> {
+        return this.getConfigModes(defaultModes);
+    }
+
+    /**
+     * Public accessor for supported auto preference profiles.
+     */
+    public getSupportedAutoPreferences(defaultPreferences: ReadonlyArray<string> = []): ReadonlyArray<string> {
+        return this.getConfigAutoPreferences(defaultPreferences);
+    }
+
     /**
      * Check if feature is supported in current mode
      */
@@ -403,7 +509,10 @@ export abstract class VeSyncFan extends VeSyncBaseDevice {
      * Get maximum fan speed level
      */
     getMaxFanSpeed(): number {
-        return this.config.levels ? Math.max(...this.config.levels) : 3;
+        if (this.config.levels && this.config.levels.length > 0) {
+            return Math.max(...this.config.levels);
+        }
+        return 3;
     }
 
     /**