tsvesync 1.0.71 → 1.0.73

package/dist/lib/fans/superior6000S.js

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeSyncSuperior6000S = void 0;
+const vesyncFan_1 = require("../vesyncFan");
+const helpers_1 = require("../helpers");
+const logger_1 = require("../logger");
+/**
+ * VeSync Superior 6000S Humidifier Class
+ * Implementation based on PyVeSync's VeSyncSuperior6000S class
+ */
+class VeSyncSuperior6000S extends vesyncFan_1.VeSyncFan {
+    constructor(details, manager) {
+        super(details, manager);
+        this.modes = ['auto', 'manual', 'sleep', 'humidity'];
+        this.mistLevels = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        this.humidityRange = { min: 30, max: 80 };
+        this._apiModes = [
+            'getHumidifierStatus',
+            'setSwitch',
+            'setVirtualLevel',
+            'setTargetHumidity',
+            'setHumidityMode',
+            'setDisplay',
+            'setDryingMode',
+        ];
+        // Initialize details object
+        this.details = {
+            mode: '',
+            speed: 0,
+            filter_life: 0,
+            screen_status: 'off',
+            child_lock: false,
+            humidity: 0,
+            target_humidity: 0,
+            mist_level: 0,
+            mist_virtual_level: 0,
+            water_lacks: false,
+            water_tank_lifted: false,
+            display: false,
+            filter_life_percentage: 0,
+            temperature: 0,
+            drying_mode: {},
+            configuration: {},
+            connection_status: null
+        };
+        // Update config for Superior 6000S
+        this.config = {
+            module: 'VeSyncAirBypass', // This doesn't matter as we're implementing directly
+            features: ['display', 'humidity', 'mist', 'timer', 'auto_mode', 'drying'],
+            levels: this.mistLevels
+        };
+        logger_1.logger.debug(`Initialized VeSyncSuperior6000S device: ${this.deviceName}`);
+    }
+    /**
+     * Build API dictionary for humidifier
+     */
+    buildApiDict(method) {
+        if (!this._apiModes.includes(method)) {
+            logger_1.logger.debug(`Invalid mode - ${method}`);
+            throw new Error(`Invalid mode - ${method}`);
+        }
+        const head = helpers_1.Helpers.reqHeaderBypass();
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                method: method,
+                source: 'APP',
+                data: {}
+            }
+        };
+        return [head, body];
+    }
+    /**
+     * Get device details
+     */
+    async getDetails() {
+        var _a;
+        logger_1.logger.debug(`Getting details for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('getHumidifierStatus');
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'getDetails');
+        if (success && ((_a = response === null || response === void 0 ? void 0 : response.result) === null || _a === void 0 ? void 0 : _a.result)) {
+            const result = response.result.result;
+            // Update device status based on powerSwitch field
+            this.deviceStatus = result.powerSwitch === 1 ? 'on' : 'off';
+            // Build details object with Superior 6000S specific fields
+            this.details = {
+                mode: result.workMode === 'autoPro' ? 'auto' : result.workMode || '',
+                humidity: result.humidity || 0,
+                target_humidity: result.targetHumidity || 0,
+                mist_level: result.mistLevel || 0,
+                mist_virtual_level: result.virtualLevel || 0,
+                water_lacks: result.waterLacksState || false,
+                water_tank_lifted: result.waterTankLifted || false,
+                display: result.screenSwitch === 1,
+                filter_life_percentage: result.filterLifePercent || 0,
+                temperature: result.temperature || 0,
+                drying_mode: result.dryingMode || {},
+                configuration: result.configuration || {},
+                connection_status: result.connectionStatus || null
+            };
+            logger_1.logger.debug(`Successfully got details for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Turn device on
+     */
+    async turnOn() {
+        return this.toggleSwitch(true);
+    }
+    /**
+     * Turn device off
+     */
+    async turnOff() {
+        return this.toggleSwitch(false);
+    }
+    /**
+     * Toggle device power
+     */
+    async toggleSwitch(enabled) {
+        logger_1.logger.info(`Setting device power to ${enabled ? 'on' : 'off'}: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('setSwitch');
+        body.payload.data = {
+            powerSwitch: enabled ? 1 : 0,
+            switchIdx: 0
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'toggleSwitch');
+        if (success) {
+            this.deviceStatus = enabled ? 'on' : 'off';
+            return true;
+        }
+        logger_1.logger.error(`Failed to set device power to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+        return false;
+    }
+    /**
+     * Set mist level
+     */
+    async setMistLevel(level) {
+        if (!this.mistLevels.includes(level)) {
+            const error = `Invalid mist level: ${level}. Must be one of: ${this.mistLevels.join(', ')}`;
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        logger_1.logger.info(`Setting mist level to ${level} for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('setVirtualLevel');
+        body.payload.data = {
+            levelIdx: 0,
+            virtualLevel: level,
+            levelType: 'mist'
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setMistLevel');
+        if (!success) {
+            logger_1.logger.error(`Failed to set mist level to ${level} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Change fan speed - Implemented to satisfy interface but redirects to setMistLevel
+     */
+    async changeFanSpeed(speed) {
+        logger_1.logger.debug(`Redirecting fan speed change to mist level for device: ${this.deviceName}`);
+        return this.setMistLevel(speed);
+    }
+    /**
+     * Set device mode
+     */
+    async setMode(mode) {
+        if (!this.modes.includes(mode)) {
+            const error = `Invalid mode: ${mode}. Must be one of: ${this.modes.join(', ')}`;
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        logger_1.logger.debug(`Setting mode to ${mode} for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('setHumidityMode');
+        body.payload.data = {
+            workMode: mode === 'auto' ? 'autoPro' : mode
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setMode');
+        if (success) {
+            this.details.mode = mode;
+        }
+        else {
+            logger_1.logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Set target humidity
+     */
+    async setHumidity(humidity) {
+        if (humidity < this.humidityRange.min || humidity > this.humidityRange.max) {
+            const error = `Invalid humidity: ${humidity}. Must be between ${this.humidityRange.min} and ${this.humidityRange.max}`;
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        logger_1.logger.debug(`Setting target humidity to ${humidity}% for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('setTargetHumidity');
+        body.payload.data = {
+            targetHumidity: humidity
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setHumidity');
+        if (!success) {
+            logger_1.logger.error(`Failed to set target humidity to ${humidity}% for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Set display status
+     */
+    async setDisplay(enabled) {
+        logger_1.logger.debug(`Setting display to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+        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) {
+            logger_1.logger.error(`Failed to set display to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Set drying mode enabled
+     */
+    async setDryingModeEnabled(enabled) {
+        logger_1.logger.debug(`Setting drying mode to ${enabled ? 'enabled' : 'disabled'} for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('setDryingMode');
+        body.payload.data = {
+            autoDryingSwitch: enabled ? 1 : 0
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setDryingModeEnabled');
+        if (!success) {
+            logger_1.logger.error(`Failed to set drying mode to ${enabled ? 'enabled' : 'disabled'} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Turn on display
+     */
+    async turnOnDisplay() {
+        logger_1.logger.debug(`Turning on display for device: ${this.deviceName}`);
+        return this.setDisplay(true);
+    }
+    /**
+     * Turn off display
+     */
+    async turnOffDisplay() {
+        logger_1.logger.debug(`Turning off display for device: ${this.deviceName}`);
+        return this.setDisplay(false);
+    }
+    /**
+     * Set auto mode
+     */
+    async setAutoMode() {
+        logger_1.logger.debug(`Setting auto mode for device: ${this.deviceName}`);
+        return this.setMode('auto');
+    }
+    /**
+     * Set manual mode
+     */
+    async setManualMode() {
+        logger_1.logger.debug(`Setting manual mode for device: ${this.deviceName}`);
+        return this.setMode('manual');
+    }
+    /**
+     * Get current humidity
+     * Provides access to the current humidity reading
+     */
+    get currentHumidity() {
+        return this.details.humidity || 0;
+    }
+    /**
+     * Get target humidity
+     * Provides access to the target humidity setting
+     */
+    get targetHumidity() {
+        return this.details.target_humidity || 0;
+    }
+    /**
+     * Get current temperature
+     * Provides access to the current temperature reading
+     */
+    get temperature() {
+        return this.details.temperature || 0;
+    }
+    /**
+     * Check if water tank is empty
+     * Returns true if water tank is empty and needs to be refilled
+     */
+    get waterLacks() {
+        return this.details.water_lacks || false;
+    }
+    /**
+     * Check if water tank is lifted
+     * Returns true if water tank is lifted/removed from the device
+     */
+    get waterTankLifted() {
+        return this.details.water_tank_lifted || false;
+    }
+    /**
+     * Get filter life percentage
+     * Returns the percentage of filter life remaining
+     */
+    get filterLifePercentage() {
+        return this.details.filter_life_percentage || 0;
+    }
+    /**
+     * Check if drying mode is enabled
+     * Returns true if drying mode is enabled
+     */
+    get dryingModeEnabled() {
+        var _a;
+        const enabled = (_a = this.details.drying_mode) === null || _a === void 0 ? void 0 : _a.autoDryingSwitch;
+        return enabled === 1;
+    }
+    /**
+     * Get drying mode state
+     * Returns 'on' if drying mode is active, 'off' if inactive, null if unknown
+     */
+    get dryingModeState() {
+        var _a;
+        const state = (_a = this.details.drying_mode) === null || _a === void 0 ? void 0 : _a.dryingState;
+        if (state === 1)
+            return 'on';
+        if (state === 2)
+            return 'off';
+        return null;
+    }
+    /**
+     * Get drying mode level
+     * Returns 'low' if level is 1, 'high' if level is 2, null if unknown
+     */
+    get dryingModeLevel() {
+        var _a;
+        const level = (_a = this.details.drying_mode) === null || _a === void 0 ? void 0 : _a.dryingLevel;
+        if (level === 1)
+            return 'low';
+        if (level === 2)
+            return 'high';
+        return null;
+    }
+    /**
+     * Get drying mode seconds remaining
+     * Returns the number of seconds remaining in drying mode
+     */
+    get dryingModeSecondsRemaining() {
+        var _a;
+        return ((_a = this.details.drying_mode) === null || _a === void 0 ? void 0 : _a.dryingRemain) || 0;
+    }
+}
+exports.VeSyncSuperior6000S = VeSyncSuperior6000S;

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' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2';
+        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2' | 'VeSyncSuperior6000S' | 'VeSyncHumid1000S' | 'VeSyncHumid200S';
         features: string[];
         levels?: number[];
     };
@@ -35,7 +35,7 @@ export declare abstract class VeSyncFan extends VeSyncBaseDevice {
         action: string;
     } | null;
     protected config: {
-        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2';
+        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2' | 'VeSyncSuperior6000S' | 'VeSyncHumid1000S' | 'VeSyncHumid200S';
         features: string[];
         levels?: number[];
     };
@@ -44,6 +44,14 @@ export declare abstract class VeSyncFan extends VeSyncBaseDevice {
      * Check if feature is supported
      */
     hasFeature(feature: string): boolean;
+    /**
+     * Check if feature is supported in current mode
+     */
+    isFeatureSupportedInCurrentMode(feature: string): boolean;
+    /**
+     * Get maximum fan speed level
+     */
+    getMaxFanSpeed(): number;
     /**
      * Get current mode
      */

package/dist/lib/vesyncFan.js

@@ -192,8 +192,9 @@ exports.fanConfig = {
         features: ['display', 'humidity', 'mist', 'timer', 'auto_mode']
     },
     'Classic200S': {
-        module: 'VeSyncHumidifier',
-        features: ['display', 'humidity', 'mist', 'timer', 'auto_mode']
+        module: 'VeSyncHumid200S',
+        features: ['display', 'humidity', 'mist', 'timer', 'auto_mode'],
+        levels: [1, 2, 3]
     },
     // Dual Series
     'Dual200S': {
@@ -266,21 +267,25 @@ exports.fanConfig = {
         features: ['display', 'humidity', 'mist', 'warm', 'timer', 'auto_mode']
     },
     'LUH-M101S-WUS': {
-        module: 'VeSyncWarmHumidifier',
-        features: ['display', 'humidity', 'mist', 'warm', 'timer', 'auto_mode']
+        module: 'VeSyncHumid1000S',
+        features: ['display', 'humidity', 'mist', 'timer', 'auto_mode', 'night_light'],
+        levels: [1, 2, 3, 4, 5, 6, 7, 8, 9]
     },
     'LUH-M101S-WEUR': {
-        module: 'VeSyncWarmHumidifier',
-        features: ['display', 'humidity', 'mist', 'warm', 'timer', 'auto_mode']
+        module: 'VeSyncHumid1000S',
+        features: ['display', 'humidity', 'mist', 'timer', 'auto_mode', 'night_light'],
+        levels: [1, 2, 3, 4, 5, 6, 7, 8, 9]
     },
-    // LEH Series
+    // LEH Series - Superior 6000S
     'LEH-S601S-WUS': {
-        module: 'VeSyncWarmHumidifier',
-        features: ['display', 'humidity', 'mist', 'warm', 'timer', 'auto_mode', 'drying']
+        module: 'VeSyncSuperior6000S',
+        features: ['display', 'humidity', 'mist', 'timer', 'auto_mode', 'drying', 'temperature'],
+        levels: [1, 2, 3, 4, 5, 6, 7, 8, 9]
     },
     'LEH-S601S-WUSR': {
-        module: 'VeSyncWarmHumidifier',
-        features: ['display', 'humidity', 'mist', 'warm', 'timer', 'auto_mode', 'drying']
+        module: 'VeSyncSuperior6000S',
+        features: ['display', 'humidity', 'mist', 'timer', 'auto_mode', 'drying', 'temperature'],
+        levels: [1, 2, 3, 4, 5, 6, 7, 8, 9]
     },
     // LV Series
     'LV-PUR131S': {
@@ -317,6 +322,40 @@ class VeSyncFan extends vesyncBaseDevice_1.VeSyncBaseDevice {
     hasFeature(feature) {
         return this.config.features.includes(feature);
     }
+    /**
+     * Check if feature is supported in current mode
+     */
+    isFeatureSupportedInCurrentMode(feature) {
+        // First check if the feature is supported at all
+        if (!this.hasFeature(feature)) {
+            return false;
+        }
+        // Check mode-specific restrictions
+        const currentMode = this.mode;
+        // Some features are not supported in sleep mode
+        if (currentMode === 'sleep') {
+            // Display and child lock are not supported in sleep mode
+            if (feature === 'display' || feature === 'child_lock') {
+                return false;
+            }
+        }
+        // Fan speed is only supported in manual mode for some devices
+        if (feature === 'fan_speed' && this.deviceType.startsWith('LV-')) {
+            return currentMode === 'manual';
+        }
+        // Auto mode is not supported on Core200S
+        if (feature === 'auto_mode' && this.deviceType.includes('Core200S')) {
+            return false;
+        }
+        // Feature is supported in current mode
+        return true;
+    }
+    /**
+     * Get maximum fan speed level
+     */
+    getMaxFanSpeed() {
+        return this.config.levels ? Math.max(...this.config.levels) : 3;
+    }
     /**
      * Get current mode
      */

package/package.json

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

package/src/lib/fans/airBypass.ts

@@ -388,6 +388,13 @@ export class VeSyncAirBypass extends VeSyncFan {
             }
         }
 
+        // Special handling for Core200S auto mode
+        if (this.deviceType.includes('Core200S') && mode === 'auto') {
+            // Core200S doesn't support auto mode, so we'll set it to manual mode
+            logger.warn(`Auto mode not supported for ${this.deviceType}, using manual mode instead`);
+            return this.setMode('manual');
+        }
+
         // Standard implementation for other devices
         const [response, status] = await this.callApi(
             '/cloud/v2/deviceManaged/bypassV2',
@@ -408,10 +415,13 @@ export class VeSyncAirBypass extends VeSyncFan {
         );
 
         const success = this.checkResponse([response, status], 'setMode');
-        if (!success) {
+        if (success) {
+            this.details.mode = mode;
+            return true;
+        } else {
             logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+            return false;
         }
-        return success;
     }
 
     /**
@@ -424,6 +434,11 @@ export class VeSyncAirBypass extends VeSyncFan {
             throw new Error(error);
         }
 
+        // Check if device is in sleep mode - display control may not work in sleep mode
+        if (this.details.mode === 'sleep') {
+            logger.warn(`Device ${this.deviceName} is in sleep mode, display control may not work`);
+        }
+
         logger.debug(`Setting display to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
 
         // Special handling for LV series
@@ -479,12 +494,20 @@ export class VeSyncAirBypass extends VeSyncFan {
         );
 
         const success = this.checkResponse([response, status], 'setDisplay');
+        
+        // Check for error code 11018000 (operation not supported in current mode)
+        if (response?.result?.code === 11018000) {
+            logger.warn(`Display control not supported in current mode for device: ${this.deviceName}`);
+            return false;
+        }
+        
         if (success) {
             this.details.screenStatus = enabled ? 'on' : 'off';
+            return true;
         } else {
             logger.error(`Failed to set display to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+            return false;
         }
-        return success;
     }
 
     /**
@@ -497,6 +520,11 @@ export class VeSyncAirBypass extends VeSyncFan {
             throw new Error(error);
         }
 
+        // Check if device is in sleep mode - child lock may not work in sleep mode
+        if (this.details.mode === 'sleep') {
+            logger.warn(`Device ${this.deviceName} is in sleep mode, child lock control may not work`);
+        }
+
         logger.debug(`Setting child lock to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
 
         // Special handling for LV series
@@ -527,6 +555,11 @@ export class VeSyncAirBypass extends VeSyncFan {
                 this.details.childLock = enabled;
                 return true;
             } else {
+                // Check for error code 11000000 (feature not supported)
+                if (response?.code === 11000000) {
+                    logger.warn(`Child lock control not supported via API for device: ${this.deviceName}`);
+                    return false;
+                }
                 logger.error(`Failed to set child lock to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
                 return false;
             }
@@ -552,12 +585,20 @@ export class VeSyncAirBypass extends VeSyncFan {
         );
 
         const success = this.checkResponse([response, status], 'setChildLock');
+        
+        // Check for error code 11000000 (feature not supported)
+        if (response?.code === 11000000 || (response?.result?.code === 11000000)) {
+            logger.warn(`Child lock control not supported via API for device: ${this.deviceName}`);
+            return false;
+        }
+        
         if (success) {
-            this.details.child_lock = enabled;
+            this.details.childLock = enabled;
+            return true;
         } else {
             logger.error(`Failed to set child lock to ${enabled ? 'on' : 'off'} for device: ${this.deviceName}`);
+            return false;
         }
-        return success;
     }
 
     /**
@@ -597,10 +638,13 @@ export class VeSyncAirBypass extends VeSyncFan {
             );
 
             const success = this.checkResponse([response, status], 'setTimer');
-            if (!success) {
+            if (success) {
+                this.timer = { duration: hours * 3600, action: 'off' };
+                return true;
+            } else {
                 logger.error(`Failed to set timer to ${hours} hours for device: ${this.deviceName}`);
+                return false;
             }
-            return success;
         }
 
         // Standard implementation for other devices
@@ -624,10 +668,20 @@ export class VeSyncAirBypass extends VeSyncFan {
         );
 
         const success = this.checkResponse([response, status], 'setTimer');
-        if (!success) {
+        
+        // Check for successful response with timer ID
+        if (success && response?.result?.result?.id) {
+            this.timer = { duration: hours * 3600, action: 'off' };
+            return true;
+        } else if (success) {
+            // API call succeeded but no timer ID returned
+            logger.warn(`Timer API call succeeded but no timer ID returned for device: ${this.deviceName}`);
+            this.timer = { duration: hours * 3600, action: 'off' };
+            return true;
+        } else {
             logger.error(`Failed to set timer to ${hours} hours for device: ${this.deviceName}`);
+            return false;
         }
-        return success;
     }
 
     /**
@@ -640,6 +694,12 @@ export class VeSyncAirBypass extends VeSyncFan {
             throw new Error(error);
         }
 
+        // If no timer is set, return success
+        if (!this.timer) {
+            logger.debug(`No timer to clear for device: ${this.deviceName}`);
+            return true;
+        }
+
         logger.debug(`Clearing timer for device: ${this.deviceName}`);
 
         // Special handling for LV series
@@ -665,10 +725,13 @@ export class VeSyncAirBypass extends VeSyncFan {
             );
 
             const success = this.checkResponse([response, status], 'clearTimer');
-            if (!success) {
+            if (success) {
+                this.timer = null;
+                return true;
+            } else {
                 logger.error(`Failed to clear timer for device: ${this.deviceName}`);
+                return false;
             }
-            return success;
         }
 
         // Standard implementation for other devices
@@ -689,10 +752,21 @@ export class VeSyncAirBypass extends VeSyncFan {
         );
 
         const success = this.checkResponse([response, status], 'clearTimer');
-        if (!success) {
+        
+        // Check for error code 11000000 (feature not supported or no timer to clear)
+        if (response?.code === 11000000 || (response?.result?.code === 11000000)) {
+            logger.warn(`No timer to clear or timer control not supported via API for device: ${this.deviceName}`);
+            this.timer = null;
+            return true;
+        }
+        
+        if (success) {
+            this.timer = null;
+            return true;
+        } else {
             logger.error(`Failed to clear timer for device: ${this.deviceName}`);
+            return false;
         }
-        return success;
     }
 
     /**