tsvesync 1.0.42 → 1.0.44

package/src/lib/vesyncFanImpl.ts

@@ -28,7 +28,7 @@ export class VeSyncAirBypass extends VeSyncFan {
         const head = Helpers.reqHeaderBypass();
         const body = {
             ...Helpers.reqBody(this.manager, 'bypassV2'),
-            deviceId: this.cid,
+            cid: this.cid,
             configModule: this.configModule,
             payload: {
                 method,
@@ -533,53 +533,13 @@ export class VeSyncAirBypass extends VeSyncFan {
     }
 
     /**
-     * Set mode
+     * Set auto mode
      */
-    async mode_toggle(mode: string): Promise<boolean> {
-        if (!this.modes.includes(mode.toLowerCase() as any)) {
-            logger.debug(`Invalid purifier mode used - ${mode}`);
-            return false;
-        }
-
-        const [head, body] = this.buildApiDict('setPurifierMode');
-        if (!head || !body) {
-            return false;
-        }
-
-        if (mode === 'manual') {
-            body.payload = {
-                data: {
-                    id: 0,
-                    level: 1,
-                    type: 'wind'
-                },
-                method: 'setLevel',
-                type: 'APP'
-            };
-        } else {
-            body.payload.data = {
-                mode: mode.toLowerCase()
-            };
-        }
-
-        const [response, status] = await this.callApi(
-            '/cloud/v2/deviceManaged/bypassV2',
-            'post',
-            body,
-            head
-        );
-
-        const success = this.checkResponse([response, status], 'mode_toggle');
-        if (success) {
-            if (mode === 'manual') {
-                this.details.speed = 1;
-                this.details.mode = 'manual';
-            } else {
-                this.details.mode = mode;
-                this.details.speed = 0;
-            }
-        } else {
-            logger.debug('Error setting purifier mode');
+    async autoMode(): Promise<boolean> {
+        logger.debug(`Setting auto mode for device: ${this.deviceName}`);
+        const success = await this.setMode('auto');
+        if (!success) {
+            logger.error(`Failed to set auto mode for device: ${this.deviceName}`);
         }
         return success;
     }
@@ -587,34 +547,25 @@ export class VeSyncAirBypass extends VeSyncFan {
     /**
      * Set manual mode
      */
-    async manual_mode(): Promise<boolean> {
-        if (!this.modes.includes('manual')) {
-            logger.debug(`${this.deviceName} does not have manual mode`);
-            return false;
+    async manualMode(): Promise<boolean> {
+        logger.debug(`Setting manual mode for device: ${this.deviceName}`);
+        const success = await this.setMode('manual');
+        if (!success) {
+            logger.error(`Failed to set manual mode for device: ${this.deviceName}`);
         }
-        return this.mode_toggle('manual');
+        return success;
     }
 
     /**
      * Set sleep mode
      */
-    async sleep_mode(): Promise<boolean> {
-        if (!this.modes.includes('sleep')) {
-            logger.debug(`${this.deviceName} does not have sleep mode`);
-            return false;
-        }
-        return this.mode_toggle('sleep');
-    }
-
-    /**
-     * Set auto mode
-     */
-    async auto_mode(): Promise<boolean> {
-        if (!this.modes.includes('auto')) {
-            logger.debug(`${this.deviceName} does not have auto mode`);
-            return false;
+    async sleepMode(): Promise<boolean> {
+        logger.debug(`Setting sleep mode for device: ${this.deviceName}`);
+        const success = await this.setMode('sleep');
+        if (!success) {
+            logger.error(`Failed to set sleep mode for device: ${this.deviceName}`);
         }
-        return this.mode_toggle('auto');
+        return success;
     }
 
     /**
@@ -640,26 +591,6 @@ export class VeSyncAirBypass extends VeSyncFan {
         }
         return success;
     }
-
-    /**
-     * Display device info
-     */
-    override display(): void {
-        super.display();
-        const info = [
-            ['Mode: ', this.details.mode || ''],
-            ['Speed: ', this.speed],
-            ['Filter Life: ', this.filterLife || 0, '%'],
-            ['Air Quality: ', this.details.air_quality || ''],
-            ['Display: ', this.details.display || false],
-            ['Child Lock: ', this.details.child_lock || false],
-            ['Night Light: ', this.details.night_light || 'off']
-        ];
-
-        for (const [key, value, unit = ''] of info) {
-            logger.info(`${key.toString().padEnd(30, '.')} ${value}${unit}`);
-        }
-    }
 }
 
 /**
@@ -1120,18 +1051,6 @@ export class VeSyncHumidifier extends VeSyncFan {
         return success;
     }
 
-    /**
-     * Set sleep mode
-     */
-    async sleepMode(): Promise<boolean> {
-        logger.debug(`Setting sleep mode for device: ${this.deviceName}`);
-        const success = await this.setMode('sleep');
-        if (!success) {
-            logger.error(`Failed to set sleep mode for device: ${this.deviceName}`);
-        }
-        return success;
-    }
-
     /**
      * Turn off display
      */
@@ -1359,12 +1278,48 @@ export class VeSyncWarmHumidifier extends VeSyncHumidifier {
 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 enabled: boolean = false;
+    protected _mode: string = '';
+    protected _speed: number = 0;
+    protected _timer: { duration: number; action: string } | null = null;
 
     constructor(details: Record<string, any>, manager: VeSync) {
         super(details, manager);
         logger.debug(`Initialized VeSyncAirBaseV2 device: ${this.deviceName}`);
     }
 
+    protected buildConfigDict(configDict: Record<string, any>): void {
+        if (configDict) {
+            this.config = configDict;
+        }
+    }
+
+    get mode(): string {
+        return this._mode;
+    }
+
+    set mode(value: string) {
+        this._mode = value;
+    }
+
+    get speed(): number {
+        return this._speed;
+    }
+
+    set speed(value: number) {
+        this._speed = value;
+    }
+
+    get timer(): { duration: number; action: string } | null {
+        return this._timer;
+    }
+
+    set timer(value: { duration: number; action: string } | null) {
+        this._timer = value;
+    }
+
     /**
      * Build API dictionary
      */
@@ -1372,7 +1327,7 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
         const head = Helpers.reqHeaderBypass();
         const body = {
             ...Helpers.reqBody(this.manager, 'bypassV2'),
-            deviceId: this.cid,
+            cid: this.cid,
             configModule: this.configModule,
             payload: {
                 method,
@@ -1383,25 +1338,100 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
         return [head, body];
     }
 
-    get lightDetection(): boolean {
-        return this._lightDetection;
-    }
+    /**
+     * Get device details
+     */
+    async getDetails(): Promise<Boolean> {
+        logger.debug(`Getting details for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('getPurifierStatus');
 
-    set lightDetection(toggle: boolean) {
-        this._lightDetection = toggle;
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        if (!this.checkResponse([response, status], 'getDetails') || !response?.result) {
+            logger.debug('Error getting purifier details');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+
+        const innerResponse = response.result;
+        if (innerResponse.code !== 0 || !innerResponse.result) {
+            logger.debug('Error in inner response from purifier');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+
+        const deviceData = innerResponse.result;
+        this.buildPurifierDict(deviceData);
+        if (deviceData.configuration) {
+            this.buildConfigDict(deviceData.configuration);
+        }
+        return true;
     }
 
-    get lightDetectionState(): boolean {
-        return this._lightDetectionState;
+    /**
+     * Build purifier dictionary
+     */
+    protected buildPurifierDict(devDict: Record<string, any>): void {
+        this.connectionStatus = 'online';
+        const powerSwitch = Boolean(devDict.powerSwitch ?? 0);
+        this.enabled = powerSwitch;
+        this.deviceStatus = powerSwitch ? 'on' : 'off';
+        this.mode = devDict.workMode ?? 'manual';
+        
+        this.speed = devDict.fanSpeedLevel ?? 0;
+        this.setSpeedLevel = devDict.manualSpeedLevel ?? 1;
+        
+        this.details = {
+            ...this.details,
+            filter_life: devDict.filterLifePercent ?? 0,
+            child_lock: Boolean(devDict.childLockSwitch ?? 0),
+            display: Boolean(devDict.screenState ?? 0),
+            light_detection_switch: Boolean(devDict.lightDetectionSwitch ?? 0),
+            environment_light_state: Boolean(devDict.environmentLightState ?? 0),
+            screen_switch: Boolean(devDict.screenSwitch ?? 0)
+        };
+
+        if (this.hasFeature('air_quality')) {
+            this.details.air_quality_value = devDict.PM25 ?? 0;
+            this.details.air_quality = devDict.AQLevel ?? 0;
+        }
+
+        if ('PM1' in devDict) this.details.pm1 = devDict.PM1;
+        if ('PM10' in devDict) this.details.pm10 = devDict.PM10;
+        if ('AQPercent' in devDict) this.details.aq_percent = devDict.AQPercent;
+        if ('fanRotateAngle' in devDict) this.details.fan_rotate_angle = devDict.fanRotateAngle;
+        if ('filterOpenState' in devDict) this.details.filter_open_state = Boolean(devDict.filterOpenState);
+        
+        if ((devDict.timerRemain ?? 0) > 0) {
+            this.timer = { duration: devDict.timerRemain, action: 'off' };
+        }
+
+        if (typeof devDict.autoPreference === 'object' && devDict.autoPreference) {
+            this.details.auto_preference_type = devDict.autoPreference?.autoPreferenceType ?? 'default';
+        } else {
+            this.details.auto_preference_type = null;
+        }
     }
 
-    async setLightDetection(toggle: boolean): Promise<boolean> {
-        const [head, body] = this.buildApiDict('setLightDetection');
-        if (!head || !body) {
+    /**
+     * Toggle device power
+     */
+    async toggleSwitch(toggle: boolean): Promise<boolean> {
+        if (typeof toggle !== 'boolean') {
+            logger.debug('Invalid toggle value for purifier switch');
             return false;
         }
 
-        body.payload.data = { enabled: toggle };
+        const [head, body] = this.buildApiDict('setSwitch');
+        body.payload.data = {
+            powerSwitch: toggle ? 1 : 0,
+            switchIdx: 0
+        };
 
         const [response, status] = await this.callApi(
             '/cloud/v2/deviceManaged/bypassV2',
@@ -1410,55 +1440,198 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
             head
         );
 
-        const success = this.checkResponse([response, status], 'setLightDetection');
+        const success = this.checkResponse([response, status], 'toggleSwitch');
         if (success) {
-            this._lightDetection = toggle;
+            this.deviceStatus = toggle ? 'on' : 'off';
         }
         return success;
     }
 
-    async setLightDetectionOn(): Promise<boolean> {
-        return this.setLightDetection(true);
+    /**
+     * Turn device on - compatibility method that proxies to toggleSwitch
+     */
+    async turnOn(): Promise<boolean> {
+        logger.info(`Turning on device: ${this.deviceName}`);
+        return this.toggleSwitch(true);
+    }
+
+    /**
+     * Turn device off - compatibility method that proxies to toggleSwitch
+     */
+    async turnOff(): Promise<boolean> {
+        logger.info(`Turning off device: ${this.deviceName}`);
+        return this.toggleSwitch(false);
     }
 
-    async setLightDetectionOff(): Promise<boolean> {
-        return this.setLightDetection(false);
+    /**
+     * Change fan speed
+     */
+    async changeFanSpeed(speed: number): Promise<boolean> {
+        const speeds: number[] = this.config?.levels ?? [];
+        const currentSpeed = this.setSpeedLevel ?? 0;
+
+        if (speed !== undefined) {
+            if (!speeds.includes(speed)) {
+                logger.debug(`Invalid speed: ${speed}. Must be one of: ${speeds.join(', ')}`);
+                return false;
+            }
+        } else {
+            if (currentSpeed === speeds[speeds.length - 1] || currentSpeed === 0) {
+                speed = speeds[0];
+            } else {
+                const currentIndex = speeds.indexOf(currentSpeed);
+                speed = speeds[currentIndex + 1];
+            }
+        }
+
+        const [head, body] = this.buildApiDict('setLevel');
+        body.payload.data = {
+            levelIdx: 0,
+            manualSpeedLevel: speed,
+            levelType: 'wind'
+        };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'changeFanSpeed');
+        if (success) {
+            this.setSpeedLevel = speed;
+            this.mode = 'manual';
+        }
+        return success;
     }
 
-    async turboMode(): Promise<boolean> {
-        return this.mode_toggle('turbo');
+    /**
+     * Set mode
+     */
+    async setMode(mode: string): Promise<boolean> {
+        if (!this.modes.includes(mode as any)) {
+            logger.debug(`Invalid mode: ${mode}. Must be one of: ${this.modes.join(', ')}`);
+            return false;
+        }
+
+        if (mode === 'manual') {
+            if (!this.speed || this.speed === 0) {
+                return this.changeFanSpeed(1);
+            }
+            return this.changeFanSpeed(this.speed);
+        }
+
+        if (mode === 'off') {
+            return this.turnOff();
+        }
+
+        const [head, body] = this.buildApiDict('setPurifierMode');
+        body.payload.data = {
+            workMode: mode
+        };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'setMode');
+        if (success) {
+            this.mode = mode;
+        }
+        return success;
     }
 
-    async petMode(): Promise<boolean> {
-        return this.mode_toggle('pet');
+    /**
+     * Set display status
+     */
+    async setDisplay(enabled: boolean): Promise<boolean> {
+        if (!this.hasFeature('display')) {
+            const error = 'Display control not supported';
+            logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+
+        const [head, body] = this.buildApiDict('setDisplay');
+        body.payload.data = {
+            screenSwitch: enabled ? 1 : 0
+        };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'setDisplay');
+        if (success) {
+            this.details.screen_switch = enabled;
+        }
+        return success;
     }
 
     /**
-     * Build configuration dictionary
+     * Set child lock
      */
-    protected buildConfigDict(configDict: Record<string, any>): void {
-        if (configDict) {
-            this.config = configDict;
+    async setChildLock(enabled: boolean): Promise<boolean> {
+        if (!this.hasFeature('child_lock')) {
+            const error = 'Child lock not supported';
+            logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
         }
+
+        const [head, body] = this.buildApiDict('setChildLock');
+        body.payload.data = {
+            childLockSwitch: enabled ? 1 : 0
+        };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'setChildLock');
+        if (success) {
+            this.details.child_lock = enabled;
+        }
+        return success;
     }
 
     /**
-     * Set mode
+     * Set timer
      */
-    public async mode_toggle(mode: string): Promise<boolean> {
-        const validModes = this.modes.map(m => m.toLowerCase());
-        if (!validModes.includes(mode.toLowerCase())) {
-            logger.debug(`Invalid mode used - ${mode}`);
-            return false;
+    async setTimer(timerDuration: number, action: 'on' | 'off' = 'off', method: string = 'powerSwitch'): Promise<boolean> {
+        if (!this.hasFeature('timer')) {
+            const error = 'Timer not supported';
+            logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
         }
 
-        const [head, body] = this.buildApiDict('setPurifierMode');
-        if (!head || !body) {
+        if (!['on', 'off'].includes(action)) {
+            logger.debug('Invalid action for timer');
+            return false;
+        }
+        if (method !== 'powerSwitch') {
+            logger.debug('Invalid method for timer');
             return false;
         }
 
+        const [head, body] = this.buildApiDict('addTimerV2');
+        body.payload.subDeviceNo = 0;
         body.payload.data = {
-            mode: mode
+            startAct: [{
+                type: method,
+                num: 0,
+                act: action === 'on' ? 1 : 0
+            }],
+            total: timerDuration,
+            subDeviceNo: 0
         };
 
         const [response, status] = await this.callApi(
@@ -1468,45 +1641,150 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
             head
         );
 
-        const success = this.checkResponse([response, status], 'mode_toggle');
+        const success = this.checkResponse([response, status], 'setTimer');
         if (success) {
-            this.details.mode = mode;
-        } else {
-            logger.debug('Error setting mode');
+            this.timer = { duration: timerDuration, action };
         }
         return success;
     }
 
     /**
-     * Set manual mode
+     * Clear timer
      */
-    async manual_mode(): Promise<boolean> {
-        return this.mode_toggle('manual');
+    async clearTimer(): Promise<boolean> {
+        if (!this.hasFeature('timer')) {
+            const error = 'Timer not supported';
+            logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+
+        const [head, body] = this.buildApiDict('delTimerV2');
+        body.payload.subDeviceNo = 0;
+        body.payload.data = { id: 1, subDeviceNo: 0 };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'clearTimer');
+        if (success) {
+            this.timer = null;
+        }
+        return success;
     }
 
     /**
-     * Set sleep mode
+     * Set auto preference
      */
-    async sleep_mode(): Promise<boolean> {
-        return this.mode_toggle('sleep');
+    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`);
+            return false;
+        }
+
+        const [head, body] = this.buildApiDict('setAutoPreference');
+        body.payload.data = {
+            autoPreference: preference,
+            roomSize: roomSize
+        };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'setAutoPreference');
+        if (success) {
+            this.details.auto_preference = preference;
+        }
+        return success;
     }
 
     /**
-     * Set auto mode
+     * Set light detection
      */
-    async auto_mode(): Promise<boolean> {
-        if (!this.modes.includes('auto')) {
-            logger.debug(`${this.deviceName} does not have auto mode`);
-            return false;
+    async setLightDetection(enabled: boolean): Promise<boolean> {
+        const [head, body] = this.buildApiDict('setLightDetection');
+        body.payload.data = {
+            lightDetectionSwitch: enabled ? 1 : 0
+        };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'setLightDetection');
+        if (success) {
+            this.details.light_detection_switch = enabled;
         }
-        return this.mode_toggle('auto');
+        return success;
+    }
+
+    /**
+     * Get light detection status
+     */
+    get lightDetection(): boolean {
+        return Boolean(this.details.light_detection_switch);
+    }
+
+    /**
+     * Get light detection state
+     */
+    get lightDetectionState(): boolean {
+        return Boolean(this.details.environment_light_state);
     }
 
     /**
-     * Set turbo mode
+     * Get auto preference type
      */
-    async turbo_mode(): Promise<boolean> {
-        return this.mode_toggle('turbo');
+    get autoPreferenceType(): string | null {
+        return this.details.auto_preference_type;
+    }
+
+    /**
+     * Display JSON details
+     */
+    override displayJSON(): string {
+        const baseInfo = JSON.parse(super.displayJSON());
+        const details: Record<string, string> = {
+            ...baseInfo,
+            'Mode': this.mode,
+            'Filter Life': this.details.filter_life.toString(),
+            'Fan Level': this.speed.toString(),
+            'Display On': this.details.display.toString(),
+            'Child Lock': this.details.child_lock.toString(),
+            'Display Set On': this.details.screen_switch.toString(),
+            'Light Detection Enabled': this.details.light_detection_switch.toString(),
+            'Environment Light State': this.details.environment_light_state.toString()
+        };
+
+        if (this.hasFeature('air_quality')) {
+            details['Air Quality Level'] = (this.details.air_quality ?? '').toString();
+            details['Air Quality Value'] = (this.details.air_quality_value ?? '').toString();
+        }
+
+        const everestKeys: Record<string, string> = {
+            'pm1': 'PM1',
+            'pm10': 'PM10',
+            'fan_rotate_angle': 'Fan Rotate Angle',
+            'filter_open_state': 'Filter Open State'
+        };
+
+        for (const [key, value] of Object.entries(everestKeys)) {
+            if (key in this.details) {
+                details[value] = this.details[key].toString();
+            }
+        }
+
+        return JSON.stringify(details, null, 4);
     }
 }
 
@@ -1522,20 +1800,36 @@ export class VeSyncTowerFan extends VeSyncAirBaseV2 {
         logger.debug(`Initialized VeSyncTowerFan device: ${this.deviceName}`);
     }
 
+    /**
+     * Get timer status (in seconds)
+     */
+    override get timer(): { duration: number; action: string } | null {
+        const timerRemain = this.details.timerRemain || 0;
+        return timerRemain > 0 ? { duration: timerRemain, action: 'off' } : null;
+    }
+
+    override set timer(value: { duration: number; action: string } | null) {
+        if (value) {
+            this.details.timerRemain = value.duration;
+        } else {
+            this.details.timerRemain = 0;
+        }
+    }
+
     /**
      * Build API dictionary
      */
     protected buildApiDict(method: string): [Record<string, any>, Record<string, any>] {
         const head = Helpers.reqHeaderBypass();
-        const body = Helpers.reqBody(this.manager, 'bypassV2');
-        body.cid = this.cid;
-        body.deviceId = this.cid;
-        body.configModule = this.configModule;
-        body.configModel = this.configModule;
-        body.payload = {
-            method: method,
-            source: 'APP',
-            data: {}
+        const body = {
+            ...Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                method,
+                source: 'APP',
+                data: {}
+            }
         };
         return [head, body];
     }
@@ -1776,13 +2070,6 @@ export class VeSyncTowerFan extends VeSyncAirBaseV2 {
         return Boolean(this.details.muteState);
     }
 
-    /**
-     * Get timer status (in seconds)
-     */
-    get timer(): number {
-        return this.details.timerRemain || 0;
-    }
-
     /**
      * Get temperature (in tenths of a degree)
      */
@@ -1911,22 +2198,25 @@ export const fanModules: Record<string, new (details: Record<string, any>, manag
     'LAP-C601S-WUS': VeSyncAirBypass,
     'LAP-C601S-WUSR': VeSyncAirBypass,
     'LAP-C601S-WEU': VeSyncAirBypass,
-    'LAP-V102S-AASR': VeSyncAirBypass,
-    'LAP-V102S-WUS': VeSyncAirBypass,
-    'LAP-V102S-WEU': VeSyncAirBypass,
-    'LAP-V102S-AUSR': VeSyncAirBypass,
-    'LAP-V102S-WJP': VeSyncAirBypass,
-    'LAP-V201S-AASR': VeSyncAirBypass,
-    'LAP-V201S-WJP': VeSyncAirBypass,
-    'LAP-V201S-WEU': VeSyncAirBypass,
-    'LAP-V201S-WUS': VeSyncAirBypass,
-    'LAP-V201-AUSR': VeSyncAirBypass,
-    'LAP-V201S-AUSR': VeSyncAirBypass,
-    'LAP-V201S-AEUR': VeSyncAirBypass,
-    'LAP-EL551S-AUS': VeSyncAirBypass,
-    'LAP-EL551S-AEUR': VeSyncAirBypass,
-    'LAP-EL551S-WEU': VeSyncAirBypass,
-    'LAP-EL551S-WUS': VeSyncAirBypass,
+    // Vital100S Series - Using VeSyncAirBaseV2
+    'LAP-V102S-AASR': VeSyncAirBaseV2,
+    'LAP-V102S-WUS': VeSyncAirBaseV2,
+    'LAP-V102S-WEU': VeSyncAirBaseV2,
+    'LAP-V102S-AUSR': VeSyncAirBaseV2,
+    'LAP-V102S-WJP': VeSyncAirBaseV2,
+    // Vital200S Series - Using VeSyncAirBaseV2
+    'LAP-V201S-AASR': VeSyncAirBaseV2,
+    'LAP-V201S-WJP': VeSyncAirBaseV2,
+    'LAP-V201S-WEU': VeSyncAirBaseV2,
+    'LAP-V201S-WUS': VeSyncAirBaseV2,
+    'LAP-V201-AUSR': VeSyncAirBaseV2,
+    'LAP-V201S-AUSR': VeSyncAirBaseV2,
+    'LAP-V201S-AEUR': VeSyncAirBaseV2,
+    // EverestAir Series - Using VeSyncAirBaseV2
+    'LAP-EL551S-AUS': VeSyncAirBaseV2,
+    'LAP-EL551S-AEUR': VeSyncAirBaseV2,
+    'LAP-EL551S-WEU': VeSyncAirBaseV2,
+    'LAP-EL551S-WUS': VeSyncAirBaseV2,
     
     // LTF Series
     'LTF-F422S-KEU': VeSyncTowerFan,