homebridge-midea-platform 1.2.0-beta.2 → 1.2.0-beta.4

package/dist/core/MideaDiscover.d.ts

@@ -1,36 +1,36 @@
-/// <reference types="node" />
-import { Logger } from 'homebridge';
-import EventEmitter from 'events';
-export default class Discover extends EventEmitter {
-    private readonly logger;
-    private socket;
-    private readonly xml_parser;
-    private security;
-    private ips;
-    constructor(logger: Logger);
-    /*********************************************************************
-     * discoverDeviceByIP
-     * Sends discover message to a single IP address.  Will resend the message
-     * an additional "retries" times spaced by 3 seconds if the target IP
-     * address has not responded (recorded in the above callback).
-     */
-    discoverDeviceByIP(ip: string, retries?: number, timeout?: number): void;
-    /*********************************************************************
-     * ifBroadcastAddrs
-     * Broadcasts to 255.255.255.255 only gets sent out on the first network inteface.
-     * This function finds all network interfaces and returns the broadcast address
-     * for each in an array, e.g. ['192.168.1.255', '192.168.100.255'].  If there are
-     * multiple interfaces this will cause broadcast to be sent out on each interface
-     * so all appliances are properly discovered.
-     */
-    private ifBroadcastAddrs;
-    /*********************************************************************
-     * startDiscover
-     * Sends broadcast to network discover Midea devices. Will continue sending
-     * up to an additional "retries" times each spaced by 3 seconds.
-     */
-    startDiscover(retries?: number, timeout?: number): void;
-    private getDeviceVersion;
-    private getDeviceInfo;
-}
+/// <reference types="node" />
+import { Logger } from 'homebridge';
+import EventEmitter from 'events';
+export default class Discover extends EventEmitter {
+    private readonly logger;
+    private socket;
+    private readonly xml_parser;
+    private security;
+    private ips;
+    constructor(logger: Logger);
+    /*********************************************************************
+     * discoverDeviceByIP
+     * Sends discover message to a single IP address.  Will resend the message
+     * an additional "retries" times spaced by 3 seconds if the target IP
+     * address has not responded (recorded in the above callback).
+     */
+    discoverDeviceByIP(ip: string, retries?: number, timeout?: number): void;
+    /*********************************************************************
+     * ifBroadcastAddrs
+     * Broadcasts to 255.255.255.255 only gets sent out on the first network inteface.
+     * This function finds all network interfaces and returns the broadcast address
+     * for each in an array, e.g. ['192.168.1.255', '192.168.100.255'].  If there are
+     * multiple interfaces this will cause broadcast to be sent out on each interface
+     * so all appliances are properly discovered.
+     */
+    private ifBroadcastAddrs;
+    /*********************************************************************
+     * startDiscover
+     * Sends broadcast to network discover Midea devices. Will continue sending
+     * up to an additional "retries" times each spaced by 3 seconds.
+     */
+    startDiscover(retries?: number, timeout?: number): void;
+    private getDeviceVersion;
+    private getDeviceInfo;
+}
 //# sourceMappingURL=MideaDiscover.d.ts.map

package/dist/core/MideaDiscover.js

@@ -1,213 +1,213 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/***********************************************************************
- * Midea device discovery class where we broadcast to network to find
- * connected devices.
- *
- * Copyright (c) 2023 Kovalovszky Patrik, https://github.com/kovapatrik
- * Portions Copyright (c) 2023 David Kerr, https://github.com/dkerr64
- *
- * With thanks to https://github.com/georgezhao2010/midea_ac_lan
- *
- */
-const dgram_1 = __importDefault(require("dgram"));
-const MideaConstants_1 = require("./MideaConstants");
-const fast_xml_parser_1 = require("fast-xml-parser");
-const events_1 = __importDefault(require("events"));
-const MideaSecurity_1 = require("./MideaSecurity");
-// To access network interface detail...
-const os_1 = __importDefault(require("os"));
-class Discover extends events_1.default {
-    constructor(logger) {
-        super();
-        this.logger = logger;
-        this.ips = [];
-        this.security = new MideaSecurity_1.LocalSecurity();
-        this.xml_parser = new fast_xml_parser_1.XMLParser();
-        this.socket = dgram_1.default.createSocket('udp4');
-        this.socket.bind(0, undefined, () => {
-            this.socket.setBroadcast(true);
-        });
-        this.socket.on('error', (err) => {
-            this.logger.debug(`server error:\n${err.stack}`);
-        });
-        // Register callback function executed when message received on the socket as
-        // result of sending broadcast messages out to network / IP address.
-        this.socket.on('message', async (msg, rinfo) => {
-            if (!this.ips.includes(rinfo.address)) {
-                // Only add device if it has not already been added.
-                this.ips.push(rinfo.address);
-                const device_version = this.getDeviceVersion(msg);
-                const device_info = await this.getDeviceInfo(rinfo.address, device_version, msg);
-                this.logger.info(`Discovered device: ${JSON.stringify(device_info)}`);
-                // Send signal to Homebridge platform with details on the discovered device
-                this.emit('device', device_info);
-            }
-        });
-    }
-    /*********************************************************************
-     * discoverDeviceByIP
-     * Sends discover message to a single IP address.  Will resend the message
-     * an additional "retries" times spaced by 3 seconds if the target IP
-     * address has not responded (recorded in the above callback).
-     */
-    discoverDeviceByIP(ip, retries = 3, timeout = 2000) {
-        let tries = 0;
-        function broadcast() {
-            if (this.ips.includes(ip) || tries++ > retries) {
-                return;
-            }
-            this.logger.debug(`Sending discovery message to ${ip}, try ${tries}...`);
-            for (const port of [6445, 20086]) {
-                this.socket.send(Buffer.from(MideaConstants_1.DISCOVERY_MESSAGE), port, ip, (err) => {
-                    if (err) {
-                        this.logger.error(`Error while sending message to ${ip}: ${err}`);
-                    }
-                });
-            }
-            setTimeout(broadcast.bind(this), timeout);
-        }
-        broadcast.bind(this)();
-    }
-    /*********************************************************************
-     * ifBroadcastAddrs
-     * Broadcasts to 255.255.255.255 only gets sent out on the first network inteface.
-     * This function finds all network interfaces and returns the broadcast address
-     * for each in an array, e.g. ['192.168.1.255', '192.168.100.255'].  If there are
-     * multiple interfaces this will cause broadcast to be sent out on each interface
-     * so all appliances are properly discovered.
-     */
-    ifBroadcastAddrs() {
-        const list = [];
-        try {
-            const ifaces = os_1.default.networkInterfaces();
-            for (const iface of Object.values(ifaces)) {
-                if (iface) {
-                    for (const f of iface) {
-                        if (!f.internal && f.family === 'IPv4') {
-                            // With thanks to https://github.com/aal89/broadcast-address/blob/master/broadcast-address.js
-                            const addr_splitted = f.address.split('.');
-                            const netmask_splitted = f.netmask.split('.');
-                            // Bitwise OR over the splitted NAND netmask, then glue them back together with a dot character to form an ip
-                            // we have to do a NAND operation because of the 2-complements; getting rid of all the 'prepended' 1's with & 0xFF
-                            const broadcast = addr_splitted.map((e, i) => (~netmask_splitted[i] & 0xff) | Number.parseInt(e)).join('.');
-                            list.push(broadcast);
-                        }
-                    }
-                }
-            }
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.stack : e;
-            this.logger.error(`Fatal error during plugin initialization:\n${msg}`);
-        }
-        // this.logger.info(`Broadcast addresses: ${JSON.stringify(list)}`);
-        return list;
-    }
-    /*********************************************************************
-     * startDiscover
-     * Sends broadcast to network discover Midea devices. Will continue sending
-     * up to an additional "retries" times each spaced by 3 seconds.
-     */
-    startDiscover(retries = 3, timeout = 2000) {
-        let tries = 0;
-        // force timeout to be between 500ms and 5 seconds
-        timeout = Math.max(500, Math.min(timeout, 5000));
-        const broadcastAddrs = this.ifBroadcastAddrs();
-        function broadcast() {
-            if (tries++ > retries) {
-                this.logger.debug(`Device discovery complete after ${retries + 1} network broadcasts.`);
-                this.emit('complete');
-                return;
-            }
-            else {
-                this.emit('retry', tries, this.ips.length);
-            }
-            for (const ip of broadcastAddrs) {
-                this.logger.debug(`Sending discovery message to ${ip}, try ${tries}...`);
-                for (const port of [6445, 20086]) {
-                    this.socket.send(Buffer.from(MideaConstants_1.DISCOVERY_MESSAGE), port, ip, (err) => {
-                        if (err) {
-                            const msg = err instanceof Error ? err.stack : err;
-                            this.logger.error(`Error while sending message to ${ip}:${port}:\n${msg}`);
-                        }
-                    });
-                }
-            }
-            setTimeout(broadcast.bind(this), timeout);
-        }
-        broadcast.bind(this)();
-    }
-    getDeviceVersion(data) {
-        try {
-            this.xml_parser.parse(data.toString(), true);
-            return MideaConstants_1.ProtocolVersion.V1;
-        }
-        catch (_a) {
-            const start_of_packet = data.subarray(0, 2);
-            if (start_of_packet.compare(Buffer.from([0x5a, 0x5a])) === 0) {
-                return MideaConstants_1.ProtocolVersion.V2;
-            }
-            else if (start_of_packet.compare(Buffer.from([0x83, 0x70])) === 0) {
-                return MideaConstants_1.ProtocolVersion.V3;
-            }
-        }
-        throw new Error('Unknown device version.');
-    }
-    async getDeviceInfo(ip, version, data) {
-        if (version === MideaConstants_1.ProtocolVersion.V1) {
-            // const root = this.xml_parser.parse(data.toString());
-            // const device = root["body"]["device"]
-            // if (device) {
-            //   const port = device["port"];
-            // }
-            // throw new Error("Could not find 'body/device' in XML.");
-            throw new Error('Version 1 not implemented.');
-        }
-        else {
-            let buffer = data;
-            // Strip V3 header and hash
-            if (version === MideaConstants_1.ProtocolVersion.V3) {
-                buffer = buffer.subarray(8, -16);
-            }
-            const encrypted_data = buffer.subarray(40, -16);
-            const device_id = buffer.readUIntLE(20, 6);
-            let decrypted_buffer;
-            try {
-                decrypted_buffer = this.security.aes_decrypt(encrypted_data);
-            }
-            catch (err) {
-                throw new Error(`Error while decrypting data: ${err}`);
-            }
-            // prettier-ignore
-            // eslint-disable-next-line max-len
-            const ip_address = `${decrypted_buffer.readUint8(3)}.${decrypted_buffer.readUint8(2)}.${decrypted_buffer.readUint8(1)}.${decrypted_buffer.readUint8(0)}`;
-            const port = decrypted_buffer.readUIntLE(4, 2);
-            if (ip_address !== ip) {
-                this.logger.warn(`IP address mismatch: ${ip_address} != ${ip}`);
-            }
-            const model = decrypted_buffer.subarray(17, 25).toString();
-            // Serial number
-            const sn = decrypted_buffer.subarray(8, 40).toString();
-            // Extract name/SSID
-            const name_length = decrypted_buffer.readUIntLE(40, 1);
-            const name = decrypted_buffer.subarray(41, 41 + name_length).toString();
-            const device_type = Number(`0x${name.split('_')[1]}`);
-            return {
-                ip: ip,
-                port: port,
-                id: device_id,
-                model: model,
-                sn: sn,
-                name: name,
-                type: device_type,
-                version: version,
-            };
-        }
-    }
-}
-exports.default = Discover;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/***********************************************************************
+ * Midea device discovery class where we broadcast to network to find
+ * connected devices.
+ *
+ * Copyright (c) 2023 Kovalovszky Patrik, https://github.com/kovapatrik
+ * Portions Copyright (c) 2023 David Kerr, https://github.com/dkerr64
+ *
+ * With thanks to https://github.com/georgezhao2010/midea_ac_lan
+ *
+ */
+const dgram_1 = __importDefault(require("dgram"));
+const MideaConstants_1 = require("./MideaConstants");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const events_1 = __importDefault(require("events"));
+const MideaSecurity_1 = require("./MideaSecurity");
+// To access network interface detail...
+const os_1 = __importDefault(require("os"));
+class Discover extends events_1.default {
+    constructor(logger) {
+        super();
+        this.logger = logger;
+        this.ips = [];
+        this.security = new MideaSecurity_1.LocalSecurity();
+        this.xml_parser = new fast_xml_parser_1.XMLParser();
+        this.socket = dgram_1.default.createSocket('udp4');
+        this.socket.bind(0, undefined, () => {
+            this.socket.setBroadcast(true);
+        });
+        this.socket.on('error', (err) => {
+            this.logger.debug(`server error:\n${err.stack}`);
+        });
+        // Register callback function executed when message received on the socket as
+        // result of sending broadcast messages out to network / IP address.
+        this.socket.on('message', async (msg, rinfo) => {
+            if (!this.ips.includes(rinfo.address)) {
+                // Only add device if it has not already been added.
+                this.ips.push(rinfo.address);
+                const device_version = this.getDeviceVersion(msg);
+                const device_info = await this.getDeviceInfo(rinfo.address, device_version, msg);
+                this.logger.info(`Discovered device: ${JSON.stringify(device_info)}`);
+                // Send signal to Homebridge platform with details on the discovered device
+                this.emit('device', device_info);
+            }
+        });
+    }
+    /*********************************************************************
+     * discoverDeviceByIP
+     * Sends discover message to a single IP address.  Will resend the message
+     * an additional "retries" times spaced by 3 seconds if the target IP
+     * address has not responded (recorded in the above callback).
+     */
+    discoverDeviceByIP(ip, retries = 3, timeout = 2000) {
+        let tries = 0;
+        function broadcast() {
+            if (this.ips.includes(ip) || tries++ > retries) {
+                return;
+            }
+            this.logger.debug(`Sending discovery message to ${ip}, try ${tries}...`);
+            for (const port of [6445, 20086]) {
+                this.socket.send(Buffer.from(MideaConstants_1.DISCOVERY_MESSAGE), port, ip, (err) => {
+                    if (err) {
+                        this.logger.error(`Error while sending message to ${ip}: ${err}`);
+                    }
+                });
+            }
+            setTimeout(broadcast.bind(this), timeout);
+        }
+        broadcast.bind(this)();
+    }
+    /*********************************************************************
+     * ifBroadcastAddrs
+     * Broadcasts to 255.255.255.255 only gets sent out on the first network inteface.
+     * This function finds all network interfaces and returns the broadcast address
+     * for each in an array, e.g. ['192.168.1.255', '192.168.100.255'].  If there are
+     * multiple interfaces this will cause broadcast to be sent out on each interface
+     * so all appliances are properly discovered.
+     */
+    ifBroadcastAddrs() {
+        const list = [];
+        try {
+            const ifaces = os_1.default.networkInterfaces();
+            for (const iface of Object.values(ifaces)) {
+                if (iface) {
+                    for (const f of iface) {
+                        if (!f.internal && f.family === 'IPv4') {
+                            // With thanks to https://github.com/aal89/broadcast-address/blob/master/broadcast-address.js
+                            const addr_splitted = f.address.split('.');
+                            const netmask_splitted = f.netmask.split('.');
+                            // Bitwise OR over the splitted NAND netmask, then glue them back together with a dot character to form an ip
+                            // we have to do a NAND operation because of the 2-complements; getting rid of all the 'prepended' 1's with & 0xFF
+                            const broadcast = addr_splitted.map((e, i) => (~netmask_splitted[i] & 0xff) | Number.parseInt(e)).join('.');
+                            list.push(broadcast);
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.stack : e;
+            this.logger.error(`Fatal error during plugin initialization:\n${msg}`);
+        }
+        // this.logger.info(`Broadcast addresses: ${JSON.stringify(list)}`);
+        return list;
+    }
+    /*********************************************************************
+     * startDiscover
+     * Sends broadcast to network discover Midea devices. Will continue sending
+     * up to an additional "retries" times each spaced by 3 seconds.
+     */
+    startDiscover(retries = 3, timeout = 2000) {
+        let tries = 0;
+        // force timeout to be between 500ms and 5 seconds
+        timeout = Math.max(500, Math.min(timeout, 5000));
+        const broadcastAddrs = this.ifBroadcastAddrs();
+        function broadcast() {
+            if (tries++ > retries) {
+                this.logger.debug(`Device discovery complete after ${retries + 1} network broadcasts.`);
+                this.emit('complete');
+                return;
+            }
+            else {
+                this.emit('retry', tries, this.ips.length);
+            }
+            for (const ip of broadcastAddrs) {
+                this.logger.debug(`Sending discovery message to ${ip}, try ${tries}...`);
+                for (const port of [6445, 20086]) {
+                    this.socket.send(Buffer.from(MideaConstants_1.DISCOVERY_MESSAGE), port, ip, (err) => {
+                        if (err) {
+                            const msg = err instanceof Error ? err.stack : err;
+                            this.logger.error(`Error while sending message to ${ip}:${port}:\n${msg}`);
+                        }
+                    });
+                }
+            }
+            setTimeout(broadcast.bind(this), timeout);
+        }
+        broadcast.bind(this)();
+    }
+    getDeviceVersion(data) {
+        try {
+            this.xml_parser.parse(data.toString(), true);
+            return MideaConstants_1.ProtocolVersion.V1;
+        }
+        catch (_a) {
+            const start_of_packet = data.subarray(0, 2);
+            if (start_of_packet.compare(Buffer.from([0x5a, 0x5a])) === 0) {
+                return MideaConstants_1.ProtocolVersion.V2;
+            }
+            else if (start_of_packet.compare(Buffer.from([0x83, 0x70])) === 0) {
+                return MideaConstants_1.ProtocolVersion.V3;
+            }
+        }
+        throw new Error('Unknown device version.');
+    }
+    async getDeviceInfo(ip, version, data) {
+        if (version === MideaConstants_1.ProtocolVersion.V1) {
+            // const root = this.xml_parser.parse(data.toString());
+            // const device = root["body"]["device"]
+            // if (device) {
+            //   const port = device["port"];
+            // }
+            // throw new Error("Could not find 'body/device' in XML.");
+            throw new Error('Version 1 not implemented.');
+        }
+        else {
+            let buffer = data;
+            // Strip V3 header and hash
+            if (version === MideaConstants_1.ProtocolVersion.V3) {
+                buffer = buffer.subarray(8, -16);
+            }
+            const encrypted_data = buffer.subarray(40, -16);
+            const device_id = buffer.readUIntLE(20, 6);
+            let decrypted_buffer;
+            try {
+                decrypted_buffer = this.security.aes_decrypt(encrypted_data);
+            }
+            catch (err) {
+                throw new Error(`Error while decrypting data: ${err}`);
+            }
+            // prettier-ignore
+            // eslint-disable-next-line max-len
+            const ip_address = `${decrypted_buffer.readUint8(3)}.${decrypted_buffer.readUint8(2)}.${decrypted_buffer.readUint8(1)}.${decrypted_buffer.readUint8(0)}`;
+            const port = decrypted_buffer.readUIntLE(4, 2);
+            if (ip_address !== ip) {
+                this.logger.warn(`IP address mismatch: ${ip_address} != ${ip}`);
+            }
+            const model = decrypted_buffer.subarray(17, 25).toString();
+            // Serial number
+            const sn = decrypted_buffer.subarray(8, 40).toString();
+            // Extract name/SSID
+            const name_length = decrypted_buffer.readUIntLE(40, 1);
+            const name = decrypted_buffer.subarray(41, 41 + name_length).toString();
+            const device_type = Number(`0x${name.split('_')[1]}`);
+            return {
+                ip: ip,
+                port: port,
+                id: device_id,
+                model: model,
+                sn: sn,
+                name: name,
+                type: device_type,
+                version: version,
+            };
+        }
+    }
+}
+exports.default = Discover;
 //# sourceMappingURL=MideaDiscover.js.map

package/dist/core/MideaMessage.d.ts

@@ -1,76 +1,76 @@
-/// <reference types="node" />
-import { DeviceType } from './MideaConstants';
-export declare enum MessageType {
-    UNKNOWN = 0,
-    SET = 2,
-    QUERY = 3,
-    NOTIFY1 = 4,
-    NOTIFY2 = 5,
-    EXCEPTION = 6,
-    QUERY_SN = 7,
-    EXCEPTION2 = 10,
-    QUERY_SUBTYPE = 160
-}
-declare abstract class MessageBase {
-    protected readonly HEADER_LENGTH = 10;
-    protected abstract device_type: DeviceType;
-    protected abstract message_type: MessageType;
-    protected abstract body_type: number | null;
-    protected abstract device_protocol_version: number;
-    protected abstract body: Buffer;
-    checksum(data: Buffer): number;
-}
-export declare abstract class MessageRequest extends MessageBase {
-    device_type: DeviceType;
-    message_type: MessageType;
-    body_type: number | null;
-    device_protocol_version: number;
-    protected abstract _body: Buffer;
-    constructor(device_type: DeviceType, message_type: MessageType, body_type: number | null, device_protocol_version: number);
-    get body(): Buffer;
-    get header(): Buffer;
-    serialize(): Buffer;
-}
-export declare class MessageQuerySubtype extends MessageRequest {
-    protected _body: Buffer;
-    constructor(device_type: DeviceType);
-}
-export declare class MessageQuestCustom extends MessageRequest {
-    protected _body: Buffer;
-    protected cmd_body: Buffer;
-    constructor(device_type: DeviceType, message_type: MessageType, cmd_body: Buffer);
-    get body(): Buffer;
-}
-export declare class MessageBody {
-    readonly data: Buffer;
-    constructor(data: Buffer);
-    get body_type(): number;
-    static read_byte(data: Buffer, offset: number, default_value: number): number;
-}
-export declare class NewProtocolMessageBody extends MessageBody {
-    protected packet_length: number;
-    constructor(body: Buffer, body_type: number);
-    static packet(param: number, value: Buffer, packet_length?: number): Buffer;
-    parse(): {
-        [key: string]: any;
-    };
-}
-export declare class MessageResponse extends MessageBase {
-    protected header: Buffer;
-    protected device_type: DeviceType;
-    protected message_type: MessageType;
-    protected body_type: number;
-    device_protocol_version: number;
-    protected _body: MessageBody;
-    constructor(message: Buffer | null | undefined);
-    get body(): Buffer;
-    set_body(body: MessageBody): void;
-    get_body_type(): string;
-    get_body_attribute(name: string): any;
-}
-export declare class MessageSubtypeResponse extends MessageResponse {
-    sub_type: number;
-    constructor(message: Buffer | null | undefined);
-}
-export {};
+/// <reference types="node" />
+import { DeviceType } from './MideaConstants';
+export declare enum MessageType {
+    UNKNOWN = 0,
+    SET = 2,
+    QUERY = 3,
+    NOTIFY1 = 4,
+    NOTIFY2 = 5,
+    EXCEPTION = 6,
+    QUERY_SN = 7,
+    EXCEPTION2 = 10,
+    QUERY_SUBTYPE = 160
+}
+declare abstract class MessageBase {
+    protected readonly HEADER_LENGTH = 10;
+    protected abstract device_type: DeviceType;
+    protected abstract message_type: MessageType;
+    protected abstract body_type: number | null;
+    protected abstract device_protocol_version: number;
+    protected abstract body: Buffer;
+    checksum(data: Buffer): number;
+}
+export declare abstract class MessageRequest extends MessageBase {
+    device_type: DeviceType;
+    message_type: MessageType;
+    body_type: number | null;
+    device_protocol_version: number;
+    protected abstract _body: Buffer;
+    constructor(device_type: DeviceType, message_type: MessageType, body_type: number | null, device_protocol_version: number);
+    get body(): Buffer;
+    get header(): Buffer;
+    serialize(): Buffer;
+}
+export declare class MessageQuerySubtype extends MessageRequest {
+    protected _body: Buffer;
+    constructor(device_type: DeviceType);
+}
+export declare class MessageQuestCustom extends MessageRequest {
+    protected _body: Buffer;
+    protected cmd_body: Buffer;
+    constructor(device_type: DeviceType, message_type: MessageType, cmd_body: Buffer);
+    get body(): Buffer;
+}
+export declare class MessageBody {
+    readonly data: Buffer;
+    constructor(data: Buffer);
+    get body_type(): number;
+    static read_byte(data: Buffer, offset: number, default_value: number): number;
+}
+export declare class NewProtocolMessageBody extends MessageBody {
+    protected packet_length: number;
+    constructor(body: Buffer, body_type: number);
+    static packet(param: number, value: Buffer, packet_length?: number): Buffer;
+    parse(): {
+        [key: string]: any;
+    };
+}
+export declare class MessageResponse extends MessageBase {
+    protected header: Buffer;
+    protected device_type: DeviceType;
+    protected message_type: MessageType;
+    protected body_type: number;
+    device_protocol_version: number;
+    protected _body: MessageBody;
+    constructor(message: Buffer | null | undefined);
+    get body(): Buffer;
+    set_body(body: MessageBody): void;
+    get_body_type(): string;
+    get_body_attribute(name: string): any;
+}
+export declare class MessageSubtypeResponse extends MessageResponse {
+    sub_type: number;
+    constructor(message: Buffer | null | undefined);
+}
+export {};
 //# sourceMappingURL=MideaMessage.d.ts.map