homebridge-tuya-without-developer-account 1.0.0

package/dist/shared/accessories/characteristic/Light.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureLight = configureLight;
+const color_1 = require("../../util/color");
+const util_1 = require("../../util/util");
+const On_1 = require("./On");
+const DEFAULT_COLOR_TEMPERATURE_KELVIN = 6500;
+var LightType;
+(function (LightType) {
+    LightType["Unknown"] = "Unknown";
+    LightType["Normal"] = "Normal";
+    LightType["C"] = "C";
+    LightType["CW"] = "CW";
+    LightType["RGB"] = "RGB";
+    LightType["RGBC"] = "RGBC";
+    LightType["RGBCW"] = "RGBCW";
+})(LightType || (LightType = {}));
+function getLightType(accessory, on, bright, temp, color, mode) {
+    const modeRange = mode && mode.property.range;
+    const { h, s, v } = (color?.property || {});
+    let lightType;
+    if (on && bright && temp && h && s && v && modeRange && modeRange.includes('colour') && modeRange.includes('white')) {
+        lightType = LightType.RGBCW;
+    }
+    else if (on && bright && !temp && h && s && v && modeRange && modeRange.includes('colour') && modeRange.includes('white')) {
+        lightType = LightType.RGBC;
+    }
+    else if (on && !temp && h && s && v) {
+        lightType = LightType.RGB;
+    }
+    else if (on && bright && temp) {
+        lightType = LightType.CW;
+    }
+    else if (on && bright && !temp) {
+        lightType = LightType.C;
+    }
+    else if (on && !bright && !temp) {
+        lightType = LightType.Normal;
+    }
+    else {
+        lightType = LightType.Unknown;
+    }
+    return lightType;
+}
+function getColorValue(accessory, schema) {
+    const status = accessory.getStatus(schema.code);
+    if (!status || !status.value || status.value === '' || status.value === '{}') {
+        return { h: 0, s: 0, v: 0 };
+    }
+    const { h, s, v } = JSON.parse(status.value);
+    return {
+        h: h,
+        s: s,
+        v: v,
+    };
+}
+function inWhiteMode(accessory, lightType, modeSchema) {
+    if (lightType === LightType.C || lightType === LightType.CW) {
+        return true;
+    }
+    else if (lightType === LightType.RGB) {
+        return false;
+    }
+    if (!modeSchema) {
+        return false;
+    }
+    const status = accessory.getStatus(modeSchema.code);
+    return (status.value === 'white');
+}
+function inColorMode(accessory, lightType, modeSchema) {
+    if (lightType === LightType.RGB) {
+        return true;
+    }
+    else if (lightType === LightType.C || lightType === LightType.CW) {
+        return false;
+    }
+    if (!modeSchema) {
+        return false;
+    }
+    const status = accessory.getStatus(modeSchema.code);
+    return (status.value === 'colour');
+}
+function configureBrightness(accessory, service, lightType, brightSchema, colorSchema, modeSchema) {
+    service.getCharacteristic(accessory.Characteristic.Brightness)
+        .onGet(() => {
+        if (inColorMode(accessory, lightType, modeSchema) && colorSchema) {
+            // Color mode, get brightness from `color_data.v`
+            const { max } = colorSchema.property.v;
+            const colorValue = getColorValue(accessory, colorSchema);
+            const value = Math.round(100 * colorValue.v / max);
+            return (0, util_1.limit)(value, 0, 100);
+        }
+        else if (inWhiteMode(accessory, lightType, modeSchema) && brightSchema) {
+            // White mode, get brightness from `brightness_value`
+            const { max } = brightSchema.property;
+            const status = accessory.getStatus(brightSchema.code);
+            const value = Math.round(100 * status.value / max);
+            return (0, util_1.limit)(value, 0, 100);
+        }
+        else {
+            // Unsupported mode
+            return 100;
+        }
+    })
+        .onSet(async (value) => {
+        accessory.log.debug(`Characteristic.Brightness set to: ${value}`);
+        if (inColorMode(accessory, lightType, modeSchema) && colorSchema) {
+            // Color mode, set brightness to `color_data.v`
+            const { min, max } = colorSchema.property.v;
+            const colorValue = getColorValue(accessory, colorSchema);
+            colorValue.v = Math.round(value * max / 100);
+            colorValue.v = (0, util_1.limit)(colorValue.v, min, max);
+            await accessory.sendCommands([{ code: colorSchema.code, value: JSON.stringify(colorValue) }], true);
+        }
+        else if (inWhiteMode(accessory, lightType, modeSchema) && brightSchema) {
+            // White mode, set brightness to `brightness_value`
+            const { min, max } = brightSchema.property;
+            let brightValue = Math.round(value * max / 100);
+            brightValue = (0, util_1.limit)(brightValue, min, max);
+            await accessory.sendCommands([{ code: brightSchema.code, value: brightValue }], true);
+        }
+        else {
+            // Unsupported mode
+            accessory.log.warn('Neither color mode nor white mode.');
+        }
+    });
+}
+function configureColourTemperature(accessory, service, lightType, tempSchema, modeSchema) {
+    const props = { minValue: 140, maxValue: 500, minStep: 1 };
+    if (lightType === LightType.RGBC) {
+        props.minValue = props.maxValue = Math.round((0, color_1.kelvinToMired)(DEFAULT_COLOR_TEMPERATURE_KELVIN));
+    }
+    accessory.log.debug('Set props for ColorTemperature:', props);
+    service.getCharacteristic(accessory.Characteristic.ColorTemperature)
+        .onGet(() => {
+        if (lightType === LightType.RGBC) {
+            return props.minValue;
+        }
+        // const schema = accessory.getSchema(...SCHEMA_CODE.COLOR_TEMP)!;
+        const { min, max } = tempSchema.property;
+        const status = accessory.getStatus(tempSchema.code);
+        const kelvin = (0, util_1.remap)(status.value, min, max, (0, color_1.miredToKelvin)(props.maxValue), (0, color_1.miredToKelvin)(props.minValue));
+        const mired = Math.round((0, color_1.kelvinToMired)(kelvin));
+        return (0, util_1.limit)(mired, props.minValue, props.maxValue);
+    })
+        .onSet(async (value) => {
+        accessory.log.debug(`Characteristic.ColorTemperature set to: ${value}`);
+        const commands = [];
+        if (modeSchema) {
+            commands.push({ code: modeSchema.code, value: 'white' });
+        }
+        if (lightType !== LightType.RGBC) {
+            const { min, max } = tempSchema.property;
+            const kelvin = (0, color_1.miredToKelvin)(value);
+            const temp = Math.round((0, util_1.remap)(kelvin, (0, color_1.miredToKelvin)(props.maxValue), (0, color_1.miredToKelvin)(props.minValue), min, max));
+            commands.push({ code: tempSchema.code, value: temp });
+        }
+        await accessory.sendCommands(commands, true);
+    })
+        .setProps(props);
+}
+function configureHue(accessory, service, lightType, colorSchema, modeSchema) {
+    const { min, max } = colorSchema.property.h;
+    service.getCharacteristic(accessory.Characteristic.Hue)
+        .onGet(() => {
+        if (inWhiteMode(accessory, lightType, modeSchema)) {
+            return (0, color_1.kelvinToHSV)(DEFAULT_COLOR_TEMPERATURE_KELVIN).h;
+        }
+        const hue = Math.round(360 * getColorValue(accessory, colorSchema).h / max);
+        return (0, util_1.limit)(hue, 0, 360);
+    })
+        .onSet(async (value) => {
+        accessory.log.debug(`Characteristic.Hue set to: ${value}`);
+        const colorValue = getColorValue(accessory, colorSchema);
+        colorValue.h = Math.round(value * max / 360);
+        colorValue.h = (0, util_1.limit)(colorValue.h, min, max);
+        const commands = [{
+                code: colorSchema.code,
+                value: JSON.stringify(colorValue),
+            }];
+        if (modeSchema) {
+            commands.push({ code: modeSchema.code, value: 'colour' });
+        }
+        await accessory.sendCommands(commands, true);
+    });
+}
+function configureSaturation(accessory, service, lightType, colorSchema, modeSchema) {
+    const { min, max } = colorSchema.property.s;
+    service.getCharacteristic(accessory.Characteristic.Saturation)
+        .onGet(() => {
+        if (inWhiteMode(accessory, lightType, modeSchema)) {
+            return (0, color_1.kelvinToHSV)(DEFAULT_COLOR_TEMPERATURE_KELVIN).s;
+        }
+        const saturation = Math.round(100 * getColorValue(accessory, colorSchema).s / max);
+        return (0, util_1.limit)(saturation, 0, 100);
+    })
+        .onSet(async (value) => {
+        accessory.log.debug(`Characteristic.Saturation set to: ${value}`);
+        const colorValue = getColorValue(accessory, colorSchema);
+        colorValue.s = Math.round(value * max / 100);
+        colorValue.s = (0, util_1.limit)(colorValue.s, min, max);
+        const commands = [{
+                code: colorSchema.code,
+                value: JSON.stringify(colorValue),
+            }];
+        if (modeSchema) {
+            commands.push({ code: modeSchema.code, value: 'colour' });
+        }
+        await accessory.sendCommands(commands, true);
+    });
+}
+function configureLight(accessory, service, onSchema, brightSchema, tempSchema, colorSchema, modeSchema) {
+    if (!onSchema) {
+        return;
+    }
+    if (!service) {
+        service = accessory.accessory.getService(accessory.Service.Lightbulb)
+            || accessory.accessory.addService(accessory.Service.Lightbulb, accessory.accessory.displayName + ' Light');
+    }
+    const lightType = getLightType(accessory, onSchema, brightSchema, tempSchema, colorSchema, modeSchema);
+    accessory.log.info('Light type:', lightType);
+    switch (lightType) {
+        case LightType.Normal:
+            (0, On_1.configureOn)(accessory, service, onSchema);
+            break;
+        case LightType.C:
+            (0, On_1.configureOn)(accessory, service, onSchema);
+            configureBrightness(accessory, service, lightType, brightSchema, colorSchema, modeSchema);
+            break;
+        case LightType.CW:
+            (0, On_1.configureOn)(accessory, service, onSchema);
+            configureBrightness(accessory, service, lightType, brightSchema, colorSchema, modeSchema);
+            configureColourTemperature(accessory, service, lightType, tempSchema, modeSchema);
+            break;
+        case LightType.RGB:
+            (0, On_1.configureOn)(accessory, service, onSchema);
+            configureBrightness(accessory, service, lightType, brightSchema, colorSchema, modeSchema);
+            configureHue(accessory, service, lightType, colorSchema, modeSchema);
+            configureSaturation(accessory, service, lightType, colorSchema, modeSchema);
+            break;
+        case LightType.RGBC:
+        case LightType.RGBCW:
+            (0, On_1.configureOn)(accessory, service, onSchema);
+            configureBrightness(accessory, service, lightType, brightSchema, colorSchema, modeSchema);
+            configureColourTemperature(accessory, service, lightType, tempSchema, modeSchema);
+            configureHue(accessory, service, lightType, colorSchema, modeSchema);
+            configureSaturation(accessory, service, lightType, colorSchema, modeSchema);
+            break;
+    }
+    configureAdaptiveLighting(accessory, service, brightSchema, tempSchema);
+}
+function configureAdaptiveLighting(accessory, service, brightSchema, tempSchema) {
+    const config = accessory.platform.getDeviceConfig(accessory.device);
+    if (!config || config.adaptiveLighting !== true) {
+        accessory.log.info('Adaptive Lighting disabled.');
+        return;
+    }
+    accessory.log.info('Adaptive Lighting enabled.');
+    if (!brightSchema || !tempSchema) {
+        accessory.log.warn('Adaptive Lighting not supported. Missing brightness or color temperature schema.');
+        return;
+    }
+    const { AdaptiveLightingController } = accessory.platform.api.hap;
+    const controller = new AdaptiveLightingController(service);
+    accessory.accessory.configureController(controller);
+    accessory.adaptiveLightingController = controller;
+}
+//# sourceMappingURL=Light.js.map

package/dist/shared/accessories/characteristic/LightSensor.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureLightSensor = configureLightSensor;
+const util_1 = require("../../util/util");
+function configureLightSensor(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    if (!service) {
+        service = accessory.accessory.getService(accessory.Service.LightSensor)
+            || accessory.accessory.addService(accessory.Service.LightSensor);
+    }
+    const property = schema.property || {};
+    const props = (0, util_1.toHapProperty)(property);
+    const multiple = Math.pow(10, property['scale'] || 0);
+    service.getCharacteristic(accessory.Characteristic.CurrentAmbientLightLevel)
+        .onGet(() => {
+        const status = accessory.getStatus(schema.code);
+        return (0, util_1.limit)(status.value / multiple, props['minValue'], props['maxValue']);
+    })
+        .setProps(props);
+}
+//# sourceMappingURL=LightSensor.js.map

package/dist/shared/accessories/characteristic/LockPhysicalControls.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureLockPhysicalControls = configureLockPhysicalControls;
+function configureLockPhysicalControls(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    const { CONTROL_LOCK_DISABLED, CONTROL_LOCK_ENABLED } = accessory.Characteristic.LockPhysicalControls;
+    service.getCharacteristic(accessory.Characteristic.LockPhysicalControls)
+        .onGet(() => {
+        const status = accessory.getStatus(schema.code);
+        return status.value ? CONTROL_LOCK_ENABLED : CONTROL_LOCK_DISABLED;
+    })
+        .onSet(async (value) => {
+        await accessory.sendCommands([{
+                code: schema.code,
+                value: (value === CONTROL_LOCK_ENABLED) ? true : false,
+            }], true);
+    });
+}
+//# sourceMappingURL=LockPhysicalControls.js.map

package/dist/shared/accessories/characteristic/MotionDetected.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureMotionDetected = configureMotionDetected;
+const TuyaDevice_1 = require("../../../cloud/device/TuyaDevice");
+function configureMotionDetected(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    if (!service) {
+        service = accessory.accessory.getService(accessory.Service.MotionSensor)
+            || accessory.accessory.addService(accessory.Service.MotionSensor);
+    }
+    service.getCharacteristic(accessory.Characteristic.MotionDetected)
+        .onGet(() => {
+        const status = accessory.getStatus(schema.code);
+        if (schema.type === TuyaDevice_1.TuyaDeviceSchemaType.Enum) { // pir
+            return (status.value === 'pir');
+        }
+        return false;
+    });
+}
+//# sourceMappingURL=MotionDetected.js.map

package/dist/shared/accessories/characteristic/Name.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureName = configureName;
+const util_1 = require("../../util/util");
+function configureName(accessory, service, name) {
+    const fallbackName = name.replace(/[^A-Za-z0-9 '\s]/g, ' ').replace(/\s+/g, ' ').trim();
+    const safeName = (0, util_1.sanitizeName)(name) ?? (fallbackName || 'Tuya Service');
+    service.setCharacteristic(accessory.Characteristic.Name, safeName);
+    if (!service.testCharacteristic(accessory.Characteristic.ConfiguredName)) {
+        service.addOptionalCharacteristic(accessory.Characteristic.ConfiguredName); // silence warning
+    }
+    // update every time so cached invalid names get corrected on restart
+    service.setCharacteristic(accessory.Characteristic.ConfiguredName, safeName);
+}
+//# sourceMappingURL=Name.js.map

package/dist/shared/accessories/characteristic/OccupancyDetected.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureOccupancyDetected = configureOccupancyDetected;
+function configureOccupancyDetected(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    if (!service) {
+        service = accessory.accessory.getService(accessory.Service.OccupancySensor)
+            || accessory.accessory.addService(accessory.Service.OccupancySensor);
+    }
+    const { OCCUPANCY_DETECTED, OCCUPANCY_NOT_DETECTED } = accessory.Characteristic.OccupancyDetected;
+    service.getCharacteristic(accessory.Characteristic.OccupancyDetected)
+        .onGet(() => {
+        const status = accessory.getStatus(schema.code);
+        return (status.value === 'presence') ? OCCUPANCY_DETECTED : OCCUPANCY_NOT_DETECTED;
+    });
+}
+//# sourceMappingURL=OccupancyDetected.js.map

package/dist/shared/accessories/characteristic/On.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureOn = configureOn;
+function configureOn(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    if (!service) {
+        service = accessory.accessory.getService(schema.code)
+            || accessory.accessory.addService(accessory.Service.Switch, schema.code, schema.code);
+    }
+    service.getCharacteristic(accessory.Characteristic.On)
+        .onGet(() => {
+        accessory.checkOnlineStatus();
+        const status = accessory.getStatus(schema.code);
+        return status?.value ?? false;
+    })
+        .onSet(async (value) => {
+        await accessory.sendCommands([{
+                code: schema.code,
+                value: value,
+            }], true);
+    });
+}
+//# sourceMappingURL=On.js.map

package/dist/shared/accessories/characteristic/OutletInUse.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureOutletInUse = configureOutletInUse;
+function configureOutletInUse(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    const test = accessory.getStatus(schema.code)?.value;
+    service?.getCharacteristic(accessory.Characteristic.OutletInUse)
+        .onGet(() => {
+        return test ? true : false;
+    });
+}
+//# sourceMappingURL=OutletInUse.js.map

package/dist/shared/accessories/characteristic/ProgrammableSwitchEvent.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureProgrammableSwitchEvent = configureProgrammableSwitchEvent;
+exports.onProgrammableSwitchEvent = onProgrammableSwitchEvent;
+const TuyaDevice_1 = require("../../../cloud/device/TuyaDevice");
+const SINGLE_PRESS = 0;
+const DOUBLE_PRESS = 1;
+const LONG_PRESS = 2;
+function configureProgrammableSwitchEvent(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    let props;
+    if (schema.type === TuyaDevice_1.TuyaDeviceSchemaType.Enum) {
+        const { range } = schema.property;
+        props = GetStatelessSwitchProps(range.includes('click') || range.includes('single_click') || range.includes('1'), range.includes('double_click'), range.includes('press') || range.includes('long_press'));
+    }
+    else {
+        props = GetStatelessSwitchProps(true, false, false);
+    }
+    service.getCharacteristic(accessory.Characteristic.ProgrammableSwitchEvent)
+        .setProps(props);
+}
+function onProgrammableSwitchEvent(accessory, service, status) {
+    if (!accessory.initialized) {
+        return;
+    }
+    let value;
+    const schema = accessory.getSchema(status.code);
+    if (schema.type === TuyaDevice_1.TuyaDeviceSchemaType.Raw || schema.type === TuyaDevice_1.TuyaDeviceSchemaType.String) { // doorbell_pic or alarm_message
+        const url = Buffer.from(status.value, 'base64').toString('binary');
+        if (url.length === 0) {
+            return;
+        }
+        accessory.log.info('Alarm message:', url);
+        value = SINGLE_PRESS;
+    }
+    else if (schema.type === TuyaDevice_1.TuyaDeviceSchemaType.Enum) {
+        if (status.value === 'click' || status.value === 'single_click' || status.value === '1') {
+            value = SINGLE_PRESS;
+        }
+        else if (status.value === 'double_click') {
+            value = DOUBLE_PRESS;
+        }
+        else if (status.value === 'press' || status.value === 'long_press') {
+            value = LONG_PRESS;
+        }
+    }
+    else if (schema.type === TuyaDevice_1.TuyaDeviceSchemaType.Integer) {
+        if (status.value > 0) {
+            value = SINGLE_PRESS;
+        }
+    }
+    if (value === undefined) {
+        accessory.log.warn('Unknown ProgrammableSwitchEvent status:', status);
+        return;
+    }
+    accessory.log.debug('ProgrammableSwitchEvent updateValue: %o %o', status.code, value);
+    service.getCharacteristic(accessory.Characteristic.ProgrammableSwitchEvent)
+        .updateValue(value);
+}
+// Modified version of
+// https://github.com/benzman81/homebridge-http-webhooks/blob/master/src/homekit/accessories/HttpWebHookStatelessSwitchAccessory.js
+function GetStatelessSwitchProps(single_press, double_press, long_press) {
+    const props = {};
+    if (single_press) {
+        props.minValue = SINGLE_PRESS;
+    }
+    else if (double_press) {
+        props.minValue = DOUBLE_PRESS;
+    }
+    else if (long_press) {
+        props.minValue = LONG_PRESS;
+    }
+    if (single_press) {
+        props.maxValue = SINGLE_PRESS;
+    }
+    if (double_press) {
+        props.maxValue = DOUBLE_PRESS;
+    }
+    if (long_press) {
+        props.maxValue = LONG_PRESS;
+    }
+    if (single_press && !double_press && long_press) {
+        props.validValues = [SINGLE_PRESS, LONG_PRESS];
+    }
+    return props;
+}
+//# sourceMappingURL=ProgrammableSwitchEvent.js.map

package/dist/shared/accessories/characteristic/RelativeHumidityDehumidifierThreshold.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureRelativeHumidityDehumidifierThreshold = configureRelativeHumidityDehumidifierThreshold;
+const util_1 = require("../../util/util");
+function configureRelativeHumidityDehumidifierThreshold(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    const property = schema.property;
+    const multiple = Math.pow(10, property.scale);
+    const props = {
+        minValue: 0,
+        maxValue: 100,
+        minStep: Math.max(1, property.step / multiple),
+    };
+    accessory.log.debug('Set props for RelativeHumidityDehumidifierThreshold:', props);
+    service.getCharacteristic(accessory.Characteristic.RelativeHumidityDehumidifierThreshold)
+        .onGet(() => {
+        const status = accessory.getStatus(schema.code);
+        return (0, util_1.limit)(status.value / multiple, 0, 100);
+    })
+        .onSet(async (value) => {
+        const dehumidity_set = (0, util_1.limit)(value * multiple, property.min, property.max);
+        await accessory.sendCommands([{ code: schema.code, value: dehumidity_set }]);
+    })
+        .setProps(props);
+}
+//# sourceMappingURL=RelativeHumidityDehumidifierThreshold.js.map

package/dist/shared/accessories/characteristic/RotationSpeed.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureRotationSpeed = configureRotationSpeed;
+exports.configureRotationSpeedLevel = configureRotationSpeedLevel;
+exports.configureRotationSpeedOn = configureRotationSpeedOn;
+const util_1 = require("../../util/util");
+function configureRotationSpeed(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    const property = schema.property;
+    const multiple = Math.pow(10, property.scale);
+    const props = {
+        minValue: property.min / multiple,
+        maxValue: property.max / multiple,
+        minStep: Math.max(1, property.step / multiple),
+    };
+    service.getCharacteristic(accessory.Characteristic.RotationSpeed)
+        .onGet(() => {
+        const status = accessory.getStatus(schema.code);
+        const value = status.value / multiple;
+        return (0, util_1.limit)(value, props.minValue, props.maxValue);
+    })
+        .onSet(async (value) => {
+        const speed = value * multiple;
+        await accessory.sendCommands([{ code: schema.code, value: speed }], true);
+    })
+        .setProps(props);
+}
+function configureRotationSpeedLevel(accessory, service, schema, ignoreValues) {
+    if (!schema) {
+        return;
+    }
+    const property = schema.property;
+    const range = [];
+    for (const value of property.range) {
+        if (ignoreValues?.includes(value)) {
+            continue;
+        }
+        range.push(value);
+    }
+    const props = { minValue: 0, maxValue: range.length, minStep: 1, unit: 'speed' };
+    accessory.log.debug('Set props for RotationSpeed:', props);
+    const onGetHandler = () => {
+        const status = accessory.getStatus(schema.code);
+        const index = range.indexOf(status.value);
+        return (0, util_1.limit)(index + 1, props.minValue, props.maxValue);
+    };
+    service.getCharacteristic(accessory.Characteristic.RotationSpeed)
+        .onGet(onGetHandler)
+        .onSet(async (value) => {
+        accessory.log.debug('Set RotationSpeed to:', value);
+        const index = Math.round(value - 1);
+        if (index < 0 || index >= range.length) {
+            accessory.log.debug('Out of range, return.');
+            return;
+        }
+        const speedLevel = range[index].toString();
+        accessory.log.debug('Set RotationSpeedLevel to:', speedLevel);
+        await accessory.sendCommands([{ code: schema.code, value: speedLevel }], true);
+    })
+        .updateValue(onGetHandler()) // ensure the value is correct before set props
+        .setProps(props);
+}
+function configureRotationSpeedOn(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    const props = { minValue: 0, maxValue: 100, minStep: 100 };
+    accessory.log.debug('Set props for RotationSpeed:', props);
+    service.getCharacteristic(accessory.Characteristic.RotationSpeed)
+        .onGet(() => {
+        const status = accessory.getStatus(schema.code);
+        return status.value ? 100 : 0;
+    })
+        .setProps(props);
+}
+//# sourceMappingURL=RotationSpeed.js.map