tsvesync 1.0.37 → 1.0.38

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,108 @@ 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);
+    /**
+     * Get device details
+     */
+    getDetails(): Promise<Boolean>;
+    /**
+     * Change fan speed
+     */
+    changeFanSpeed(speed: number): 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>;
+    /**
+     * 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 child lock status
+     */
+    get childLock(): string;
+    /**
+     * Get night light status
+     */
+    get nightLight(): string;
+    /**
+     * Get timer status
+     */
+    get timer(): 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,331 @@ 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}`);
+    }
+    /**
+     * Get device details
+     */
+    async getDetails() {
+        var _a;
+        logger_1.logger.debug(`Getting details for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('getTowerFanStatus');
+        if (!head || !body) {
+            logger_1.logger.debug('Error building API request');
+            return false;
+        }
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        if (!this.checkResponse([response, status], 'getDetails') || !response) {
+            logger_1.logger.debug('Error getting purifier details');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+        const innerResult = (_a = response.result) === null || _a === void 0 ? void 0 : _a.result;
+        if (!innerResult) {
+            this.connectionStatus = 'offline';
+            logger_1.logger.debug('Error in inner result dict from purifier');
+            return false;
+        }
+        this.deviceStatus = innerResult.enabled ? 'on' : 'off';
+        this.details = {
+            mode: innerResult.mode || '',
+            speed: innerResult.speed || 0,
+            display: innerResult.display || false,
+            child_lock: innerResult.child_lock || false,
+            night_light: innerResult.night_light || 'off',
+            timer: innerResult.timer || 0,
+            configuration: innerResult.configuration || {},
+            light_detection: innerResult.light_detection || false,
+            light_detection_state: innerResult.light_detection_state || false
+        };
+        if (innerResult.configuration) {
+            this.buildConfigDict(innerResult.configuration);
+        }
+        this._lightDetection = innerResult.light_detection || false;
+        this._lightDetectionState = innerResult.light_detection_state || false;
+        logger_1.logger.debug(`Successfully got details for device: ${this.deviceName}`);
+        return true;
+    }
+    /**
+     * 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');
+        if (!head || !body) {
+            return false;
+        }
+        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.speed = speed;
+        }
+        else {
+            logger_1.logger.debug('Error setting fan speed');
+        }
+        return success;
+    }
+    /**
+     * Toggle device power
+     */
+    async toggleSwitch(toggle) {
+        const [head, body] = this.buildApiDict('setSwitch');
+        if (!head || !body) {
+            return false;
+        }
+        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 device 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 purifier mode used - ${mode}`);
+            return false;
+        }
+        if (mode.toLowerCase() === 'off') {
+            return this.turnOff();
+        }
+        const [head, body] = this.buildApiDict('setTowerFanMode');
+        if (!head || !body) {
+            return false;
+        }
+        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.mode = mode;
+        }
+        else {
+            logger_1.logger.debug('Error setting purifier mode');
+        }
+        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.speed || 0;
+    }
+    /**
+     * Get display status
+     */
+    get displayState() {
+        return this.details.display || false;
+    }
+    /**
+     * Get child lock status
+     */
+    get childLock() {
+        return this.details.child_lock ? 'on' : 'off';
+    }
+    /**
+     * Get night light status
+     */
+    get nightLight() {
+        return this.details.night_light || 'off';
+    }
+    /**
+     * Get timer status
+     */
+    get timer() {
+        return this.details.timer || 0;
+    }
+    /**
+     * Display device info
+     */
+    display() {
+        super.display();
+        const info = [
+            ['Speed: ', this.speed],
+            ['Display: ', this.displayState],
+            ['Child Lock: ', this.childLock],
+            ['Night Light: ', this.nightLight],
+            ['Timer: ', this.timer]
+        ];
+        for (const [key, value] of info) {
+            logger_1.logger.info(`${key.toString().padEnd(30, '.')} ${value}`);
+        }
+    }
+}
+exports.VeSyncTowerFan = VeSyncTowerFan;
 // Export fan modules dictionary
 exports.fanModules = {
     // Core Series
@@ -1063,10 +1388,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.38",
   "description": "A TypeScript library for interacting with VeSync smart home devices",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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,413 @@ 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}`);
+    }
+
+    /**
+     * Get device details
+     */
+    async getDetails(): Promise<Boolean> {
+        logger.debug(`Getting details for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('getTowerFanStatus');
+        if (!head || !body) {
+            logger.debug('Error building API request');
+            return false;
+        }
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        if (!this.checkResponse([response, status], 'getDetails') || !response) {
+            logger.debug('Error getting purifier details');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+
+        const innerResult = response.result?.result;
+        if (!innerResult) {
+            this.connectionStatus = 'offline';
+            logger.debug('Error in inner result dict from purifier');
+            return false;
+        }
+
+        this.deviceStatus = innerResult.enabled ? 'on' : 'off';
+        this.details = {
+            mode: innerResult.mode || '',
+            speed: innerResult.speed || 0,
+            display: innerResult.display || false,
+            child_lock: innerResult.child_lock || false,
+            night_light: innerResult.night_light || 'off',
+            timer: innerResult.timer || 0,
+            configuration: innerResult.configuration || {},
+            light_detection: innerResult.light_detection || false,
+            light_detection_state: innerResult.light_detection_state || false
+        };
+
+        if (innerResult.configuration) {
+            this.buildConfigDict(innerResult.configuration);
+        }
+
+        this._lightDetection = innerResult.light_detection || false;
+        this._lightDetectionState = innerResult.light_detection_state || false;
+
+        logger.debug(`Successfully got details for device: ${this.deviceName}`);
+        return true;
+    }
+
+    /**
+     * 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');
+        if (!head || !body) {
+            return false;
+        }
+
+        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.speed = speed;
+        } else {
+            logger.debug('Error setting fan speed');
+        }
+        return success;
+    }
+
+    /**
+     * Toggle device power
+     */
+    async toggleSwitch(toggle: boolean): Promise<boolean> {
+        const [head, body] = this.buildApiDict('setSwitch');
+        if (!head || !body) {
+            return false;
+        }
+
+        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 device 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 purifier mode used - ${mode}`);
+            return false;
+        }
+
+        if (mode.toLowerCase() === 'off') {
+            return this.turnOff();
+        }
+
+        const [head, body] = this.buildApiDict('setTowerFanMode');
+        if (!head || !body) {
+            return false;
+        }
+
+        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.mode = mode;
+        } else {
+            logger.debug('Error setting purifier mode');
+        }
+        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.speed || 0;
+    }
+
+    /**
+     * Get display status
+     */
+    get displayState(): boolean {
+        return this.details.display || false;
+    }
+
+    /**
+     * Get child lock status
+     */
+    override get childLock(): string {
+        return this.details.child_lock ? 'on' : 'off';
+    }
+
+    /**
+     * Get night light status
+     */
+    get nightLight(): string {
+        return this.details.night_light || 'off';
+    }
+
+    /**
+     * Get timer status
+     */
+    get timer(): number {
+        return this.details.timer || 0;
+    }
+
+    /**
+     * Display device info
+     */
+    override display(): void {
+        super.display();
+        const info = [
+            ['Speed: ', this.speed],
+            ['Display: ', this.displayState],
+            ['Child Lock: ', this.childLock],
+            ['Night Light: ', this.nightLight],
+            ['Timer: ', this.timer]
+        ];
+
+        for (const [key, value] of info) {
+            logger.info(`${key.toString().padEnd(30, '.')} ${value}`);
+        }
+    }
+}
+
 // Export fan modules dictionary
 export const fanModules: Record<string, new (details: Record<string, any>, manager: VeSync) => VeSyncFan> = {
     // Core Series
@@ -1292,10 +1699,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,