tsvesync 1.0.89 → 1.0.91

package/dist/__tests__/vesyncFan.test.js

@@ -0,0 +1,263 @@
+"use strict";
+/**
+ * Unit tests for VeSyncFan base class and air quality features
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vesyncFan_1 = require("../lib/vesyncFan");
+// Mock VeSync manager
+const mockManager = {
+    username: 'test@example.com',
+    password: 'testpass',
+    token: 'testtoken',
+    accountID: 'testaccount',
+    apiKey: 'testapikey',
+    apiBase: 'testbase',
+    timezone: 'UTC'
+};
+// Test implementation of abstract VeSyncFan class
+class TestVeSyncFan extends vesyncFan_1.VeSyncFan {
+    async getDetails() {
+        return true;
+    }
+    async turnOn() {
+        this.deviceStatus = 'on';
+        return true;
+    }
+    async turnOff() {
+        this.deviceStatus = 'off';
+        return true;
+    }
+    async changeFanSpeed(level) {
+        this.details.speed = level;
+        return true;
+    }
+    async changeMode(mode) {
+        this.details.mode = mode;
+        return true;
+    }
+}
+describe('VeSyncFan Base Class', () => {
+    let fan;
+    beforeEach(() => {
+        const deviceDetails = {
+            deviceName: 'Test Fan',
+            deviceType: 'Core300S',
+            cid: 'test-cid',
+            uuid: 'test-uuid',
+            deviceStatus: 'off',
+            deviceRegion: 'US',
+            configModule: 'VeSyncAirBypass',
+            macId: '00:11:22:33:44:55',
+            deviceCategory: 'fan',
+            connectionStatus: 'online'
+        };
+        fan = new TestVeSyncFan(deviceDetails, mockManager);
+    });
+    describe('Air Quality Getters', () => {
+        it('should return default values when air quality data is not available', () => {
+            expect(fan.airQualityValue).toBe(0);
+            expect(fan.pm1).toBe(0);
+            expect(fan.pm10).toBe(0);
+            expect(fan.aqPercent).toBe(0);
+            expect(fan.airQualityLevel).toBe('');
+        });
+        it('should return correct air quality values when data is available', () => {
+            fan.details.air_quality_value = 25;
+            fan.details.pm1 = 15;
+            fan.details.pm10 = 30;
+            fan.details.aq_percent = 80;
+            fan.details.air_quality = 'Good';
+            expect(fan.airQualityValue).toBe(25);
+            expect(fan.pm1).toBe(15);
+            expect(fan.pm10).toBe(30);
+            expect(fan.aqPercent).toBe(80);
+            expect(fan.airQualityLevel).toBe('Good');
+        });
+        it('should handle numeric air quality levels', () => {
+            fan.details.air_quality = 2;
+            expect(fan.airQualityLevel).toBe(2);
+        });
+        it('should maintain backward compatibility with airQuality getter', () => {
+            fan.details.air_quality = 'Excellent';
+            expect(fan.airQuality).toBe('Excellent');
+            expect(fan.airQuality).toBe(fan.airQualityLevel);
+        });
+        it('should handle extreme air quality values', () => {
+            fan.details.air_quality_value = 999;
+            fan.details.pm1 = 500;
+            fan.details.pm10 = 1000;
+            fan.details.aq_percent = 100;
+            expect(fan.airQualityValue).toBe(999);
+            expect(fan.pm1).toBe(500);
+            expect(fan.pm10).toBe(1000);
+            expect(fan.aqPercent).toBe(100);
+        });
+        it('should handle zero air quality values', () => {
+            fan.details.air_quality_value = 0;
+            fan.details.pm1 = 0;
+            fan.details.pm10 = 0;
+            fan.details.aq_percent = 0;
+            expect(fan.airQualityValue).toBe(0);
+            expect(fan.pm1).toBe(0);
+            expect(fan.pm10).toBe(0);
+            expect(fan.aqPercent).toBe(0);
+        });
+    });
+    describe('Filter Life Handling', () => {
+        it('should return 0 when filter life is not available', () => {
+            expect(fan.filterLife).toBe(0);
+        });
+        it('should handle number format filter life (VeSyncAirBypass)', () => {
+            fan.details.filter_life = 85;
+            expect(fan.filterLife).toBe(85);
+        });
+        it('should handle object format filter life (VeSyncAir131)', () => {
+            fan.details.filter_life = { percent: 72 };
+            expect(fan.filterLife).toBe(72);
+        });
+        it('should handle object format with missing percent property', () => {
+            fan.details.filter_life = { other: 'value' };
+            expect(fan.filterLife).toBe(0);
+        });
+        it('should handle null filter life object', () => {
+            fan.details.filter_life = null;
+            expect(fan.filterLife).toBe(0);
+        });
+        it('should handle undefined filter life', () => {
+            fan.details.filter_life = undefined;
+            expect(fan.filterLife).toBe(0);
+        });
+        it('should handle zero filter life values', () => {
+            fan.details.filter_life = 0;
+            expect(fan.filterLife).toBe(0);
+            fan.details.filter_life = { percent: 0 };
+            expect(fan.filterLife).toBe(0);
+        });
+        it('should handle 100% filter life', () => {
+            fan.details.filter_life = 100;
+            expect(fan.filterLife).toBe(100);
+            fan.details.filter_life = { percent: 100 };
+            expect(fan.filterLife).toBe(100);
+        });
+        it('should handle invalid filter life formats gracefully', () => {
+            fan.details.filter_life = 'invalid';
+            expect(fan.filterLife).toBe(0);
+            fan.details.filter_life = [];
+            expect(fan.filterLife).toBe(0);
+        });
+    });
+    describe('Feature Detection', () => {
+        it('should detect air quality feature for supported devices', () => {
+            expect(fan.hasFeature('air_quality')).toBe(true);
+        });
+        it('should detect supported features based on device type', () => {
+            expect(fan.hasFeature('display')).toBe(true);
+            expect(fan.hasFeature('child_lock')).toBe(true);
+            expect(fan.hasFeature('night_light')).toBe(true);
+            expect(fan.hasFeature('timer')).toBe(true);
+            expect(fan.hasFeature('fan_speed')).toBe(true);
+            expect(fan.hasFeature('auto_mode')).toBe(true);
+            expect(fan.hasFeature('sleep_mode')).toBe(true);
+        });
+        it('should return false for unsupported features', () => {
+            expect(fan.hasFeature('unsupported_feature')).toBe(false);
+        });
+        it('should handle devices without configuration', () => {
+            const unknownDevice = new TestVeSyncFan({
+                deviceName: 'Unknown Device',
+                deviceType: 'UnknownType',
+                cid: 'test-cid',
+                uuid: 'test-uuid'
+            }, mockManager);
+            expect(unknownDevice.hasFeature('air_quality')).toBe(false);
+        });
+    });
+    describe('Feature Support in Current Mode', () => {
+        it('should support air quality in all modes', () => {
+            fan.details.mode = 'auto';
+            expect(fan.isFeatureSupportedInCurrentMode('air_quality')).toBe(true);
+            fan.details.mode = 'manual';
+            expect(fan.isFeatureSupportedInCurrentMode('air_quality')).toBe(true);
+            fan.details.mode = 'sleep';
+            expect(fan.isFeatureSupportedInCurrentMode('air_quality')).toBe(true);
+        });
+        it('should disable display and child lock in sleep mode', () => {
+            fan.details.mode = 'sleep';
+            expect(fan.isFeatureSupportedInCurrentMode('display')).toBe(false);
+            expect(fan.isFeatureSupportedInCurrentMode('child_lock')).toBe(false);
+        });
+        it('should support display and child lock in other modes', () => {
+            fan.details.mode = 'auto';
+            expect(fan.isFeatureSupportedInCurrentMode('display')).toBe(true);
+            expect(fan.isFeatureSupportedInCurrentMode('child_lock')).toBe(true);
+            fan.details.mode = 'manual';
+            expect(fan.isFeatureSupportedInCurrentMode('display')).toBe(true);
+            expect(fan.isFeatureSupportedInCurrentMode('child_lock')).toBe(true);
+        });
+        it('should return false for unsupported features regardless of mode', () => {
+            fan.details.mode = 'auto';
+            expect(fan.isFeatureSupportedInCurrentMode('unsupported')).toBe(false);
+        });
+    });
+    describe('Device Capabilities', () => {
+        it('should return correct maximum fan speed', () => {
+            expect(fan.getMaxFanSpeed()).toBe(4); // Core300S has 4 speeds
+        });
+        it('should handle devices without speed levels configured', () => {
+            const deviceWithoutLevels = new TestVeSyncFan({
+                deviceName: 'Basic Device',
+                deviceType: 'UnknownType',
+                cid: 'test-cid',
+                uuid: 'test-uuid'
+            }, mockManager);
+            expect(deviceWithoutLevels.getMaxFanSpeed()).toBe(3); // Default fallback
+        });
+        it('should return current mode and speed', () => {
+            fan.details.mode = 'auto';
+            fan.details.speed = 3;
+            expect(fan.mode).toBe('auto');
+            expect(fan.speed).toBe(3);
+        });
+        it('should handle missing mode and speed', () => {
+            expect(fan.mode).toBe('');
+            expect(fan.speed).toBe(0);
+        });
+    });
+    describe('Edge Cases and Error Handling', () => {
+        it('should handle missing details object', () => {
+            const minimalFan = new TestVeSyncFan({
+                deviceName: 'Minimal Device',
+                deviceType: 'Core300S',
+                cid: 'test-cid',
+                uuid: 'test-uuid'
+            }, mockManager);
+            // Details should be initialized as empty object
+            expect(minimalFan.airQualityValue).toBe(0);
+            expect(minimalFan.filterLife).toBe(0);
+            expect(minimalFan.mode).toBe('');
+            expect(minimalFan.speed).toBe(0);
+        });
+        it('should handle null and undefined values gracefully', () => {
+            fan.details.air_quality_value = null;
+            fan.details.filter_life = null;
+            fan.details.mode = null;
+            fan.details.speed = null;
+            expect(fan.airQualityValue).toBe(0);
+            expect(fan.filterLife).toBe(0);
+            expect(fan.mode).toBe('');
+            expect(fan.speed).toBe(0);
+        });
+        it('should handle invalid data types', () => {
+            fan.details.air_quality_value = 'invalid';
+            fan.details.pm1 = 'invalid';
+            fan.details.pm10 = 'invalid';
+            fan.details.aq_percent = 'invalid';
+            fan.details.speed = 'invalid';
+            expect(fan.airQualityValue).toBe(0);
+            expect(fan.pm1).toBe(0);
+            expect(fan.pm10).toBe(0);
+            expect(fan.aqPercent).toBe(0);
+            expect(fan.speed).toBe(0);
+        });
+    });
+});

package/dist/lib/fans/air131.js

@@ -56,10 +56,11 @@ class VeSyncAir131 extends vesyncFan_1.VeSyncFan {
             this.details = {
                 mode: data.mode || 'manual', // Default to manual if not specified
                 speed: data.level || 0,
-                filterLife: data.filterLife || 0,
-                screenStatus: data.screenStatus || 'off',
-                childLock: data.childLock || false,
-                airQuality: data.airQuality || 'unknown',
+                filter_life: data.filterLife || data.filter_life || 0,
+                screen_status: data.screenStatus || 'off',
+                child_lock: data.childLock || false,
+                air_quality: data.airQuality || 'unknown',
+                air_quality_value: data.air_quality_value || 0,
                 active_time: data.activeTime || 0
             };
             // Store last known speed when device is on and has a valid speed

package/dist/lib/fans/airBypass.js

@@ -56,11 +56,19 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
                 this.details = {
                     mode: result.mode || '',
                     speed: result.level || 0,
-                    filterLife: result.filter_life || 0,
-                    screenStatus: result.display ? 'on' : 'off',
-                    childLock: result.child_lock || false,
-                    airQuality: result.air_quality || 0
+                    filter_life: result.filter_life || 0,
+                    screen_status: result.display ? 'on' : 'off',
+                    child_lock: result.child_lock || false,
+                    air_quality: result.air_quality || 0,
+                    air_quality_value: result.air_quality_value || 0
                 };
+                // Capture additional air quality properties if available
+                if ('PM1' in result)
+                    this.details.pm1 = result.PM1;
+                if ('PM10' in result)
+                    this.details.pm10 = result.PM10;
+                if ('AQPercent' in result)
+                    this.details.aq_percent = result.AQPercent;
                 // Don't overwrite config as it contains features array
                 if (result.configuration) {
                     this.details.configuration = result.configuration;

package/dist/lib/helpers.d.ts

@@ -2,21 +2,8 @@
  * Helper functions for VeSync API
  */
 import { VeSync } from './vesync';
-export declare const REGIONAL_ENDPOINTS: {
-    readonly US: "https://smartapi.vesync.com";
-    readonly EU: "https://smartapi.vesync.eu";
-    readonly ASIA: "https://smartapi.vesync.com.cn";
-};
 export declare function getApiBaseUrl(): string;
 export declare function setApiBaseUrl(url: string): void;
-/**
- * Get regional API endpoint based on timezone
- */
-export declare function getRegionalEndpoint(timeZone: string): string;
-/**
- * Set API endpoint based on timezone if not explicitly set
- */
-export declare function setRegionalEndpoint(timeZone: string): void;
 export declare const API_RATE_LIMIT = 30;
 export declare const API_TIMEOUT = 15000;
 export declare const APP_VERSION = "2.8.6";

package/dist/lib/helpers.js

@@ -6,174 +6,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Helpers = exports.BYPASS_HEADER_UA = exports.MOBILE_ID = exports.DEFAULT_REGION = exports.DEFAULT_TZ = exports.USER_TYPE = exports.PHONE_OS = exports.PHONE_BRAND = exports.APP_VERSION = exports.API_TIMEOUT = exports.API_RATE_LIMIT = exports.REGIONAL_ENDPOINTS = void 0;
+exports.Helpers = exports.BYPASS_HEADER_UA = exports.MOBILE_ID = exports.DEFAULT_REGION = exports.DEFAULT_TZ = exports.USER_TYPE = exports.PHONE_OS = exports.PHONE_BRAND = exports.APP_VERSION = exports.API_TIMEOUT = exports.API_RATE_LIMIT = void 0;
 exports.getApiBaseUrl = getApiBaseUrl;
 exports.setApiBaseUrl = setApiBaseUrl;
-exports.getRegionalEndpoint = getRegionalEndpoint;
-exports.setRegionalEndpoint = setRegionalEndpoint;
 const axios_1 = __importDefault(require("axios"));
 const crypto_1 = __importDefault(require("crypto"));
 const logger_1 = require("./logger");
-// API configuration
+// API configuration - Always use US endpoint
 let _apiBaseUrl = 'https://smartapi.vesync.com';
-// Regional API endpoints
-exports.REGIONAL_ENDPOINTS = {
-    US: 'https://smartapi.vesync.com',
-    EU: 'https://smartapi.vesync.eu',
-    ASIA: 'https://smartapi.vesync.com.cn'
-};
-// Timezone to region mapping for API endpoint detection
-const TIMEZONE_REGION_MAP = {
-    // European timezones - Western Europe
-    'Europe/Berlin': 'EU',
-    'Europe/London': 'EU',
-    'Europe/Paris': 'EU',
-    'Europe/Rome': 'EU',
-    'Europe/Madrid': 'EU',
-    'Europe/Amsterdam': 'EU',
-    'Europe/Vienna': 'EU',
-    'Europe/Brussels': 'EU',
-    'Europe/Copenhagen': 'EU',
-    'Europe/Dublin': 'EU',
-    'Europe/Helsinki': 'EU',
-    'Europe/Lisbon': 'EU',
-    'Europe/Luxembourg': 'EU',
-    'Europe/Oslo': 'EU',
-    'Europe/Prague': 'EU',
-    'Europe/Stockholm': 'EU',
-    'Europe/Warsaw': 'EU',
-    'Europe/Zurich': 'EU',
-    // European timezones - Eastern Europe
-    'Europe/Athens': 'EU',
-    'Europe/Budapest': 'EU',
-    'Europe/Bucharest': 'EU',
-    'Europe/Sofia': 'EU',
-    'Europe/Kiev': 'EU',
-    'Europe/Riga': 'EU',
-    'Europe/Vilnius': 'EU',
-    'Europe/Tallinn': 'EU',
-    'Europe/Zagreb': 'EU',
-    'Europe/Ljubljana': 'EU',
-    'Europe/Bratislava': 'EU',
-    'Europe/Belgrade': 'EU',
-    'Europe/Sarajevo': 'EU',
-    'Europe/Podgorica': 'EU',
-    'Europe/Skopje': 'EU',
-    'Europe/Tirane': 'EU',
-    // European timezones - Nordic/Baltic
-    'Europe/Reykjavik': 'EU',
-    'Europe/Moscow': 'EU',
-    'Europe/Kaliningrad': 'EU',
-    'Europe/Minsk': 'EU',
-    // European timezones - Other
-    'Europe/Malta': 'EU',
-    'Europe/Monaco': 'EU',
-    'Europe/Vatican': 'EU',
-    'Europe/San_Marino': 'EU',
-    'Europe/Andorra': 'EU',
-    'Europe/Gibraltar': 'EU',
-    'Europe/Isle_of_Man': 'EU',
-    'Europe/Jersey': 'EU',
-    'Europe/Guernsey': 'EU',
-    // Asian timezones - East Asia
-    'Asia/Shanghai': 'ASIA',
-    'Asia/Beijing': 'ASIA',
-    'Asia/Hong_Kong': 'ASIA',
-    'Asia/Tokyo': 'ASIA',
-    'Asia/Seoul': 'ASIA',
-    'Asia/Singapore': 'ASIA',
-    'Asia/Taipei': 'ASIA',
-    'Asia/Macau': 'ASIA',
-    // Asian timezones - Southeast Asia
-    'Asia/Bangkok': 'ASIA',
-    'Asia/Jakarta': 'ASIA',
-    'Asia/Manila': 'ASIA',
-    'Asia/Ho_Chi_Minh': 'ASIA',
-    'Asia/Kuala_Lumpur': 'ASIA',
-    'Asia/Phnom_Penh': 'ASIA',
-    'Asia/Vientiane': 'ASIA',
-    'Asia/Yangon': 'ASIA',
-    'Asia/Brunei': 'ASIA',
-    // Asian timezones - South Asia
-    'Asia/Mumbai': 'ASIA',
-    'Asia/Delhi': 'ASIA',
-    'Asia/Kolkata': 'ASIA',
-    'Asia/Dhaka': 'ASIA',
-    'Asia/Karachi': 'ASIA',
-    'Asia/Colombo': 'ASIA',
-    'Asia/Kathmandu': 'ASIA',
-    'Asia/Thimphu': 'ASIA',
-    // Asian timezones - Central Asia
-    'Asia/Almaty': 'ASIA',
-    'Asia/Bishkek': 'ASIA',
-    'Asia/Dushanbe': 'ASIA',
-    'Asia/Tashkent': 'ASIA',
-    'Asia/Ashgabat': 'ASIA',
-    // Asian timezones - West Asia / Middle East
-    'Asia/Dubai': 'ASIA',
-    'Asia/Riyadh': 'ASIA',
-    'Asia/Tehran': 'ASIA',
-    'Asia/Baghdad': 'ASIA',
-    'Asia/Kuwait': 'ASIA',
-    'Asia/Qatar': 'ASIA',
-    'Asia/Bahrain': 'ASIA',
-    'Asia/Muscat': 'ASIA',
-    'Asia/Baku': 'ASIA',
-    'Asia/Yerevan': 'ASIA',
-    'Asia/Tbilisi': 'ASIA',
-    // Oceania (using ASIA endpoint for now)
-    'Australia/Sydney': 'ASIA',
-    'Australia/Melbourne': 'ASIA',
-    'Australia/Brisbane': 'ASIA',
-    'Australia/Perth': 'ASIA',
-    'Australia/Adelaide': 'ASIA',
-    'Australia/Hobart': 'ASIA',
-    'Australia/Darwin': 'ASIA',
-    'Australia/Canberra': 'ASIA',
-    'Pacific/Auckland': 'ASIA',
-    'Pacific/Wellington': 'ASIA',
-    'Pacific/Fiji': 'ASIA',
-    'Pacific/Honolulu': 'US',
-    // North America (Canada)
-    'America/Toronto': 'US',
-    'America/Montreal': 'US',
-    'America/Vancouver': 'US',
-    'America/Calgary': 'US',
-    'America/Edmonton': 'US',
-    'America/Winnipeg': 'US',
-    'America/Halifax': 'US',
-    'America/St_Johns': 'US',
-    // North America (Mexico)
-    'America/Mexico_City': 'US',
-    'America/Tijuana': 'US',
-    'America/Cancun': 'US',
-    'America/Merida': 'US',
-    'America/Monterrey': 'US'
-    // US and other timezones default to US endpoint
-};
 function getApiBaseUrl() {
     return _apiBaseUrl;
 }
 function setApiBaseUrl(url) {
     _apiBaseUrl = url;
 }
-/**
- * Get regional API endpoint based on timezone
- */
-function getRegionalEndpoint(timeZone) {
-    const region = TIMEZONE_REGION_MAP[timeZone] || 'US';
-    return exports.REGIONAL_ENDPOINTS[region];
-}
-/**
- * Set API endpoint based on timezone if not explicitly set
- */
-function setRegionalEndpoint(timeZone) {
-    const regionalUrl = getRegionalEndpoint(timeZone);
-    if (_apiBaseUrl === exports.REGIONAL_ENDPOINTS.US && regionalUrl !== exports.REGIONAL_ENDPOINTS.US) {
-        logger_1.logger.debug(`Setting regional API endpoint for ${timeZone}: ${regionalUrl}`);
-        setApiBaseUrl(regionalUrl);
-    }
-}
 exports.API_RATE_LIMIT = 30;
 exports.API_TIMEOUT = 15000;
 exports.APP_VERSION = '2.8.6';
@@ -320,8 +166,8 @@ class Helpers {
         try {
             // Ensure API base URL is properly set
             if (!_apiBaseUrl || _apiBaseUrl === 'undefined') {
-                logger_1.logger.error('API base URL is not properly configured. Setting regional endpoint...');
-                setRegionalEndpoint(manager.timeZone);
+                logger_1.logger.error('API base URL is not properly configured. Setting to default US endpoint...');
+                setApiBaseUrl('https://smartapi.vesync.com');
             }
             const url = _apiBaseUrl + endpoint;
             logger_1.logger.debug(`Making API call to: ${url}`);

package/dist/lib/vesync.d.ts

@@ -43,7 +43,7 @@ export declare class VeSync {
      * Initialize VeSync Manager
      * @param username - VeSync account username
      * @param password - VeSync account password
-     * @param timeZone - Optional timezone (defaults to America/New_York)
+     * @param timeZone - Optional timezone for device operations (defaults to America/New_York)
      * @param debug - Optional debug mode flag
      * @param redact - Optional redact mode flag
      * @param apiUrl - Optional API base URL override

package/dist/lib/vesync.js

@@ -124,7 +124,7 @@ class VeSync {
      * Initialize VeSync Manager
      * @param username - VeSync account username
      * @param password - VeSync account password
-     * @param timeZone - Optional timezone (defaults to America/New_York)
+     * @param timeZone - Optional timezone for device operations (defaults to America/New_York)
      * @param debug - Optional debug mode flag
      * @param redact - Optional redact mode flag
      * @param apiUrl - Optional API base URL override
@@ -173,13 +173,13 @@ class VeSync {
             this.timeZone = helpers_1.DEFAULT_TZ;
             logger_1.logger.debug('Time zone is not a string');
         }
-        // Set custom API URL if provided, otherwise use regional endpoint
+        // Set custom API URL if provided, otherwise use default US endpoint
         if (apiUrl) {
             (0, helpers_1.setApiBaseUrl)(apiUrl);
         }
         else {
-            // Automatically set regional endpoint based on timezone
-            (0, helpers_1.setRegionalEndpoint)(this.timeZone);
+            // Always use US endpoint
+            (0, helpers_1.setApiBaseUrl)('https://smartapi.vesync.com');
         }
         // Set custom logger if provided
         if (customLogger) {
@@ -428,7 +428,7 @@ class VeSync {
                     switch (response.code) {
                         case -11012022:
                             logger_1.logger.error('App version too low error. Current version:', body.appVersion);
-                            logger_1.logger.error('This typically indicates a regional API compatibility issue.');
+                            logger_1.logger.error('This typically indicates an API version compatibility issue.');
                             break;
                         case -11003:
                             logger_1.logger.error('Authentication failed - check credentials');

package/dist/lib/vesyncFan.d.ts

@@ -18,10 +18,16 @@ export declare abstract class VeSyncFan extends VeSyncBaseDevice {
     protected details: {
         mode?: string;
         speed?: number;
-        filter_life?: number;
+        filter_life?: number | {
+            percent: number;
+        };
         screen_status?: 'on' | 'off';
         child_lock?: boolean;
-        air_quality?: string;
+        air_quality?: string | number;
+        air_quality_value?: number;
+        pm1?: number;
+        pm10?: number;
+        aq_percent?: number;
         humidity?: number;
         mist_level?: number;
         warm_level?: number;
@@ -73,9 +79,29 @@ export declare abstract class VeSyncFan extends VeSyncBaseDevice {
      */
     get childLock(): boolean;
     /**
-     * Get air quality (if supported)
+     * Get air quality level (if supported)
      */
-    get airQuality(): string;
+    get airQualityLevel(): string | number;
+    /**
+     * Get air quality (alias for airQualityLevel for backward compatibility)
+     */
+    get airQuality(): string | number;
+    /**
+     * Get air quality value - PM2.5 in μg/m³ (if supported)
+     */
+    get airQualityValue(): number;
+    /**
+     * Get PM1 value (if supported)
+     */
+    get pm1(): number;
+    /**
+     * Get PM10 value (if supported)
+     */
+    get pm10(): number;
+    /**
+     * Get air quality percentage (if supported)
+     */
+    get aqPercent(): number;
     /**
      * Get humidity level (if supported)
      */