tsvesync 1.0.11

package/dist/src/lib/vesyncBulb.d.ts

@@ -0,0 +1,79 @@
+/**
+ * VeSync Bulb Base Class
+ */
+import { VeSyncBaseDevice } from './vesyncBaseDevice';
+import { VeSync } from './vesync';
+/**
+ * VeSync Bulb Base Class
+ */
+export declare abstract class VeSyncBulb extends VeSyncBaseDevice {
+    protected brightness: number;
+    protected colorTemp: number;
+    protected colorValue: number;
+    protected colorHue: number;
+    protected colorSaturation: number;
+    protected colorMode: string;
+    protected features: string[];
+    protected rgbValues: {
+        red: number;
+        green: number;
+        blue: number;
+    };
+    constructor(details: Record<string, any>, manager: VeSync);
+    /**
+     * Get bulb details
+     */
+    getDetails(): Promise<void>;
+    /**
+     * Update bulb status
+     */
+    update(): Promise<void>;
+    /**
+     * Turn bulb on
+     */
+    turnOn(): Promise<boolean>;
+    /**
+     * Turn bulb off
+     */
+    turnOff(): Promise<boolean>;
+    /**
+     * Set bulb brightness
+     */
+    setBrightness(brightness: number): Promise<boolean>;
+    /**
+     * Get bulb brightness
+     */
+    getBrightness(): number;
+    /**
+     * Get color temperature in Kelvin
+     */
+    getColorTempKelvin(): number;
+    /**
+     * Get color temperature in percent
+     */
+    getColorTempPercent(): number;
+    /**
+     * Get color hue
+     */
+    getColorHue(): number;
+    /**
+     * Get color saturation
+     */
+    getColorSaturation(): number;
+    /**
+     * Get color value
+     */
+    getColorValue(): number;
+    /**
+     * Get RGB values
+     */
+    getRGBValues(): {
+        red: number;
+        green: number;
+        blue: number;
+    };
+    /**
+     * Set color temperature - Abstract method to be implemented by subclasses
+     */
+    abstract setColorTemp(colorTemp: number): Promise<boolean>;
+}

package/dist/src/lib/vesyncBulb.js

@@ -0,0 +1,198 @@
+"use strict";
+/**
+ * VeSync Bulb Base Class
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeSyncBulb = void 0;
+const vesyncBaseDevice_1 = require("./vesyncBaseDevice");
+const helpers_1 = require("./helpers");
+// Feature dictionary for bulb types
+const featureDict = {
+    'ESL100': {
+        features: ['dimmable'],
+        colorModel: 'none'
+    },
+    'ESL100CW': {
+        features: ['dimmable', 'color_temp'],
+        colorModel: 'none'
+    },
+    'XYD0001': {
+        features: ['dimmable', 'color_temp', 'rgb_shift'],
+        colorModel: 'hsv'
+    },
+    'ESL100MC': {
+        features: ['dimmable', 'rgb_shift'],
+        colorModel: 'rgb'
+    }
+};
+/**
+ * VeSync Bulb Base Class
+ */
+class VeSyncBulb extends vesyncBaseDevice_1.VeSyncBaseDevice {
+    constructor(details, manager) {
+        super(details, manager);
+        this.brightness = 0;
+        this.colorTemp = 0;
+        this.colorValue = 0;
+        this.colorHue = 0;
+        this.colorSaturation = 0;
+        this.colorMode = '';
+        this.features = featureDict[this.deviceType]?.features || [];
+        this.rgbValues = {
+            red: 0,
+            green: 0,
+            blue: 0
+        };
+    }
+    /**
+     * Get bulb details
+     */
+    async getDetails() {
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicedetail'),
+            uuid: this.cid,
+            method: 'devicedetail'
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/devicedetail', 'post', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if (response?.code === 0 && response?.result) {
+            this.deviceStatus = response.result.deviceStatus || this.deviceStatus;
+            this.brightness = response.result.brightness || this.brightness;
+            if (this.features.includes('color_temp')) {
+                this.colorTemp = response.result.colorTemp || this.colorTemp;
+            }
+            if (this.features.includes('rgb_shift')) {
+                if (featureDict[this.deviceType].colorModel === 'rgb') {
+                    this.rgbValues = {
+                        red: response.result.red || this.rgbValues.red,
+                        green: response.result.green || this.rgbValues.green,
+                        blue: response.result.blue || this.rgbValues.blue
+                    };
+                }
+                else {
+                    this.colorHue = response.result.hue || this.colorHue;
+                    this.colorSaturation = response.result.saturation || this.colorSaturation;
+                    this.colorValue = response.result.value || this.colorValue;
+                }
+            }
+        }
+    }
+    /**
+     * Update bulb status
+     */
+    async update() {
+        await this.getDetails();
+    }
+    /**
+     * Turn bulb on
+     */
+    async turnOn() {
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.cid,
+            status: 'on'
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/devicestatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if (response?.code === 0) {
+            this.deviceStatus = 'on';
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Turn bulb off
+     */
+    async turnOff() {
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.cid,
+            status: 'off'
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/devicestatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if (response?.code === 0) {
+            this.deviceStatus = 'off';
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Set bulb brightness
+     */
+    async setBrightness(brightness) {
+        if (!this.features.includes('dimmable')) {
+            return false;
+        }
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.cid,
+            status: 'on',
+            brightNess: brightness.toString()
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/updateBrightness', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if (response?.code === 0) {
+            this.brightness = brightness;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get bulb brightness
+     */
+    getBrightness() {
+        return this.brightness;
+    }
+    /**
+     * Get color temperature in Kelvin
+     */
+    getColorTempKelvin() {
+        if (!this.features.includes('color_temp')) {
+            return 0;
+        }
+        return ((6500 - 2700) * this.colorTemp / 100) + 2700;
+    }
+    /**
+     * Get color temperature in percent
+     */
+    getColorTempPercent() {
+        if (!this.features.includes('color_temp')) {
+            return 0;
+        }
+        return this.colorTemp;
+    }
+    /**
+     * Get color hue
+     */
+    getColorHue() {
+        if (!this.features.includes('rgb_shift')) {
+            return 0;
+        }
+        return this.colorHue;
+    }
+    /**
+     * Get color saturation
+     */
+    getColorSaturation() {
+        if (!this.features.includes('rgb_shift')) {
+            return 0;
+        }
+        return this.colorSaturation;
+    }
+    /**
+     * Get color value
+     */
+    getColorValue() {
+        if (!this.features.includes('rgb_shift')) {
+            return 0;
+        }
+        return this.colorValue;
+    }
+    /**
+     * Get RGB values
+     */
+    getRGBValues() {
+        if (!this.features.includes('rgb_shift') || featureDict[this.deviceType].colorModel !== 'rgb') {
+            return { red: 0, green: 0, blue: 0 };
+        }
+        return this.rgbValues;
+    }
+}
+exports.VeSyncBulb = VeSyncBulb;

package/dist/src/lib/vesyncBulbImpl.d.ts

@@ -0,0 +1,38 @@
+/**
+ * VeSync Bulb Implementations
+ */
+import { VeSyncBulb } from './vesyncBulb';
+import { VeSync } from './vesync';
+/**
+ * ESL100 Bulb Implementation
+ */
+export declare class VeSyncBulbESL100 extends VeSyncBulb {
+    constructor(details: Record<string, any>, manager: VeSync);
+    setColorTemp(colorTemp: number): Promise<boolean>;
+}
+/**
+ * ESL100CW Bulb Implementation
+ */
+export declare class VeSyncBulbESL100CW extends VeSyncBulb {
+    constructor(details: Record<string, any>, manager: VeSync);
+    setColorTemp(colorTemp: number): Promise<boolean>;
+}
+/**
+ * XYD0001 Bulb Implementation
+ */
+export declare class VeSyncBulbXYD0001 extends VeSyncBulb {
+    constructor(details: Record<string, any>, manager: VeSync);
+    setColorTemp(colorTemp: number): Promise<boolean>;
+    setHsv(hue: number, saturation: number, value: number): Promise<boolean>;
+    enableWhiteMode(): Promise<boolean>;
+}
+/**
+ * ESL100MC Bulb Implementation
+ */
+export declare class VeSyncBulbESL100MC extends VeSyncBulb {
+    constructor(details: Record<string, any>, manager: VeSync);
+    setColorTemp(colorTemp: number): Promise<boolean>;
+    setRgb(red: number, green: number, blue: number): Promise<boolean>;
+    enableWhiteMode(): Promise<boolean>;
+}
+export declare const bulbModules: Record<string, any>;

package/dist/src/lib/vesyncBulbImpl.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * VeSync Bulb Implementations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulbModules = exports.VeSyncBulbESL100MC = exports.VeSyncBulbXYD0001 = exports.VeSyncBulbESL100CW = exports.VeSyncBulbESL100 = void 0;
+const vesyncBulb_1 = require("./vesyncBulb");
+const helpers_1 = require("./helpers");
+/**
+ * ESL100 Bulb Implementation
+ */
+class VeSyncBulbESL100 extends vesyncBulb_1.VeSyncBulb {
+    constructor(details, manager) {
+        super(details, manager);
+    }
+    async setColorTemp(colorTemp) {
+        return false;
+    }
+}
+exports.VeSyncBulbESL100 = VeSyncBulbESL100;
+/**
+ * ESL100CW Bulb Implementation
+ */
+class VeSyncBulbESL100CW extends vesyncBulb_1.VeSyncBulb {
+    constructor(details, manager) {
+        super(details, manager);
+    }
+    async setColorTemp(colorTemp) {
+        if (!this.features.includes('color_temp')) {
+            return false;
+        }
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.cid,
+            status: 'on',
+            colorTemp: colorTemp.toString()
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/updateColorTemperature', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if (response?.code === 0) {
+            this.colorTemp = colorTemp;
+            return true;
+        }
+        return false;
+    }
+}
+exports.VeSyncBulbESL100CW = VeSyncBulbESL100CW;
+/**
+ * XYD0001 Bulb Implementation
+ */
+class VeSyncBulbXYD0001 extends vesyncBulb_1.VeSyncBulb {
+    constructor(details, manager) {
+        super(details, manager);
+    }
+    async setColorTemp(colorTemp) {
+        if (!this.features.includes('color_temp')) {
+            return false;
+        }
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.cid,
+            status: 'on',
+            colorTemp: colorTemp.toString()
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/updateColorTemperature', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if (response?.code === 0) {
+            this.colorTemp = colorTemp;
+            return true;
+        }
+        return false;
+    }
+    async setHsv(hue, saturation, value) {
+        if (!this.features.includes('rgb_shift')) {
+            return false;
+        }
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.cid,
+            status: 'on',
+            mode: 'color',
+            hue: Math.round(hue).toString(),
+            saturation: Math.round(saturation).toString(),
+            brightness: Math.round(value).toString()
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/updateColor', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if (response?.code === 0) {
+            this.colorHue = hue;
+            this.colorSaturation = saturation;
+            this.colorValue = value;
+            return true;
+        }
+        return false;
+    }
+    async enableWhiteMode() {
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.cid,
+            status: 'on',
+            colorMode: 'white'
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/updateColorMode', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if (response?.code === 0) {
+            this.colorMode = 'white';
+            return true;
+        }
+        return false;
+    }
+}
+exports.VeSyncBulbXYD0001 = VeSyncBulbXYD0001;
+/**
+ * ESL100MC Bulb Implementation
+ */
+class VeSyncBulbESL100MC extends vesyncBulb_1.VeSyncBulb {
+    constructor(details, manager) {
+        super(details, manager);
+    }
+    async setColorTemp(colorTemp) {
+        return false;
+    }
+    async setRgb(red, green, blue) {
+        if (!this.features.includes('rgb_shift')) {
+            return false;
+        }
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.cid,
+            status: 'on',
+            mode: 'color',
+            red: Math.round(red).toString(),
+            green: Math.round(green).toString(),
+            blue: Math.round(blue).toString()
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/updateColor', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if (response?.code === 0) {
+            this.rgbValues = { red, green, blue };
+            return true;
+        }
+        return false;
+    }
+    async enableWhiteMode() {
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.cid,
+            status: 'on',
+            colorMode: 'white'
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/updateColorMode', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if (response?.code === 0) {
+            this.colorMode = 'white';
+            return true;
+        }
+        return false;
+    }
+}
+exports.VeSyncBulbESL100MC = VeSyncBulbESL100MC;
+// Export the bulb modules dictionary
+exports.bulbModules = {
+    'ESL100': VeSyncBulbESL100,
+    'ESL100CW': VeSyncBulbESL100CW,
+    'XYD0001': VeSyncBulbXYD0001,
+    'ESL100MC': VeSyncBulbESL100MC
+};

package/dist/src/lib/vesyncFan.d.ts

@@ -0,0 +1,80 @@
+/**
+ * VeSync Fan Classes
+ */
+import { VeSyncBaseDevice } from './vesyncBaseDevice';
+import { VeSync } from './vesync';
+interface FanConfig {
+    [key: string]: {
+        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier';
+        features: string[];
+    };
+}
+export declare const fanConfig: FanConfig;
+/**
+ * Base class for VeSync Fans
+ */
+export declare abstract class VeSyncFan extends VeSyncBaseDevice {
+    protected details: Record<string, any>;
+    protected mode_dict: Record<string, any>;
+    protected speed_dict: Record<string, any>;
+    protected features: string[];
+    constructor(details: Record<string, any>, manager: VeSync);
+    /**
+     * Check if feature is supported
+     */
+    hasFeature(feature: string): boolean;
+    /**
+     * Get current mode
+     */
+    get mode(): string;
+    /**
+     * Get current speed
+     */
+    get speed(): number;
+    /**
+     * Get filter life percentage
+     */
+    get filterLife(): number;
+    /**
+     * Get screen status
+     */
+    get screenStatus(): string;
+    /**
+     * Get child lock status
+     */
+    get childLock(): string;
+    /**
+     * Get air quality (if supported)
+     */
+    get airQuality(): string;
+    /**
+     * Get humidity level (if supported)
+     */
+    get humidity(): number;
+    /**
+     * Get mist level (if supported)
+     */
+    get mistLevel(): number;
+    /**
+     * Get warm level (if supported)
+     */
+    get warmLevel(): number;
+    /**
+     * Get timer status
+     */
+    get timer(): number;
+    /**
+     * Return formatted device info to stdout
+     */
+    display(): void;
+    /**
+     * Return JSON details for fan
+     */
+    displayJSON(): string;
+    abstract getDetails(): Promise<void>;
+    abstract turnOn(): Promise<boolean>;
+    abstract turnOff(): Promise<boolean>;
+    abstract changeFanSpeed(speed: number): Promise<boolean>;
+    abstract setMode(mode: string): Promise<boolean>;
+}
+export {};