@willieee802/zigbee-herdsman-converters 19.44.0 → 19.44.2

package/dist/lib/ewelink.js

@@ -0,0 +1,722 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modernExtend = exports.ewelinkModernExtend = exports.ewelinkFromZigbee = exports.ewelinkToZigbee = void 0;
+const exposes_1 = require("./exposes");
+const modernExtend_1 = require("./modernExtend");
+const utils = __importStar(require("./utils"));
+const e = exposes_1.presets;
+const ea = exposes_1.access;
+// ====================== Type Or Interface ==============================
+// ======================= Utils =========================================
+const findKeyByValue = (object, value) => {
+    const entry = Object.entries(object).find(([key, val]) => val === value);
+    return entry ? entry[0] : undefined;
+};
+// ======================= Custom TZ =====================================
+exports.ewelinkToZigbee = {
+    motor_direction: {
+        key: ["motor_direction"],
+        convertSet: async (entity, key, value, meta) => {
+            // biome-ignore lint/suspicious/noImplicitAnyLet: ignored using `--suppress`
+            let windowCoveringMode;
+            if (value === "forward") {
+                windowCoveringMode = 0x00;
+            }
+            else if (value === "reverse") {
+                windowCoveringMode = 0x01;
+            }
+            await entity.write("closuresWindowCovering", { windowCoveringMode }, utils.getOptions(meta.mapped, entity));
+            return { state: { motor_direction: value } };
+        },
+    },
+};
+// ======================= Custom FZ =====================================
+exports.ewelinkFromZigbee = {
+    motor_direction: {
+        cluster: "closuresWindowCovering",
+        type: ["attributeReport", "readResponse"],
+        options: [exposes_1.options.invert_cover()],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (typeof msg.data === "object" && Object.hasOwn(msg.data, "windowCoveringMode")) {
+                result.motor_direction = (msg.data.windowCoveringMode & (1 << 0)) > 0 === true ? "reverse" : "forward";
+            }
+            return result;
+        },
+    },
+};
+// ======================= Custom Extend =================================
+function privateMotorClbByPosition(clusterName, writeCommand) {
+    const protocol = {
+        dooya: {
+            supportModel: ["CK-MG22-Z310EE07DOOYA-01(7015)", "MYDY25Z-1", "CK-MG22-JLDJ-01(7015)"],
+            mapping: {
+                open: 0x01,
+                close: 0x02,
+                other: 0x03,
+                clear: 0x10,
+            },
+            updateMotorClbCommand: {
+                privateCmd: 0x01,
+                subCmd: 0x09,
+            },
+            updatedMotorClbCommand: {
+                privateCmd: 0x01,
+                subCmd: 0x09,
+            },
+            deleteMotorClbCommand: {
+                privateCmd: 0x01,
+                subCmd: 0x0b,
+            },
+            deletedMotorClbCommand: {
+                privateCmd: 0x01,
+                subCmd: 0x0b,
+            },
+        },
+        raex: {
+            supportModel: ["MYRX25Z-1"],
+            mapping: {
+                open: 0x01,
+                close: 0x02,
+                clear: 0x01,
+            },
+            updateMotorClbCommand: {
+                privateCmd: 0x22,
+                dataLength: 0x02,
+                subCmd: 0x71,
+            },
+            deleteMotorClbCommand: {
+                privateCmd: 0x22,
+                dataLength: 0x02,
+                subCmd: 0x76,
+            },
+        },
+        ak: {
+            supportModel: ["AM25B-1-25-ES-E-Z", "ZM25-EAZ", "AM25C-1-25-ES-E-Z"],
+            mapping: {
+                open: 0x00,
+                close: 0x01,
+                clear: 0x02,
+            },
+            // AK Protocol setting the limit and clearing the limit use the same command.
+            updateMotorClbCommand: {
+                cmdType: 0x00,
+                privateCmd: 0x68,
+                dataType: 0x04,
+                dataLength: [0x00, 0x01],
+            },
+            updatedMotorClbCommand: {
+                cmdType: 0x01,
+                privateCmd: 0x68,
+                dataType: 0x04,
+            },
+        },
+    };
+    const exposes = [];
+    exposes.push(e.enum("motor_clb_position", ea.SET, ["open", "close", "other", "clear"]).withDescription("Motor Calibration By Position"));
+    exposes.push(e.text("motor_clb_position_result", ea.STATE).withDescription("Motor Calibration Result"));
+    const fromZigbee = [
+        {
+            cluster: clusterName,
+            type: ["raw"],
+            convert: (model, msg, publish, options, meta) => {
+                if (msg.type === "raw" && msg.data instanceof Buffer) {
+                    // Raex Protocol，updated Report only through 'motor_info'.
+                    if (protocol.dooya.supportModel.includes(model.model)) {
+                        const bufferObj = msg.data.subarray(3, msg.data.length).toJSON(); // The first five bytes belong to the ZCL frame header, which are not of interest here; only the payload is extracted.
+                        const payload = bufferObj.data;
+                        const { privateCmd: updatedPrivateCmd, subCmd: updatedPrivateSubCmd } = protocol.dooya.updatedMotorClbCommand;
+                        const { privateCmd: deletedPrivateCmd, subCmd: deletedPrivateSubCmd } = protocol.dooya.deletedMotorClbCommand;
+                        if (payload[0] === updatedPrivateCmd && payload[1] === updatedPrivateSubCmd) {
+                            const entities = Object.entries(protocol.dooya.mapping);
+                            const motor_clb_position_result = {};
+                            for (const entity of entities) {
+                                if (entity[1] === payload[2]) {
+                                    motor_clb_position_result[entity[0]] = "calibrated";
+                                    break;
+                                }
+                            }
+                            return {
+                                motor_clb_position_result,
+                            };
+                        }
+                        if (payload[0] === deletedPrivateCmd && payload[1] === deletedPrivateSubCmd) {
+                            if (payload[2] === protocol.dooya.mapping.clear) {
+                                const motor_clb_position_result = {
+                                    open: "uncalibrated",
+                                    close: "uncalibrated",
+                                    other: "uncalibrated",
+                                };
+                                return {
+                                    motor_clb_position_result,
+                                };
+                            }
+                        }
+                    }
+                    else if (protocol.ak.supportModel.includes(model.model)) {
+                        const bufferObj = msg.data.subarray(3, msg.data.length).toJSON(); // The first five bytes belong to the ZCL frame header, which are not of interest here; only the payload is extracted.
+                        const payload = bufferObj.data;
+                        const { cmdType, privateCmd, dataType } = protocol.ak.updatedMotorClbCommand;
+                        if (payload[0] === cmdType && payload[2] === privateCmd && payload[3] === dataType) {
+                            if (payload[6] === protocol.ak.mapping.clear) {
+                                const motor_clb_position_result = {
+                                    open: "uncalibrated",
+                                    close: "uncalibrated",
+                                    other: "uncalibrated",
+                                };
+                                return {
+                                    motor_clb_position_result,
+                                };
+                            }
+                            const entities = Object.entries(protocol.ak.mapping);
+                            const motor_clb_position_result = {};
+                            for (const entity of entities) {
+                                if (entity[1] === payload[6]) {
+                                    motor_clb_position_result[entity[0]] = "calibrated";
+                                    break;
+                                }
+                            }
+                            return {
+                                motor_clb_position_result,
+                            };
+                        }
+                    }
+                }
+            },
+        },
+    ];
+    const toZigbee = [
+        {
+            key: ["motor_clb_position"],
+            convertSet: async (entity, key, value, meta) => {
+                utils.assertEndpoint(entity);
+                const device = entity.getDevice();
+                const modelID = device.modelID;
+                if (protocol.dooya.supportModel.includes(modelID)) {
+                    const { deleteMotorClbCommand, updateMotorClbCommand, mapping } = protocol.dooya;
+                    // Dooya Protocol
+                    const payloadValue = [];
+                    if (value === "clear") {
+                        // Clear limit position
+                        payloadValue[0] = deleteMotorClbCommand.privateCmd;
+                        payloadValue[1] = deleteMotorClbCommand.subCmd;
+                        payloadValue[2] = mapping[value];
+                    }
+                    else if (["open", "close", "other"].includes(value)) {
+                        // Set limit position
+                        payloadValue[0] = updateMotorClbCommand.privateCmd;
+                        payloadValue[1] = updateMotorClbCommand.subCmd;
+                        payloadValue[2] = mapping[value];
+                    }
+                    await entity.command(clusterName, writeCommand, { data: payloadValue });
+                }
+                else if (protocol.raex.supportModel.includes(modelID)) {
+                    const { deleteMotorClbCommand, updateMotorClbCommand, mapping } = protocol.raex;
+                    // Raex Protocol
+                    const payloadValue = [];
+                    if (value === "clear") {
+                        // Clear limit position
+                        payloadValue[0] = deleteMotorClbCommand.privateCmd;
+                        payloadValue[1] = deleteMotorClbCommand.dataLength;
+                        payloadValue[2] = deleteMotorClbCommand.subCmd;
+                        payloadValue[3] = mapping[value];
+                    }
+                    else if (["open", "close", "other"].includes(value)) {
+                        // Set limit position
+                        payloadValue[0] = updateMotorClbCommand.privateCmd;
+                        payloadValue[1] = updateMotorClbCommand.dataLength;
+                        payloadValue[2] = updateMotorClbCommand.subCmd;
+                        payloadValue[3] = mapping[value];
+                    }
+                    await entity.command(clusterName, writeCommand, { data: payloadValue });
+                }
+                else if (protocol.ak.supportModel.includes(modelID)) {
+                    // AK Protocol
+                    const { updateMotorClbCommand, mapping } = protocol.ak;
+                    const payloadValue = [];
+                    payloadValue[0] = updateMotorClbCommand.cmdType;
+                    payloadValue[1] = 0x00;
+                    payloadValue[2] = updateMotorClbCommand.privateCmd;
+                    payloadValue[3] = updateMotorClbCommand.dataType;
+                    payloadValue.push(...updateMotorClbCommand.dataLength);
+                    payloadValue[6] = mapping[value];
+                    await entity.command(clusterName, writeCommand, { data: payloadValue });
+                }
+                return { state: { [key]: value } };
+            },
+        },
+    ];
+    return { exposes, toZigbee, fromZigbee, isModernExtend: true };
+}
+function privateMotorMode(clusterName, writeCommand) {
+    const mode = ["inching", "continuou"];
+    const protocol = {
+        dooya: {
+            supportModel: ["CK-MG22-Z310EE07DOOYA-01(7015)", "MYDY25Z-1", "CK-MG22-JLDJ-01(7015)"],
+            mapping: {
+                continuou: 0x20,
+                inching: 0x30,
+            },
+            updateMotorModeCommand: {
+                privateCmd: 0x01,
+                subCmd: 0x10,
+            },
+            updatedMotorModeCommand: {
+                privateCmd: 0x01,
+                subCmd: 0x10,
+            },
+        },
+        raex: {
+            supportModel: ["MYRX25Z-1"],
+            mapping: {
+                continuou: 0x01,
+                inching: 0x02,
+            },
+            updateMotorModeCommand: {
+                privateCmd: 0x11,
+                dataLength: 0x02,
+                subCmd: 0x54,
+            },
+        },
+        ak: {
+            supportModel: ["AM25B-1-25-ES-E-Z", "ZM25-EAZ", "AM25C-1-25-ES-E-Z"],
+            mapping: {
+                continuou: 0x00,
+                inching: 0x01,
+            },
+            updateMotorModeCommand: {
+                cmdType: 0x00,
+                privateCmd: 0x67,
+                dataType: 0x04,
+                dataLength: [0x00, 0x01],
+            },
+            updatedMotorModeCommand: {
+                cmdType: 0x01,
+                privateCmd: 0x67,
+                dataType: 0x04,
+            },
+        },
+    };
+    const expose = e.enum("motor_mode", ea.STATE_SET, mode).withDescription("Motor Mode");
+    const fromZigbee = [
+        {
+            cluster: clusterName,
+            type: ["raw"],
+            convert: (model, msg, publish, options, meta) => {
+                if (msg.type === "raw" && msg.data instanceof Buffer) {
+                    if (protocol.dooya.supportModel.includes(model.model)) {
+                        const bufferObj = msg.data.subarray(3, msg.data.length).toJSON();
+                        const payload = bufferObj.data;
+                        const { privateCmd, subCmd } = protocol.dooya.updatedMotorModeCommand;
+                        if (payload[0] === privateCmd && payload[1] === subCmd) {
+                            const entities = Object.entries(protocol.dooya.mapping);
+                            // biome-ignore lint/suspicious/noImplicitAnyLet: ignored using `--suppress`
+                            let motorMode;
+                            for (const entity of entities) {
+                                if (entity[1] === payload[2]) {
+                                    motorMode = entity[0];
+                                    break;
+                                }
+                            }
+                            return {
+                                motor_mode: motorMode,
+                            };
+                        }
+                    }
+                    else if (protocol.ak.supportModel.includes(model.model)) {
+                        const bufferObj = msg.data.subarray(3, msg.data.length).toJSON();
+                        const payload = bufferObj.data;
+                        const { cmdType, privateCmd, dataType } = protocol.ak.updatedMotorModeCommand;
+                        if (payload[0] === cmdType && payload[2] === privateCmd && payload[3] === dataType) {
+                            const entities = Object.entries(protocol.ak.mapping);
+                            // biome-ignore lint/suspicious/noImplicitAnyLet: ignored using `--suppress`
+                            let motorMode;
+                            for (const entity of entities) {
+                                if (entity[1] === payload[6]) {
+                                    motorMode = entity[0];
+                                    break;
+                                }
+                            }
+                            return {
+                                motor_mode: motorMode,
+                            };
+                        }
+                    }
+                }
+            },
+        },
+    ];
+    const toZigbee = [
+        {
+            key: ["motor_mode"],
+            convertSet: async (entity, key, value, meta) => {
+                utils.assertEndpoint(entity);
+                const device = entity.getDevice();
+                const modelID = device.modelID;
+                if (protocol.dooya.supportModel.includes(modelID)) {
+                    // Dooya Protocol
+                    const payloadValue = [];
+                    const { updateMotorModeCommand, mapping } = protocol.dooya;
+                    payloadValue[0] = updateMotorModeCommand.privateCmd;
+                    payloadValue[1] = updateMotorModeCommand.subCmd;
+                    payloadValue[2] = mapping[value];
+                    await entity.command(clusterName, writeCommand, { data: payloadValue });
+                }
+                else if (protocol.raex.supportModel.includes(modelID)) {
+                    // Raex Protocol
+                    const payloadValue = [];
+                    const { updateMotorModeCommand, mapping } = protocol.raex;
+                    payloadValue[0] = updateMotorModeCommand.privateCmd;
+                    payloadValue[1] = updateMotorModeCommand.dataLength;
+                    payloadValue[2] = updateMotorModeCommand.subCmd;
+                    payloadValue[3] = mapping[value];
+                    await entity.command(clusterName, writeCommand, { data: payloadValue });
+                }
+                else if (protocol.ak.supportModel.includes(modelID)) {
+                    // AK Protocol
+                    const payloadValue = [];
+                    const { updateMotorModeCommand, mapping } = protocol.ak;
+                    payloadValue[0] = updateMotorModeCommand.cmdType;
+                    payloadValue[1] = 0x00;
+                    payloadValue[2] = updateMotorModeCommand.privateCmd;
+                    payloadValue[3] = updateMotorModeCommand.dataType;
+                    payloadValue.push(...updateMotorModeCommand.dataLength);
+                    payloadValue[6] = mapping[value];
+                    await entity.command(clusterName, writeCommand, { data: payloadValue });
+                }
+                return { state: { [key]: value } };
+            },
+        },
+    ];
+    return { exposes: [expose], toZigbee, fromZigbee, isModernExtend: true };
+}
+function privateReportMotorInfo(clusterName) {
+    const protocol = {
+        dooya: {
+            supportModel: ["CK-MG22-Z310EE07DOOYA-01(7015)", "MYDY25Z-1", "CK-MG22-JLDJ-01(7015)", "Grandekor Smart Curtain Grandekor"],
+            mapping: {
+                status: {
+                    open: 0x01,
+                    close: 0x02,
+                    stop: 0x03,
+                },
+                itinerary: {
+                    none: 0x00,
+                    all: 0x01,
+                    hasOpen: 0x02,
+                    hasClose: 0x03,
+                    hasThird: 0x04,
+                },
+                speed: {
+                    none: 0x00,
+                    T1: 0x01,
+                    T2: 0x02,
+                    T3: 0x03,
+                    T4: 0x04,
+                    T5: 0x05,
+                    T6: 0x06,
+                    T7: 0x07,
+                    T8: 0x08,
+                    T9: 0x09,
+                    T10: 0x0a,
+                    T11: 0x0b,
+                    T12: 0x0c,
+                    T13: 0x0d,
+                    T14: 0x0e,
+                },
+                motorDirection: {
+                    forward: 0x01,
+                    reverse: 0x02,
+                },
+                motorMode: {
+                    continuou: 0x01,
+                    inching: 0x02,
+                },
+            },
+            updatedMotorInfoCommand: {
+                privateCmd: 0x03,
+                subCmd: 0x01,
+            },
+        },
+        raex: {
+            supportModel: ["MYRX25Z-1"],
+            mapping: {
+                status: {
+                    open: "01",
+                    close: "10",
+                    stop: "00",
+                },
+                itinerary: {
+                    none: 0x00,
+                    hasOpen: 0x01,
+                    hasClose: 0x02,
+                    all: 0x03,
+                },
+                speed: {
+                    none: 0x00,
+                    T1: 0x01,
+                    T2: 0x02,
+                    T3: 0x03,
+                },
+                motorDirection: {
+                    forward: "0",
+                    reverse: "1",
+                },
+                motorMode: {
+                    continuou: "0",
+                    inching: "1",
+                },
+            },
+            updatedMotorInfoCommand: {
+                privateCmd: 0xa1,
+                subCmd: 0x0c,
+            },
+        },
+    };
+    const expose = e.text("motor_info", ea.STATE).withDescription("Motor Updated Info");
+    const fromZigbee = [
+        {
+            cluster: clusterName,
+            type: ["raw"],
+            convert: (model, msg, publish, options, meta) => {
+                if (msg.type === "raw" && msg.data instanceof Buffer) {
+                    if (protocol.dooya.supportModel.includes(model.model)) {
+                        // Dooya Protocol
+                        const bufferObj = msg.data.subarray(3, msg.data.length).toJSON();
+                        const payload = bufferObj.data;
+                        const dooyaProtocol = protocol.dooya;
+                        const { privateCmd, subCmd } = protocol.dooya.updatedMotorInfoCommand;
+                        if (payload[0] === privateCmd && payload[1] === subCmd) {
+                            const motor_status = findKeyByValue(dooyaProtocol.mapping.status, payload[2]);
+                            const motor_percentage = payload[3];
+                            const motor_angle = payload[4];
+                            const motor_itinerary = findKeyByValue(dooyaProtocol.mapping.itinerary, payload[5]);
+                            const motor_speed = payload[6];
+                            const motor_direction = findKeyByValue(dooyaProtocol.mapping.motorDirection, payload[7]);
+                            const motor_mode = findKeyByValue(dooyaProtocol.mapping.motorMode, payload[8]);
+                            const battery = payload[9];
+                            return {
+                                [expose.property]: {
+                                    motor_status,
+                                    motor_percentage,
+                                    motor_angle,
+                                    motor_itinerary,
+                                    motor_speed,
+                                    motor_direction,
+                                    motor_mode,
+                                    battery,
+                                },
+                            };
+                        }
+                    }
+                    else if (protocol.raex.supportModel.includes(model.model)) {
+                        // Raex Protocol
+                        const bufferObj = msg.data.subarray(3, msg.data.length).toJSON();
+                        const payload = bufferObj.data;
+                        const raexProtocol = protocol.raex;
+                        const { privateCmd, subCmd } = raexProtocol.updatedMotorInfoCommand;
+                        if (payload[0] === privateCmd && payload[1] === subCmd) {
+                            const motor_status_binary = payload[2].toString(2).padStart(8, "0").slice(6, 8);
+                            const motor_status = findKeyByValue(raexProtocol.mapping.status, motor_status_binary);
+                            const motor_percentage = payload[3]; // 255 indicates that the motor cannot find the percentage.
+                            const motor_angle = payload[4]; // 255 indicates that the motor cannot find the angle
+                            const battery = payload[5];
+                            const motor_itinerary = findKeyByValue(raexProtocol.mapping.itinerary, payload[11]);
+                            const motor_speed = payload[9];
+                            const motor_direction_binary = payload[8].toString(2).padStart(8, "0").slice(6, 7);
+                            const motor_direction = findKeyByValue(raexProtocol.mapping.motorDirection, motor_direction_binary);
+                            const motor_mode_binary = payload[8].toString(2).padStart(8, "0").slice(5, 6);
+                            const motor_mode = findKeyByValue(raexProtocol.mapping.motorMode, motor_mode_binary);
+                            return {
+                                [expose.property]: {
+                                    motor_status,
+                                    motor_percentage,
+                                    motor_angle,
+                                    motor_itinerary,
+                                    motor_speed,
+                                    motor_direction,
+                                    motor_mode,
+                                    battery,
+                                },
+                            };
+                        }
+                    }
+                }
+            },
+        },
+    ];
+    return { exposes: [expose], fromZigbee, isModernExtend: true };
+}
+function privateMotorSpeed(clusterName, writeCommand, minSpeed, maxSpeed) {
+    const protocol = {
+        dooya: {
+            supportModel: ["CK-MG22-Z310EE07DOOYA-01(7015)", "MYDY25Z-1", "CK-MG22-JLDJ-01(7015)", "Grandekor Smart Curtain Grandekor"],
+            updateMotorSpeedCommand: {
+                privateCmd: 0x01,
+                subCmd: 0xd1,
+            },
+            updatedMotorSpeedCommand: {
+                privateCmd: 0x01,
+                subCmd: 0xd1,
+            },
+            updatedMaxMotorSpeedCommand: {
+                privateCmd: 0x02,
+                subCmd: 0x0e,
+            },
+        },
+        raex: {
+            supportModel: ["MYRX25Z-1"],
+            updateMotorSpeedCommand: {
+                privateCmd: 0x11,
+                dataLength: 0x02,
+                subCmd: 0x53,
+            },
+        },
+    };
+    const exposes = [];
+    exposes.push(e.numeric("motor_speed", ea.STATE_SET).withDescription("Set the motor speed").withValueMin(minSpeed).withValueMax(maxSpeed));
+    exposes.push(e.numeric("supported_max_motor_speed", ea.STATE).withDescription("Supported max motor speed"));
+    const fromZigbee = [
+        {
+            cluster: clusterName,
+            type: ["raw"],
+            convert: (model, msg, publish, options, meta) => {
+                if (msg.type === "raw" && msg.data instanceof Buffer) {
+                    if (protocol.dooya.supportModel.includes(model.model)) {
+                        const bufferObj = msg.data.subarray(3, msg.data.length).toJSON();
+                        const payload = bufferObj.data;
+                        const { updatedMotorSpeedCommand, updatedMaxMotorSpeedCommand } = protocol.dooya;
+                        if (payload[0] === updatedMotorSpeedCommand.privateCmd && payload[1] === updatedMotorSpeedCommand.subCmd) {
+                            return {
+                                motor_speed: payload[2], // If the gear position is 255, it means the device does not support speed adjustment.
+                            };
+                        }
+                        if (payload[0] === updatedMaxMotorSpeedCommand.privateCmd && payload[1] === updatedMaxMotorSpeedCommand.subCmd) {
+                            const supportedMax = payload[2];
+                            if (supportedMax === 0 || supportedMax === undefined) {
+                                return {
+                                    supported_max_motor_speed: 0,
+                                };
+                            }
+                            return { supported_max_motor_speed: supportedMax };
+                        }
+                    }
+                }
+            },
+        },
+    ];
+    const toZigbee = [
+        {
+            key: ["motor_speed"],
+            convertSet: async (entity, key, value, meta) => {
+                utils.assertEndpoint(entity);
+                const device = entity.getDevice();
+                const modelID = device.modelID;
+                if (protocol.dooya.supportModel.includes(modelID)) {
+                    const payloadValue = [];
+                    const { updateMotorSpeedCommand } = protocol.dooya;
+                    payloadValue[0] = updateMotorSpeedCommand.privateCmd;
+                    payloadValue[1] = updateMotorSpeedCommand.subCmd;
+                    payloadValue[2] = value;
+                    await entity.command(clusterName, writeCommand, { data: payloadValue });
+                }
+                else if (protocol.raex.supportModel.includes(modelID)) {
+                    const payloadValue = [];
+                    const { updateMotorSpeedCommand } = protocol.raex;
+                    payloadValue[0] = updateMotorSpeedCommand.privateCmd;
+                    payloadValue[1] = updateMotorSpeedCommand.dataLength;
+                    payloadValue[2] = updateMotorSpeedCommand.subCmd;
+                    payloadValue[3] = value;
+                    await entity.command(clusterName, writeCommand, { data: payloadValue });
+                }
+                return { state: { [key]: value } };
+            },
+        },
+    ];
+    return { exposes, toZigbee, fromZigbee, isModernExtend: true };
+}
+exports.ewelinkModernExtend = {
+    ewelinkAction: () => {
+        const exposes = [exposes_1.presets.action(["single", "double", "long"])];
+        const fromZigbee = [
+            {
+                cluster: "genOnOff",
+                type: ["commandOn", "commandOff", "commandToggle"],
+                convert: (model, msg, publish, options, meta) => {
+                    const lookup = { commandToggle: "single", commandOn: "double", commandOff: "long" };
+                    return { action: lookup[msg.type] };
+                },
+            },
+        ];
+        const configure = [(0, modernExtend_1.setupConfigureForBinding)("genOnOff", "output")];
+        return { exposes, fromZigbee, configure, isModernExtend: true };
+    },
+    ewelinkBattery: () => {
+        // 3600/7200 prevents disconnect
+        // https://github.com/Koenkk/zigbee2mqtt/issues/13600#issuecomment-1283827935
+        return (0, modernExtend_1.battery)({
+            voltage: true,
+            voltageReporting: true,
+            percentageReportingConfig: { min: 3600, max: 7200, change: 2 },
+            voltageReportingConfig: { min: 3600, max: 7200, change: 100 },
+        });
+    },
+    ewelinkMotorReverse: () => {
+        const exposes = [e.enum("motor_direction", ea.STATE_SET, ["forward", "reverse"]).withDescription("Set the motor direction")];
+        const toZigbee = [exports.ewelinkToZigbee.motor_direction];
+        const fromZigbee = [exports.ewelinkFromZigbee.motor_direction];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            isModernExtend: true,
+        };
+    },
+    ewelinkMotorClbByPosition: (clusterName, writeCommand) => {
+        return privateMotorClbByPosition(clusterName, writeCommand);
+    },
+    ewelinkMotorMode: (clusterName, writeCommand) => {
+        return privateMotorMode(clusterName, writeCommand);
+    },
+    ewelinkReportMotorInfo: (clusterName) => {
+        return privateReportMotorInfo(clusterName);
+    },
+    ewelinkMotorSpeed: (clusterName, writeCommand, min, max) => {
+        return privateMotorSpeed(clusterName, writeCommand, min, max);
+    },
+};
+exports.modernExtend = exports.ewelinkModernExtend;
+//# sourceMappingURL=ewelink.js.map