tsvesync 1.0.37 → 1.0.39

package/dist/lib/helpers.d.ts

@@ -40,7 +40,7 @@ export declare class Helpers {
     /**
      * Calculate MD5 hash
      */
-    static md5(text: string): string;
+    static hashPassword(text: string): string;
     /**
      * Build header for legacy api GET requests
      */
@@ -84,5 +84,5 @@ export declare class Helpers {
     /**
      * Calculate MD5 hash
      */
-    static hashPassword(text: string): string;
+    static md5(text: string): string;
 }

package/dist/lib/helpers.js

@@ -34,7 +34,7 @@ class Helpers {
     /**
      * Calculate MD5 hash
      */
-    static md5(text) {
+    static hashPassword(text) {
         return crypto_1.default.createHash('md5').update(text).digest('hex');
     }
     /**
@@ -250,7 +250,7 @@ class Helpers {
     /**
      * Calculate MD5 hash
      */
-    static hashPassword(text) {
+    static md5(text) {
         return crypto_1.default.createHash('md5').update(text).digest('hex');
     }
 }

package/dist/lib/vesyncFan.d.ts

@@ -5,7 +5,7 @@ import { VeSyncBaseDevice } from './vesyncBaseDevice';
 import { VeSync } from './vesync';
 interface FanConfig {
     [key: string]: {
-        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier';
+        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan';
         features: string[];
     };
 }

package/dist/lib/vesyncFan.js

@@ -136,20 +136,20 @@ exports.fanConfig = {
     },
     // LTF Series
     'LTF-F422S-KEU': {
-        module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'timer']
+        module: 'VeSyncTowerFan',
+        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes']
     },
     'LTF-F422S-WUSR': {
-        module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'timer']
+        module: 'VeSyncTowerFan',
+        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes']
     },
     'LTF-F422_WJP': {
-        module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'timer']
+        module: 'VeSyncTowerFan',
+        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes']
     },
     'LTF-F422S-WUS': {
-        module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'timer']
+        module: 'VeSyncTowerFan',
+        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes']
     },
     // Classic Series
     'Classic300S': {

package/dist/lib/vesyncFanImpl.d.ts

@@ -209,4 +209,136 @@ export declare class VeSyncWarmHumidifier extends VeSyncHumidifier {
      */
     get dryingModeSecondsRemaining(): number;
 }
+/**
+ * VeSync Air Purifier with Bypass V2
+ */
+export declare class VeSyncAirBaseV2 extends VeSyncAirBypass {
+    protected _lightDetection: boolean;
+    protected _lightDetectionState: boolean;
+    constructor(details: Record<string, any>, manager: VeSync);
+    /**
+     * Build API dictionary
+     */
+    protected buildApiDict(method: string): [Record<string, any>, Record<string, any>];
+    get lightDetection(): boolean;
+    set lightDetection(toggle: boolean);
+    get lightDetectionState(): boolean;
+    setLightDetection(toggle: boolean): Promise<boolean>;
+    setLightDetectionOn(): Promise<boolean>;
+    setLightDetectionOff(): Promise<boolean>;
+    turboMode(): Promise<boolean>;
+    petMode(): Promise<boolean>;
+    /**
+     * Build configuration dictionary
+     */
+    protected buildConfigDict(configDict: Record<string, any>): void;
+    /**
+     * Set mode
+     */
+    protected mode_toggle(mode: string): Promise<boolean>;
+}
+/**
+ * VeSync Tower Fan Implementation
+ */
+export declare class VeSyncTowerFan extends VeSyncAirBaseV2 {
+    protected readonly towerModes: readonly ["normal", "advancedSleep", "off"];
+    protected readonly speeds: number[];
+    constructor(details: Record<string, any>, manager: VeSync);
+    /**
+     * Build API dictionary
+     */
+    protected buildApiDict(method: string): [Record<string, any>, Record<string, any>];
+    /**
+     * Get device details
+     */
+    getDetails(): Promise<Boolean>;
+    /**
+     * Toggle device power
+     */
+    toggleSwitch(toggle: boolean): Promise<boolean>;
+    /**
+     * Turn device on
+     */
+    turnOn(): Promise<boolean>;
+    /**
+     * Turn device off
+     */
+    turnOff(): Promise<boolean>;
+    /**
+     * Set tower fan mode
+     */
+    mode_toggle(mode: string): Promise<boolean>;
+    /**
+     * Change fan speed
+     */
+    changeFanSpeed(speed: number): Promise<boolean>;
+    /**
+     * Set normal mode
+     */
+    normal_mode(): Promise<boolean>;
+    /**
+     * Set manual mode - adapter to set mode to normal
+     */
+    manual_mode(): Promise<boolean>;
+    /**
+     * Set advanced sleep mode
+     */
+    advanced_sleep_mode(): Promise<boolean>;
+    /**
+     * Set sleep mode - adapter for advanced sleep mode
+     */
+    sleep_mode(): Promise<boolean>;
+    /**
+     * Override setMode to handle tower fan specific modes
+     */
+    setMode(mode: string): Promise<boolean>;
+    /**
+     * Get current speed
+     */
+    get speed(): number;
+    /**
+     * Get display status
+     */
+    get displayState(): boolean;
+    /**
+     * Get oscillation status
+     */
+    get oscillationState(): boolean;
+    /**
+     * Get mute status
+     */
+    get muteState(): boolean;
+    /**
+     * Get timer status (in seconds)
+     */
+    get timer(): number;
+    /**
+     * Get temperature (in tenths of a degree)
+     */
+    get temperature(): number;
+    /**
+     * Get humidity percentage
+     */
+    get humidity(): number;
+    /**
+     * Get thermal comfort level
+     */
+    get thermalComfort(): number;
+    /**
+     * Get sleep preferences
+     */
+    get sleepPreference(): Record<string, any>;
+    /**
+     * Get schedule count
+     */
+    get scheduleCount(): number;
+    /**
+     * Get error code
+     */
+    get errorCode(): number;
+    /**
+     * Display device info
+     */
+    display(): void;
+}
 export declare const fanModules: Record<string, new (details: Record<string, any>, manager: VeSync) => VeSyncFan>;

package/dist/lib/vesyncFanImpl.js

@@ -3,7 +3,7 @@
  * VeSync Fan Implementations
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fanModules = exports.VeSyncWarmHumidifier = exports.VeSyncHumidifier = exports.VeSyncAirBypass = void 0;
+exports.fanModules = exports.VeSyncTowerFan = exports.VeSyncAirBaseV2 = exports.VeSyncWarmHumidifier = exports.VeSyncHumidifier = exports.VeSyncAirBypass = void 0;
 const vesyncFan_1 = require("./vesyncFan");
 const helpers_1 = require("./helpers");
 const logger_1 = require("./logger");
@@ -1027,6 +1027,391 @@ class VeSyncWarmHumidifier extends VeSyncHumidifier {
     }
 }
 exports.VeSyncWarmHumidifier = VeSyncWarmHumidifier;
+/**
+ * VeSync Air Purifier with Bypass V2
+ */
+class VeSyncAirBaseV2 extends VeSyncAirBypass {
+    constructor(details, manager) {
+        super(details, manager);
+        this._lightDetection = false;
+        this._lightDetectionState = false;
+        logger_1.logger.debug(`Initialized VeSyncAirBaseV2 device: ${this.deviceName}`);
+    }
+    /**
+     * Build API dictionary
+     */
+    buildApiDict(method) {
+        const head = helpers_1.Helpers.reqHeaderBypass();
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            deviceId: this.cid,
+            configModule: this.configModule,
+            payload: {
+                method,
+                source: 'APP',
+                data: {}
+            }
+        };
+        return [head, body];
+    }
+    get lightDetection() {
+        return this._lightDetection;
+    }
+    set lightDetection(toggle) {
+        this._lightDetection = toggle;
+    }
+    get lightDetectionState() {
+        return this._lightDetectionState;
+    }
+    async setLightDetection(toggle) {
+        const [head, body] = this.buildApiDict('setLightDetection');
+        if (!head || !body) {
+            return false;
+        }
+        body.payload.data = { enabled: toggle };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setLightDetection');
+        if (success) {
+            this._lightDetection = toggle;
+        }
+        return success;
+    }
+    async setLightDetectionOn() {
+        return this.setLightDetection(true);
+    }
+    async setLightDetectionOff() {
+        return this.setLightDetection(false);
+    }
+    async turboMode() {
+        return this.mode_toggle('turbo');
+    }
+    async petMode() {
+        return this.mode_toggle('pet');
+    }
+    /**
+     * Build configuration dictionary
+     */
+    buildConfigDict(configDict) {
+        if (configDict) {
+            this.config = configDict;
+        }
+    }
+    /**
+     * Set mode
+     */
+    async mode_toggle(mode) {
+        const validModes = this.modes.map(m => m.toLowerCase());
+        if (!validModes.includes(mode.toLowerCase())) {
+            logger_1.logger.debug(`Invalid mode used - ${mode}`);
+            return false;
+        }
+        const [head, body] = this.buildApiDict('setPurifierMode');
+        if (!head || !body) {
+            return false;
+        }
+        body.payload.data = {
+            mode: mode
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'mode_toggle');
+        if (success) {
+            this.details.mode = mode;
+        }
+        else {
+            logger_1.logger.debug('Error setting mode');
+        }
+        return success;
+    }
+}
+exports.VeSyncAirBaseV2 = VeSyncAirBaseV2;
+/**
+ * VeSync Tower Fan Implementation
+ */
+class VeSyncTowerFan extends VeSyncAirBaseV2 {
+    constructor(details, manager) {
+        super(details, manager);
+        this.towerModes = ['normal', 'advancedSleep', 'off'];
+        this.speeds = Array.from({ length: 12 }, (_, i) => i + 1);
+        logger_1.logger.debug(`Initialized VeSyncTowerFan device: ${this.deviceName}`);
+    }
+    /**
+     * Build API dictionary
+     */
+    buildApiDict(method) {
+        const head = helpers_1.Helpers.reqHeaderBypass();
+        const body = helpers_1.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: {}
+        };
+        return [head, body];
+    }
+    /**
+     * Get device details
+     */
+    async getDetails() {
+        logger_1.logger.debug(`Getting details for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('getTowerFanStatus');
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        if (!this.checkResponse([response, status], 'getDetails') || !(response === null || response === void 0 ? void 0 : response.result)) {
+            logger_1.logger.debug('Error getting tower fan details');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+        const innerResponse = response.result;
+        if (innerResponse.code !== 0 || !innerResponse.result) {
+            logger_1.logger.debug('Error in inner response from tower fan');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+        const deviceData = innerResponse.result;
+        this.deviceStatus = deviceData.powerSwitch === 1 ? 'on' : 'off';
+        this.details = {
+            powerSwitch: deviceData.powerSwitch,
+            workMode: deviceData.workMode,
+            manualSpeedLevel: deviceData.manualSpeedLevel,
+            fanSpeedLevel: deviceData.fanSpeedLevel,
+            screenState: deviceData.screenState,
+            screenSwitch: deviceData.screenSwitch,
+            oscillationState: deviceData.oscillationState,
+            oscillationSwitch: deviceData.oscillationSwitch,
+            muteState: deviceData.muteState,
+            muteSwitch: deviceData.muteSwitch,
+            timerRemain: deviceData.timerRemain,
+            temperature: deviceData.temperature || 0,
+            humidity: deviceData.humidity || 0,
+            thermalComfort: deviceData.thermalComfort,
+            sleepPreference: deviceData.sleepPreference || {},
+            scheduleCount: deviceData.scheduleCount,
+            displayingType: deviceData.displayingType,
+            errorCode: deviceData.errorCode
+        };
+        logger_1.logger.debug(`Successfully got details for device: ${this.deviceName}`);
+        return true;
+    }
+    /**
+     * Toggle device power
+     */
+    async toggleSwitch(toggle) {
+        if (typeof toggle !== 'boolean') {
+            logger_1.logger.debug('Invalid toggle value for tower fan switch');
+            return false;
+        }
+        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', 'post', body, head);
+        const success = this.checkResponse([response, status], 'toggleSwitch');
+        if (success) {
+            this.deviceStatus = toggle ? 'on' : 'off';
+        }
+        else {
+            logger_1.logger.debug('Error toggling tower fan power');
+        }
+        return success;
+    }
+    /**
+     * Turn device on
+     */
+    async turnOn() {
+        logger_1.logger.debug(`Turning on device: ${this.deviceName}`);
+        return this.toggleSwitch(true);
+    }
+    /**
+     * Turn device off
+     */
+    async turnOff() {
+        logger_1.logger.debug(`Turning off device: ${this.deviceName}`);
+        return this.toggleSwitch(false);
+    }
+    /**
+     * Set tower fan mode
+     */
+    async mode_toggle(mode) {
+        const validModes = this.towerModes.map(m => m.toLowerCase());
+        if (!validModes.includes(mode.toLowerCase())) {
+            logger_1.logger.debug(`Invalid tower fan mode used - ${mode}`);
+            return false;
+        }
+        if (mode.toLowerCase() === 'off') {
+            return this.turnOff();
+        }
+        const [head, body] = this.buildApiDict('setTowerFanMode');
+        body.deviceId = this.cid;
+        body.payload.data = {
+            workMode: mode
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'mode_toggle');
+        if (success) {
+            this.details.workMode = mode;
+        }
+        else {
+            logger_1.logger.debug('Error setting tower fan mode');
+        }
+        return success;
+    }
+    /**
+     * Change fan speed
+     */
+    async changeFanSpeed(speed) {
+        if (!this.speeds.includes(speed)) {
+            logger_1.logger.debug(`Invalid speed: ${speed}. Must be one of: ${this.speeds.join(', ')}`);
+            return false;
+        }
+        const [head, body] = this.buildApiDict('setLevel');
+        body.payload.data = {
+            levelIdx: 0,
+            levelType: 'wind',
+            manualSpeedLevel: speed
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'changeFanSpeed');
+        if (success) {
+            this.details.manualSpeedLevel = speed;
+        }
+        else {
+            logger_1.logger.debug('Error setting fan speed');
+        }
+        return success;
+    }
+    /**
+     * Set normal mode
+     */
+    async normal_mode() {
+        logger_1.logger.debug(`Setting normal mode for device: ${this.deviceName}`);
+        return this.mode_toggle('normal');
+    }
+    /**
+     * Set manual mode - adapter to set mode to normal
+     */
+    async manual_mode() {
+        logger_1.logger.debug(`Setting manual mode for device: ${this.deviceName}`);
+        return this.normal_mode();
+    }
+    /**
+     * Set advanced sleep mode
+     */
+    async advanced_sleep_mode() {
+        logger_1.logger.debug(`Setting advanced sleep mode for device: ${this.deviceName}`);
+        return this.mode_toggle('advancedSleep');
+    }
+    /**
+     * Set sleep mode - adapter for advanced sleep mode
+     */
+    async sleep_mode() {
+        logger_1.logger.debug(`Setting sleep mode for device: ${this.deviceName}`);
+        return this.advanced_sleep_mode();
+    }
+    /**
+     * Override setMode to handle tower fan specific modes
+     */
+    async setMode(mode) {
+        return this.mode_toggle(mode);
+    }
+    /**
+     * Get current speed
+     */
+    get speed() {
+        return this.details.manualSpeedLevel || 0;
+    }
+    /**
+     * Get display status
+     */
+    get displayState() {
+        return Boolean(this.details.screenState);
+    }
+    /**
+     * Get oscillation status
+     */
+    get oscillationState() {
+        return Boolean(this.details.oscillationState);
+    }
+    /**
+     * Get mute status
+     */
+    get muteState() {
+        return Boolean(this.details.muteState);
+    }
+    /**
+     * Get timer status (in seconds)
+     */
+    get timer() {
+        return this.details.timerRemain || 0;
+    }
+    /**
+     * Get temperature (in tenths of a degree)
+     */
+    get temperature() {
+        return this.details.temperature || 0;
+    }
+    /**
+     * Get humidity percentage
+     */
+    get humidity() {
+        return this.details.humidity || 0;
+    }
+    /**
+     * Get thermal comfort level
+     */
+    get thermalComfort() {
+        return this.details.thermalComfort || 0;
+    }
+    /**
+     * Get sleep preferences
+     */
+    get sleepPreference() {
+        return this.details.sleepPreference || {};
+    }
+    /**
+     * Get schedule count
+     */
+    get scheduleCount() {
+        return this.details.scheduleCount || 0;
+    }
+    /**
+     * Get error code
+     */
+    get errorCode() {
+        return this.details.errorCode || 0;
+    }
+    /**
+     * Display device info
+     */
+    display() {
+        super.display();
+        const info = [
+            ['Mode: ', this.details.workMode || ''],
+            ['Speed: ', this.speed],
+            ['Fan Speed Level: ', this.details.fanSpeedLevel || 0],
+            ['Display: ', this.displayState],
+            ['Display Switch: ', this.details.screenSwitch],
+            ['Oscillation: ', this.oscillationState],
+            ['Oscillation Switch: ', this.details.oscillationSwitch],
+            ['Mute: ', this.muteState],
+            ['Mute Switch: ', this.details.muteSwitch],
+            ['Timer: ', this.timer],
+            ['Temperature: ', this.temperature / 10, '°C'],
+            ['Humidity: ', this.humidity, '%'],
+            ['Thermal Comfort: ', this.thermalComfort],
+            ['Sleep Preference: ', JSON.stringify(this.sleepPreference)],
+            ['Schedule Count: ', this.scheduleCount],
+            ['Displaying Type: ', this.details.displayingType],
+            ['Error Code: ', this.errorCode]
+        ];
+        for (const [key, value, unit = ''] of info) {
+            logger_1.logger.info(`${key.toString().padEnd(30, '.')} ${value}${unit}`);
+        }
+    }
+}
+exports.VeSyncTowerFan = VeSyncTowerFan;
 // Export fan modules dictionary
 exports.fanModules = {
     // Core Series
@@ -1063,10 +1448,10 @@ exports.fanModules = {
     'LAP-EL551S-WEU': VeSyncAirBypass,
     'LAP-EL551S-WUS': VeSyncAirBypass,
     // LTF Series
-    'LTF-F422S-KEU': VeSyncAirBypass,
-    'LTF-F422S-WUSR': VeSyncAirBypass,
-    'LTF-F422_WJP': VeSyncAirBypass,
-    'LTF-F422S-WUS': VeSyncAirBypass,
+    'LTF-F422S-KEU': VeSyncTowerFan,
+    'LTF-F422S-WUSR': VeSyncTowerFan,
+    'LTF-F422_WJP': VeSyncTowerFan,
+    'LTF-F422S-WUS': VeSyncTowerFan,
     // Classic Series
     'Classic300S': VeSyncHumidifier,
     'Classic200S': VeSyncHumidifier,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsvesync",
-  "version": "1.0.37",
+  "version": "1.0.39",
   "description": "A TypeScript library for interacting with VeSync smart home devices",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/lib/helpers.ts

@@ -58,7 +58,7 @@ export class Helpers {
     /**
      * Calculate MD5 hash
      */
-    static md5(text: string): string {
+    static hashPassword(text: string): string {
         return crypto.createHash('md5').update(text).digest('hex');
     }
 
@@ -302,7 +302,7 @@ export class Helpers {
     /**
      * Calculate MD5 hash
      */
-    static hashPassword(text: string): string {
+    static md5(text: string): string {
         return crypto.createHash('md5').update(text).digest('hex');
     }
 } 

package/src/lib/vesyncFan.ts

@@ -8,7 +8,7 @@ import { logger } from './logger';
 
 interface FanConfig {
     [key: string]: {
-        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier';
+        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan';
         features: string[];
     };
 }
@@ -145,20 +145,20 @@ export const fanConfig: FanConfig = {
     
     // LTF Series
     'LTF-F422S-KEU': {
-        module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'timer']
+        module: 'VeSyncTowerFan',
+        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes']
     },
     'LTF-F422S-WUSR': {
-        module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'timer']
+        module: 'VeSyncTowerFan',
+        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes']
     },
     'LTF-F422_WJP': {
-        module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'timer']
+        module: 'VeSyncTowerFan',
+        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes']
     },
     'LTF-F422S-WUS': {
-        module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'timer']
+        module: 'VeSyncTowerFan',
+        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes']
     },
     
     // Classic Series

package/src/lib/vesyncFanImpl.ts

@@ -1254,6 +1254,477 @@ export class VeSyncWarmHumidifier extends VeSyncHumidifier {
     }
 }
 
+/**
+ * VeSync Air Purifier with Bypass V2
+ */
+export class VeSyncAirBaseV2 extends VeSyncAirBypass {
+    protected _lightDetection: boolean = false;
+    protected _lightDetectionState: boolean = false;
+
+    constructor(details: Record<string, any>, manager: VeSync) {
+        super(details, manager);
+        logger.debug(`Initialized VeSyncAirBaseV2 device: ${this.deviceName}`);
+    }
+
+    /**
+     * Build API dictionary
+     */
+    protected buildApiDict(method: string): [Record<string, any>, Record<string, any>] {
+        const head = Helpers.reqHeaderBypass();
+        const body = {
+            ...Helpers.reqBody(this.manager, 'bypassV2'),
+            deviceId: this.cid,
+            configModule: this.configModule,
+            payload: {
+                method,
+                source: 'APP',
+                data: {}
+            }
+        };
+        return [head, body];
+    }
+
+    get lightDetection(): boolean {
+        return this._lightDetection;
+    }
+
+    set lightDetection(toggle: boolean) {
+        this._lightDetection = toggle;
+    }
+
+    get lightDetectionState(): boolean {
+        return this._lightDetectionState;
+    }
+
+    async setLightDetection(toggle: boolean): Promise<boolean> {
+        const [head, body] = this.buildApiDict('setLightDetection');
+        if (!head || !body) {
+            return false;
+        }
+
+        body.payload.data = { enabled: toggle };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'setLightDetection');
+        if (success) {
+            this._lightDetection = toggle;
+        }
+        return success;
+    }
+
+    async setLightDetectionOn(): Promise<boolean> {
+        return this.setLightDetection(true);
+    }
+
+    async setLightDetectionOff(): Promise<boolean> {
+        return this.setLightDetection(false);
+    }
+
+    async turboMode(): Promise<boolean> {
+        return this.mode_toggle('turbo');
+    }
+
+    async petMode(): Promise<boolean> {
+        return this.mode_toggle('pet');
+    }
+
+    /**
+     * Build configuration dictionary
+     */
+    protected buildConfigDict(configDict: Record<string, any>): void {
+        if (configDict) {
+            this.config = configDict;
+        }
+    }
+
+    /**
+     * Set mode
+     */
+    protected 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;
+        }
+
+        const [head, body] = this.buildApiDict('setPurifierMode');
+        if (!head || !body) {
+            return false;
+        }
+
+        body.payload.data = {
+            mode: mode
+        };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'mode_toggle');
+        if (success) {
+            this.details.mode = mode;
+        } else {
+            logger.debug('Error setting mode');
+        }
+        return success;
+    }
+}
+
+/**
+ * VeSync Tower Fan Implementation
+ */
+export class VeSyncTowerFan extends VeSyncAirBaseV2 {
+    protected readonly towerModes = ['normal', 'advancedSleep', 'off'] as const;
+    protected readonly speeds = Array.from({length: 12}, (_, i) => i + 1);
+
+    constructor(details: Record<string, any>, manager: VeSync) {
+        super(details, manager);
+        logger.debug(`Initialized VeSyncTowerFan device: ${this.deviceName}`);
+    }
+
+    /**
+     * 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: {}
+        };
+        return [head, body];
+    }
+
+    /**
+     * Get device details
+     */
+    async getDetails(): Promise<Boolean> {
+        logger.debug(`Getting details for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('getTowerFanStatus');
+
+        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 tower fan details');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+
+        const innerResponse = response.result;
+        if (innerResponse.code !== 0 || !innerResponse.result) {
+            logger.debug('Error in inner response from tower fan');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+
+        const deviceData = innerResponse.result;
+        this.deviceStatus = deviceData.powerSwitch === 1 ? 'on' : 'off';
+        this.details = {
+            powerSwitch: deviceData.powerSwitch,
+            workMode: deviceData.workMode,
+            manualSpeedLevel: deviceData.manualSpeedLevel,
+            fanSpeedLevel: deviceData.fanSpeedLevel,
+            screenState: deviceData.screenState,
+            screenSwitch: deviceData.screenSwitch,
+            oscillationState: deviceData.oscillationState,
+            oscillationSwitch: deviceData.oscillationSwitch,
+            muteState: deviceData.muteState,
+            muteSwitch: deviceData.muteSwitch,
+            timerRemain: deviceData.timerRemain,
+            temperature: deviceData.temperature || 0,
+            humidity: deviceData.humidity || 0,
+            thermalComfort: deviceData.thermalComfort,
+            sleepPreference: deviceData.sleepPreference || {},
+            scheduleCount: deviceData.scheduleCount,
+            displayingType: deviceData.displayingType,
+            errorCode: deviceData.errorCode
+        };
+
+        logger.debug(`Successfully got details for device: ${this.deviceName}`);
+        return true;
+    }
+
+    /**
+     * Toggle device power
+     */
+    async toggleSwitch(toggle: boolean): Promise<boolean> {
+        if (typeof toggle !== 'boolean') {
+            logger.debug('Invalid toggle value for tower fan switch');
+            return false;
+        }
+
+        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',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'toggleSwitch');
+        if (success) {
+            this.deviceStatus = toggle ? 'on' : 'off';
+        } else {
+            logger.debug('Error toggling tower fan power');
+        }
+        return success;
+    }
+
+    /**
+     * Turn device on
+     */
+    async turnOn(): Promise<boolean> {
+        logger.debug(`Turning on device: ${this.deviceName}`);
+        return this.toggleSwitch(true);
+    }
+
+    /**
+     * Turn device off
+     */
+    async turnOff(): Promise<boolean> {
+        logger.debug(`Turning off device: ${this.deviceName}`);
+        return this.toggleSwitch(false);
+    }
+
+    /**
+     * Set tower fan mode
+     */
+    async mode_toggle(mode: string): Promise<boolean> {
+        const validModes = this.towerModes.map(m => m.toLowerCase());
+        if (!validModes.includes(mode.toLowerCase())) {
+            logger.debug(`Invalid tower fan mode used - ${mode}`);
+            return false;
+        }
+
+        if (mode.toLowerCase() === 'off') {
+            return this.turnOff();
+        }
+
+        const [head, body] = this.buildApiDict('setTowerFanMode');
+        body.deviceId = this.cid;
+        body.payload.data = {
+            workMode: mode
+        };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'mode_toggle');
+        if (success) {
+            this.details.workMode = mode;
+        } else {
+            logger.debug('Error setting tower fan mode');
+        }
+        return success;
+    }
+
+    /**
+     * Change fan speed
+     */
+    async changeFanSpeed(speed: number): Promise<boolean> {
+        if (!this.speeds.includes(speed)) {
+            logger.debug(`Invalid speed: ${speed}. Must be one of: ${this.speeds.join(', ')}`);
+            return false;
+        }
+
+        const [head, body] = this.buildApiDict('setLevel');
+        body.payload.data = {
+            levelIdx: 0,
+            levelType: 'wind',
+            manualSpeedLevel: speed
+        };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'changeFanSpeed');
+        if (success) {
+            this.details.manualSpeedLevel = speed;
+        } else {
+            logger.debug('Error setting fan speed');
+        }
+        return success;
+    }
+
+    /**
+     * Set normal mode
+     */
+    async normal_mode(): Promise<boolean> {
+        logger.debug(`Setting normal mode for device: ${this.deviceName}`);
+        return this.mode_toggle('normal');
+    }
+
+    /**
+     * Set manual mode - adapter to set mode to normal
+     */
+    async manual_mode(): Promise<boolean> {
+        logger.debug(`Setting manual mode for device: ${this.deviceName}`);
+        return this.normal_mode();
+    }
+
+    /**
+     * Set advanced sleep mode
+     */
+    async advanced_sleep_mode(): Promise<boolean> {
+        logger.debug(`Setting advanced sleep mode for device: ${this.deviceName}`);
+        return this.mode_toggle('advancedSleep');
+    }
+
+    /**
+     * Set sleep mode - adapter for advanced sleep mode
+     */
+    async sleep_mode(): Promise<boolean> {
+        logger.debug(`Setting sleep mode for device: ${this.deviceName}`);
+        return this.advanced_sleep_mode();
+    }
+
+    /**
+     * Override setMode to handle tower fan specific modes
+     */
+    async setMode(mode: string): Promise<boolean> {
+        return this.mode_toggle(mode);
+    }
+
+    /**
+     * Get current speed
+     */
+    get speed(): number {
+        return this.details.manualSpeedLevel || 0;
+    }
+
+    /**
+     * Get display status
+     */
+    get displayState(): boolean {
+        return Boolean(this.details.screenState);
+    }
+
+    /**
+     * Get oscillation status
+     */
+    get oscillationState(): boolean {
+        return Boolean(this.details.oscillationState);
+    }
+
+    /**
+     * Get mute status
+     */
+    get muteState(): boolean {
+        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)
+     */
+    get temperature(): number {
+        return this.details.temperature || 0;
+    }
+
+    /**
+     * Get humidity percentage
+     */
+    get humidity(): number {
+        return this.details.humidity || 0;
+    }
+
+    /**
+     * Get thermal comfort level
+     */
+    get thermalComfort(): number {
+        return this.details.thermalComfort || 0;
+    }
+
+    /**
+     * Get sleep preferences
+     */
+    get sleepPreference(): Record<string, any> {
+        return this.details.sleepPreference || {};
+    }
+
+    /**
+     * Get schedule count
+     */
+    get scheduleCount(): number {
+        return this.details.scheduleCount || 0;
+    }
+
+    /**
+     * Get error code
+     */
+    get errorCode(): number {
+        return this.details.errorCode || 0;
+    }
+
+    /**
+     * Display device info
+     */
+    override display(): void {
+        super.display();
+        const info = [
+            ['Mode: ', this.details.workMode || ''],
+            ['Speed: ', this.speed],
+            ['Fan Speed Level: ', this.details.fanSpeedLevel || 0],
+            ['Display: ', this.displayState],
+            ['Display Switch: ', this.details.screenSwitch],
+            ['Oscillation: ', this.oscillationState],
+            ['Oscillation Switch: ', this.details.oscillationSwitch],
+            ['Mute: ', this.muteState],
+            ['Mute Switch: ', this.details.muteSwitch],
+            ['Timer: ', this.timer],
+            ['Temperature: ', this.temperature / 10, '°C'],
+            ['Humidity: ', this.humidity, '%'],
+            ['Thermal Comfort: ', this.thermalComfort],
+            ['Sleep Preference: ', JSON.stringify(this.sleepPreference)],
+            ['Schedule Count: ', this.scheduleCount],
+            ['Displaying Type: ', this.details.displayingType],
+            ['Error Code: ', this.errorCode]
+        ];
+
+        for (const [key, value, unit = ''] of info) {
+            logger.info(`${key.toString().padEnd(30, '.')} ${value}${unit}`);
+        }
+    }
+}
+
 // Export fan modules dictionary
 export const fanModules: Record<string, new (details: Record<string, any>, manager: VeSync) => VeSyncFan> = {
     // Core Series
@@ -1292,10 +1763,10 @@ export const fanModules: Record<string, new (details: Record<string, any>, manag
     'LAP-EL551S-WUS': VeSyncAirBypass,
     
     // LTF Series
-    'LTF-F422S-KEU': VeSyncAirBypass,
-    'LTF-F422S-WUSR': VeSyncAirBypass,
-    'LTF-F422_WJP': VeSyncAirBypass,
-    'LTF-F422S-WUS': VeSyncAirBypass,
+    'LTF-F422S-KEU': VeSyncTowerFan,
+    'LTF-F422S-WUSR': VeSyncTowerFan,
+    'LTF-F422_WJP': VeSyncTowerFan,
+    'LTF-F422S-WUS': VeSyncTowerFan,
     
     // Classic Series
     'Classic300S': VeSyncHumidifier,