@willieee802/zigbee-herdsman 0.49.3 → 0.50.0

package/test/requests.bench.ts

@@ -275,6 +275,7 @@ describe("Requests", () => {
                 },
                 BASIC_REQ_FRAME,
                 endpoint,
+                Zcl.Status.SUCCESS,
             );
         },
         {
@@ -307,6 +308,7 @@ describe("Requests", () => {
                 },
                 TIME_REQ_FRAME,
                 endpoint,
+                Zcl.Status.SUCCESS,
             );
         },
         {

package/test/zcl.test.ts

@@ -5,6 +5,7 @@ import {BuffaloZclDataType, DataType, Direction, FrameType, StructuredIndicatorT
 
 const MANU_SPE_CUSTOM_CLUSTERS = {
     manuSpecificAssaDoorLock: {
+        name: "manuSpecificAssaDoorLock",
         ID: 0xfc00,
         attributes: {},
         commands: {},
@@ -12,6 +13,18 @@ const MANU_SPE_CUSTOM_CLUSTERS = {
     },
 };
 
+const MIBOXER_GROUPS_CUSTOM_CLUSTER = {
+    genGroups: {
+        name: "genGroups",
+        ID: Zcl.Clusters.genGroups.ID,
+        attributes: {},
+        commands: {
+            miboxerSetZones: {name: "miboxerSetZones", ID: 0xf0, parameters: [{name: "zones", type: BuffaloZclDataType.LIST_MIBOXER_ZONES}]},
+        },
+        commandsResponse: {},
+    },
+};
+
 describe("Zcl", () => {
     it("Get cluster by name", () => {
         const cluster = Zcl.Utils.getCluster("genIdentify", undefined, {});
@@ -25,41 +38,29 @@ describe("Zcl", () => {
 
     it("Get cluster by ID", () => {
         const cluster1 = Zcl.Utils.getCluster(0, undefined, {});
-        // @ts-expect-error testing
-        delete cluster1.getAttribute;
-        // @ts-expect-error testing
-        delete cluster1.getCommand;
-        // @ts-expect-error testing
-        delete cluster1.getCommandResponse;
         const cluster2 = Zcl.Utils.getCluster("genBasic", undefined, {});
-        // @ts-expect-error testing
-        delete cluster2.getAttribute;
-        // @ts-expect-error testing
-        delete cluster2.getCommand;
-        // @ts-expect-error testing
-        delete cluster2.getCommandResponse;
         expect(cluster1).toStrictEqual(cluster2);
     });
 
     it("Get cluster attribute by ID", () => {
         const cluster = Zcl.Utils.getCluster(0, undefined, {});
-        const attribute = cluster.getAttribute(1);
+        const attribute = Zcl.Utils.getClusterAttribute(cluster, 1, undefined);
         expect(attribute).toStrictEqual({ID: 1, type: DataType.UINT8, name: "appVersion", default: 0, max: 255});
     });
 
     it("Cluster has attribute", () => {
         const cluster = Zcl.Utils.getCluster(0, undefined, {});
-        expect(cluster.getAttribute("zclVersion")).not.toBeUndefined();
-        expect(cluster.getAttribute("NOTEXISTING")).toBeUndefined();
-        expect(cluster.getAttribute(0)).not.toBeUndefined();
-        expect(cluster.getAttribute(910293)).toBeUndefined();
+        expect(Zcl.Utils.getClusterAttribute(cluster, "zclVersion", undefined)).not.toBeUndefined();
+        expect(Zcl.Utils.getClusterAttribute(cluster, "NOTEXISTING", undefined)).toBeUndefined();
+        expect(Zcl.Utils.getClusterAttribute(cluster, 0, undefined)).not.toBeUndefined();
+        expect(Zcl.Utils.getClusterAttribute(cluster, 910293, undefined)).toBeUndefined();
     });
 
     it("Get specific command by name", () => {
         const cluster = Zcl.Utils.getCluster("genIdentify", undefined, {});
-        const command = cluster.getCommand("ezmodeInvoke");
-        expect(command.ID).toBe(2);
-        expect(command.name).toBe("ezmodeInvoke");
+        const command = Zcl.Utils.getClusterCommand(cluster, "identify");
+        expect(command.ID).toBe(0);
+        expect(command.name).toBe("identify");
     });
 
     it("Get global command by name", () => {
@@ -71,13 +72,13 @@ describe("Zcl", () => {
     it("Get global command non existing", () => {
         expect(() => {
             Zcl.Utils.getGlobalCommand("nonexisting");
-        }).toThrow("Global command with key 'nonexisting' does not exist");
+        }).toThrow("Status 'UNSUP_COMMAND' foundation:nonexisting");
     });
 
     it("Get cluster by name non-existing", () => {
         expect(() => {
             Zcl.Utils.getCluster("notExisting", undefined, {});
-        }).toThrow("Cluster with name 'notExisting' does not exist");
+        }).toThrow("Status 'UNSUPPORTED_CLUSTER' notExisting");
     });
 
     it("Get cluster by id non-existing", () => {
@@ -92,13 +93,13 @@ describe("Zcl", () => {
 
     it("Get specific command by ID", () => {
         const cluster = Zcl.Utils.getCluster("genIdentify", undefined, {});
-        const command = cluster.getCommand(2);
-        expect(command).toStrictEqual(cluster.getCommand("ezmodeInvoke"));
+        const command = Zcl.Utils.getClusterCommand(cluster, 0);
+        expect(command).toStrictEqual(Zcl.Utils.getClusterCommand(cluster, "identify"));
     });
 
     it("Get specific command by name server to client", () => {
         const cluster = Zcl.Utils.getCluster("genIdentify", undefined, {});
-        const command = cluster.getCommandResponse(0);
+        const command = Zcl.Utils.getClusterCommandResponse(cluster, 0);
         expect(command.ID).toBe(0);
         expect(command.name).toBe("identifyQueryRsp");
     });
@@ -106,15 +107,8 @@ describe("Zcl", () => {
     it("Get specific command by name non existing", () => {
         expect(() => {
             const cluster = Zcl.Utils.getCluster("genIdentify", undefined, {});
-            cluster.getCommandResponse("nonexisting");
-        }).toThrow("Cluster 'genIdentify' has no command response 'nonexisting'");
-    });
-
-    it("Get discrete or analog of unkown type", () => {
-        expect(() => {
-            // @ts-expect-error invalid on purpose
-            Zcl.Utils.getDataTypeClass(99999);
-        }).toThrow("Don't know value type for 'undefined'");
+            Zcl.Utils.getClusterCommandResponse(cluster, "nonexisting");
+        }).toThrow("Status 'UNSUP_COMMAND' response genIdentify:nonexisting");
     });
 
     it("ZclFrame from buffer parse payload with unknown frame type", () => {
@@ -156,30 +150,6 @@ describe("Zcl", () => {
         expect(frame.isCommand("report")).toBe(true);
     });
 
-    it("ZclFrame from buffer tradfriArrowSingle", () => {
-        const buffer = Buffer.from([0x05, 0x7c, 0x11, 0x1d, 0x07, 0x00, 0x01, 0x0d, 0x00]);
-        const frame = Zcl.Frame.fromBuffer(Zcl.Clusters.genScenes.ID, Zcl.Header.fromBuffer(buffer)!, buffer, {});
-        const header = new Zcl.Header(
-            {
-                reservedBits: 0,
-                direction: 0,
-                disableDefaultResponse: false,
-                frameType: 1,
-                manufacturerSpecific: true,
-            },
-            4476,
-            29,
-            7,
-        );
-
-        const payload = {value: 256, value2: 13};
-
-        expect(frame.header).toStrictEqual(header);
-        expect(frame.payload).toStrictEqual(payload);
-        expect(frame.command.ID).toStrictEqual(7);
-        expect(frame.command.name).toStrictEqual("tradfriArrowSingle");
-    });
-
     it("ZclFrame from buffer genGroups getMembership", () => {
         const buffer = Buffer.from([0x11, 0x7c, 0x02, 2, 10, 0, 20, 0]);
         const frame = Zcl.Frame.fromBuffer(Zcl.Clusters.genGroups.ID, Zcl.Header.fromBuffer(buffer)!, buffer, {});
@@ -269,7 +239,7 @@ describe("Zcl", () => {
     });
 
     it("ZclFrame from buffer configReportRsp - long", () => {
-        const buffer = Buffer.from([0x08, 0x01, 0x07, 0x00, 0x01, 0x34, 0x12, 0x01, 0x01, 0x35, 0x12]);
+        const buffer = Buffer.from([0x08, 0x01, 0x07, 0x02, 0x01, 0x34, 0x12, 0x01, 0x01, 0x35, 0x12]);
         const frame = Zcl.Frame.fromBuffer(Zcl.Clusters.genPowerCfg.ID, Zcl.Header.fromBuffer(buffer)!, buffer, {});
         const header = new Zcl.Header(
             {
@@ -285,7 +255,7 @@ describe("Zcl", () => {
         );
 
         const payload = [
-            {status: 0, direction: 1, attrId: 0x1234},
+            {status: 2, direction: 1, attrId: 0x1234},
             {status: 1, direction: 1, attrId: 0x1235},
         ];
 
@@ -294,7 +264,7 @@ describe("Zcl", () => {
     });
 
     it("ZclFrame from buffer configReportRsp (hvacThermostat)", () => {
-        const buffer = Buffer.from([0x18, 0x03, 0x07, 0x00, 0x00, 0x12, 0x00]);
+        const buffer = Buffer.from([0x18, 0x03, 0x07, 0x00]);
         const frame = Zcl.Frame.fromBuffer(Zcl.Clusters.hvacThermostat.ID, Zcl.Header.fromBuffer(buffer)!, buffer, {});
         const header = new Zcl.Header(
             {
@@ -309,7 +279,7 @@ describe("Zcl", () => {
             7,
         );
 
-        const payload = [{status: 0, direction: 0, attrId: 18}];
+        const payload = [{status: 0}];
 
         expect(frame.payload).toStrictEqual(payload);
         expect(frame.header).toStrictEqual(header);
@@ -571,15 +541,6 @@ describe("Zcl", () => {
             {
                 attrId: 65282,
                 dataType: 76,
-                numElms: 6,
-                structElms: [
-                    {elmType: 16, elmVal: 1},
-                    {elmType: 33, elmVal: 3022},
-                    {elmType: 33, elmVal: 17320},
-                    {elmType: 36, elmVal: 1},
-                    {elmType: 33, elmVal: 560},
-                    {elmType: 32, elmVal: 86},
-                ],
                 attrData: [
                     {elmType: 16, elmVal: 1},
                     {elmType: 33, elmVal: 3022},
@@ -1536,15 +1497,6 @@ describe("Zcl", () => {
         expect(frame.toBuffer()).toStrictEqual(expected);
     });
 
-    it("ZclFrame to buffer tradfriArrowSingle", () => {
-        const expected = Buffer.from([0x05, 0x7c, 0x11, 0x1d, 0x07, 0x00, 0x01, 0x0d, 0x00]);
-        const payload = {value: 256, value2: 13};
-
-        const frame = Zcl.Frame.create(FrameType.SPECIFIC, Direction.CLIENT_TO_SERVER, false, 4476, 29, 7, 5, payload, {});
-
-        expect(frame.toBuffer()).toStrictEqual(expected);
-    });
-
     it("ZclFrame to buffer readRsp failed", () => {
         const expected = Buffer.from([8, 1, 1, 1, 0, 2]);
         const payload = [{status: 2, attrId: 1}];
@@ -1945,13 +1897,13 @@ describe("Zcl", () => {
     });
 
     it("Zcl utils get cluster with manufacturerCode", () => {
-        const cluster = Zcl.Utils.getCluster(0xfc00, 0x100b, MANU_SPE_CUSTOM_CLUSTERS);
-        expect(cluster.ID).toBe(0xfc00);
-        expect(cluster.name).toBe("manuSpecificPhilips");
+        const cluster = Zcl.Utils.getCluster(0xfc57, 0x1217, MANU_SPE_CUSTOM_CLUSTERS);
+        expect(cluster.ID).toBe(0xfc57);
+        expect(cluster.name).toBe("manuSpecificAmazonWWAH");
     });
 
     it("Zcl utils get cluster manufacturerCode", () => {
-        const cluster = Zcl.Utils.getCluster(0xfc00, 0x10f2, MANU_SPE_CUSTOM_CLUSTERS);
+        const cluster = Zcl.Utils.getCluster(0xfc00, Zcl.ManufacturerCode.UBISYS_TECHNOLOGIES_GMBH, MANU_SPE_CUSTOM_CLUSTERS);
         expect(cluster.ID).toBe(0xfc00);
         expect(cluster.name).toBe("manuSpecificAssaDoorLock");
     });
@@ -1963,38 +1915,55 @@ describe("Zcl", () => {
     });
 
     it("Zcl utils get cluster attributes manufacturerCode", () => {
-        const cluster = Zcl.Utils.getCluster("closuresWindowCovering", 0x1021, {});
-        const attribute = cluster.getAttribute(0xf004);
+        const cluster = Zcl.Utils.getCluster("closuresWindowCovering", 0x1021, {
+            closuresWindowCovering: {
+                ID: Zcl.Clusters.closuresWindowCovering.ID,
+                name: "closuresWindowCovering",
+                attributes: {
+                    stepPositionTilt: {
+                        name: "stepPositionTilt",
+                        ID: 0xf004,
+                        type: DataType.ENUM8,
+                        manufacturerCode: Zcl.ManufacturerCode.LEGRAND_GROUP,
+                        write: true,
+                        max: 0xff,
+                    },
+                },
+                commands: {},
+                commandsResponse: {},
+            },
+        });
+        const attribute = Zcl.Utils.getClusterAttribute(cluster, 0xf004, 0x1021);
         expect(attribute).toStrictEqual(expect.objectContaining({ID: 0xf004, manufacturerCode: 0x1021, name: "stepPositionTilt", type: 48}));
     });
 
     it("Zcl utils get cluster attributes manufacturerCode wrong", () => {
         const cluster = Zcl.Utils.getCluster("closuresWindowCovering", 123, {});
-        expect(cluster.getAttribute(0x1000)).toBeUndefined();
+        expect(Zcl.Utils.getClusterAttribute(cluster, 0x1000, 123)).toBeUndefined();
     });
 
     it("Zcl utils get command", () => {
         const cluster = Zcl.Utils.getCluster("genOnOff", undefined, {});
-        const command = cluster.getCommand(0);
+        const command = Zcl.Utils.getClusterCommand(cluster, 0);
         expect(command.name).toStrictEqual("off");
-        expect(cluster.getCommand("off")).toStrictEqual(command);
+        expect(Zcl.Utils.getClusterCommand(cluster, "off")).toStrictEqual(command);
     });
 
     it("Zcl utils get attribute", () => {
         const cluster = Zcl.Utils.getCluster("genOnOff", undefined, {});
-        const attribute = cluster.getAttribute(16385);
+        const attribute = Zcl.Utils.getClusterAttribute(cluster, 16385, undefined);
         expect(attribute?.name).toStrictEqual("onTime");
-        expect(cluster.getAttribute("onTime")).toStrictEqual(attribute);
+        expect(Zcl.Utils.getClusterAttribute(cluster, "onTime", undefined)).toStrictEqual(attribute);
     });
 
     it("Zcl utils get attribute non-existing", () => {
         const cluster = Zcl.Utils.getCluster("genOnOff", undefined, {});
-        expect(cluster.getAttribute("notExisting")).toBeUndefined();
+        expect(Zcl.Utils.getClusterAttribute(cluster, "notExisting", undefined)).toBeUndefined();
     });
 
     it("Zcl utils get command non-existing", () => {
         const cluster = Zcl.Utils.getCluster("genOnOff", undefined, {});
-        expect(() => cluster.getCommand("notExisting")).toThrow("Cluster 'genOnOff' has no command 'notExisting'");
+        expect(() => Zcl.Utils.getClusterCommand(cluster, "notExisting")).toThrow("Status 'UNSUP_COMMAND' genOnOff:notExisting");
     });
 
     it("Zcl green power readGpd commissioning", () => {
@@ -2159,6 +2128,7 @@ describe("Zcl", () => {
         ).toStrictEqual({
             manufacturerCode: 13330,
             clusterID: 65535,
+            clusterName: "65535",
             attributes: {
                 "0": 50462976,
                 "1": "ZIGBEE",
@@ -2321,7 +2291,12 @@ describe("Zcl", () => {
             0x11, 0x01, 0xf0, 0x08, 0x84, 0x2b, 0x01, 0x98, 0x2b, 0x02, 0xac, 0x2b, 0x03, 0xc0, 0x2b, 0x04, 0xd4, 0x2b, 0x05, 0xe8, 0x2b, 0x06, 0xfc,
             0x2b, 0x07, 0x10, 0x2c, 0x08,
         ]);
-        const zoneConfigFrame = Zcl.Frame.fromBuffer(Zcl.Clusters.genGroups.ID, Zcl.Header.fromBuffer(zoneConfigPayload)!, zoneConfigPayload, {});
+        const zoneConfigFrame = Zcl.Frame.fromBuffer(
+            Zcl.Clusters.genGroups.ID,
+            Zcl.Header.fromBuffer(zoneConfigPayload)!,
+            zoneConfigPayload,
+            MIBOXER_GROUPS_CUSTOM_CLUSTER,
+        );
         expect(zoneConfigFrame.payload.zones).toStrictEqual([
             {zoneNum: 1, groupId: 0x2b84},
             {zoneNum: 2, groupId: 0x2b98},
@@ -2353,7 +2328,7 @@ describe("Zcl", () => {
             "miboxerSetZones",
             Zcl.Clusters.genGroups.ID,
             {zones: testZones},
-            {},
+            MIBOXER_GROUPS_CUSTOM_CLUSTER,
         );
         expect(zoneConfigFrame.toBuffer()).toStrictEqual(
             Buffer.from([

package/test/zspec/zcl/buffalo.test.ts

@@ -134,11 +134,34 @@ describe("ZCL Buffalo", () => {
             {value: 4294967290, types: [Zcl.DataType.DATA32, Zcl.DataType.BITMAP32, Zcl.DataType.UINT32, Zcl.DataType.UTC, Zcl.DataType.BAC_OID]},
             {position: 4, write: "writeUInt32", read: "readUInt32"},
         ],
+        [
+            "uint40-like",
+            {value: 1099511627770, types: [Zcl.DataType.DATA40, Zcl.DataType.BITMAP40, Zcl.DataType.UINT40]},
+            {position: 5, write: "writeUInt40", read: "readUInt40"},
+        ],
+        [
+            "uint48-like",
+            {value: 281474976710650, types: [Zcl.DataType.DATA48, Zcl.DataType.BITMAP48, Zcl.DataType.UINT48]},
+            {position: 6, write: "writeUInt48", read: "readUInt48"},
+        ],
+        [
+            "uint56-like",
+            {value: 72057594037927935n, types: [Zcl.DataType.DATA56, Zcl.DataType.BITMAP56, Zcl.DataType.UINT56]},
+            {position: 7, write: "writeUInt56", read: "readUInt56"},
+        ],
+        [
+            "uint64-like",
+            {value: 18446744073709551610n, types: [Zcl.DataType.DATA64, Zcl.DataType.BITMAP64, Zcl.DataType.UINT64]},
+            {position: 8, write: "writeUInt64", read: "readUInt64"},
+        ],
         ["int8-like", {value: -120, types: [Zcl.DataType.INT8]}, {position: 1, write: "writeInt8", read: "readInt8"}],
         ["int16-like", {value: -32760, types: [Zcl.DataType.INT16]}, {position: 2, write: "writeInt16", read: "readInt16"}],
         ["int24-like", {value: -8388600, types: [Zcl.DataType.INT24]}, {position: 3, write: "writeInt24", read: "readInt24"}],
         ["int32-like", {value: -2147483640, types: [Zcl.DataType.INT32]}, {position: 4, write: "writeInt32", read: "readInt32"}],
+        ["int40-like", {value: -549755813887, types: [Zcl.DataType.INT40]}, {position: 5, write: "writeInt40", read: "readInt40"}],
         ["int48-like", {value: -140737488355320, types: [Zcl.DataType.INT48]}, {position: 6, write: "writeInt48", read: "readInt48"}],
+        ["int56-like", {value: -36028797018963960n, types: [Zcl.DataType.INT56]}, {position: 7, write: "writeInt56", read: "readInt56"}],
+        ["int64-like", {value: -9223372036854775800n, types: [Zcl.DataType.INT64]}, {position: 8, write: "writeInt64", read: "readInt64"}],
         ["float-like", {value: 1.539989614439558e-36, types: [Zcl.DataType.SINGLE_PREC]}, {position: 4, write: "writeFloatLE", read: "readFloatLE"}],
         [
             "double-like",
@@ -1109,19 +1132,48 @@ describe("ZCL Buffalo", () => {
 
         it("Reads attribute report", () => {
             const value = [
-                0x12,
-                0x34, // Manufacturer ID
-                0xff,
-                0xff, // Cluster ID
                 0x00,
+                0x00, // Cluster ID
+                0x01,
                 0x00, // Attribute ID
-                Zcl.DataType.UINT32, // Attribute Type
-                0x00,
+                Zcl.DataType.UINT8, // Attribute Type
+                0xff,
                 0x01,
+                0x10,
+                Zcl.DataType.CHAR_STR,
+                0x06,
+                0x5a,
+                0x49,
+                0x47,
+                0x42,
+                0x45,
+                0x45,
                 0x02,
-                0x03,
+                0x10,
+                Zcl.DataType.BOOLEAN,
                 0x01,
+            ];
+            const buffalo = new BuffaloZcl(Buffer.from(value));
+
+            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0xa0, payloadSize: value.length}})).toStrictEqual({
+                clusterID: 0x0000,
+                clusterName: "genBasic",
+                attributes: {appVersion: 0xff, 4097: "ZIGBEE", 4098: 1},
+            });
+        });
+
+        it("Reads manufacturer-specific attribute report", () => {
+            const value = [
+                0x12,
+                0x34, // Manufacturer ID
                 0x00,
+                0x00, // Cluster ID
+                0x00,
+                0x00, // Attribute ID
+                Zcl.DataType.UINT8, // Attribute Type
+                0x08,
+                0x01,
+                0x20,
                 Zcl.DataType.CHAR_STR,
                 0x06,
                 0x5a,
@@ -1131,16 +1183,154 @@ describe("ZCL Buffalo", () => {
                 0x45,
                 0x45,
                 0x02,
-                0x00,
+                0x20,
                 Zcl.DataType.BOOLEAN,
                 0x01,
             ];
             const buffalo = new BuffaloZcl(Buffer.from(value));
 
             expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0xa1, payloadSize: value.length}})).toStrictEqual({
-                manufacturerCode: 13330,
-                clusterID: 65535,
-                attributes: {"0": 50462976, "1": "ZIGBEE", "2": 1},
+                manufacturerCode: 0x3412,
+                clusterID: 0x0000,
+                clusterName: "genBasic",
+                attributes: {zclVersion: 8, 8193: "ZIGBEE", 8194: 1},
+            });
+        });
+
+        it("Reads multi-cluster attribute report", () => {
+            const value = [
+                0xff,
+                0xff, // Cluster ID
+                0x00,
+                0x00, // Attribute ID
+                Zcl.DataType.UINT32, // Attribute Type
+                0x00,
+                0x01,
+                0x02,
+                0x03,
+                0x00,
+                0x00, // Cluster ID
+                0x01,
+                0x00, // Attribute ID
+                Zcl.DataType.UINT8, // Attribute Type
+                0x10,
+            ];
+            const buffalo = new BuffaloZcl(Buffer.from(value));
+
+            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0xa2, payloadSize: value.length}})).toStrictEqual({
+                reports: [
+                    {
+                        clusterID: 0xffff,
+                        clusterName: "65535",
+                        attribute: 0,
+                        attrData: 50462976,
+                    },
+                    {
+                        clusterID: 0x0000,
+                        clusterName: "genBasic",
+                        attribute: "appVersion",
+                        attrData: 0x10,
+                    },
+                ],
+            });
+        });
+
+        it("Reads manufacturer-specific multi-cluster attribute report", () => {
+            const value = [
+                0xef,
+                0xf3, // Manufacturer code
+                0x00,
+                0x00, // Cluster ID
+                0x00,
+                0x00, // Attribute ID
+                Zcl.DataType.UINT8, // Attribute Type
+                0x08,
+                0xff,
+                0xfe, // Cluster ID
+                0x00,
+                0x01, // Attribute ID
+                Zcl.DataType.UINT16, // Attribute Type
+                0x10,
+                0x11,
+            ];
+            const buffalo = new BuffaloZcl(Buffer.from(value));
+
+            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0xa3, payloadSize: value.length}})).toStrictEqual({
+                manufacturerCode: 0xf3ef,
+                reports: [
+                    {
+                        clusterID: 0x0000,
+                        clusterName: "genBasic",
+                        attribute: "zclVersion",
+                        attrData: 8,
+                    },
+                    {
+                        clusterID: 0xfeff,
+                        clusterName: "65279",
+                        attribute: 0x0100,
+                        attrData: 4368,
+                    },
+                ],
+            });
+        });
+
+        it("Reads attribute request", () => {
+            const value = [
+                0x02, // Options
+                0xfe,
+                0xef, // Manufacturer code
+                0xff,
+                0xff, // Cluster ID
+                0x02, // Length
+                0x00,
+                0x00, // Attribute ID
+                0x00,
+                0x01, // Attribute ID
+            ];
+            const buffalo = new BuffaloZcl(Buffer.from(value));
+
+            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0xa4, payloadSize: value.length}})).toStrictEqual({
+                options: 0x02,
+                manufacturerID: 0xeffe,
+                records: [{clusterID: 0xffff, attributes: [0x0000, 0x0100]}],
+            });
+        });
+
+        it("Reads attribute response", () => {
+            const value = [
+                0x02, // Options
+                0xfe,
+                0xef, // Manufacturer code
+                0x00,
+                0x00, // Cluster ID
+                0x02, // Length
+                0x00,
+                0x00, // Attribute ID
+                0x00, // Status
+                Zcl.DataType.UINT8, // Data type
+                0x08, // Attr data
+                0xfc,
+                0xff, // Attribute ID
+                0x00, // Status
+                Zcl.DataType.UINT16, // Data type
+                0x00,
+                0x10, // Attr data
+            ];
+            const buffalo = new BuffaloZcl(Buffer.from(value));
+
+            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0xa5, payloadSize: value.length}})).toStrictEqual({
+                options: 0x02,
+                manufacturerID: 0xeffe,
+                records: [
+                    {
+                        clusterID: 0x0000,
+                        clusterName: "genBasic",
+                        attributes: {
+                            zclVersion: {status: Zcl.Status.SUCCESS, attrData: 0x08},
+                            65532: {status: Zcl.Status.SUCCESS, attrData: 0x1000},
+                        },
+                    },
+                ],
             });
         });
 
@@ -1298,6 +1488,56 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expectedWritten.length);
     });
 
+    it("Reads Mi Struct", () => {
+        const buffer = Buffer.from([
+            34, 1, 33, 213, 12, 3, 40, 33, 4, 33, 168, 19, 5, 33, 43, 0, 6, 36, 0, 0, 5, 0, 0, 8, 33, 4, 2, 10, 33, 0, 0, 100, 16, 0,
+        ]);
+        const buffalo = new BuffaloZcl(buffer);
+
+        expect(buffalo.read(Zcl.BuffaloZclDataType.MI_STRUCT, {})).toStrictEqual({
+            "1": 3285,
+            "3": 33,
+            "4": 5032,
+            "5": 43,
+            "6": 327680,
+            "8": 516,
+            "10": 0,
+            "100": 0,
+        });
+        expect(buffalo.getPosition()).toStrictEqual(buffer.byteLength);
+    });
+
+    it("Reads Mi Struct with padding", () => {
+        const buffer = Buffer.from([
+            68, 3, 40, 29, 5, 33, 190, 45, 8, 33, 47, 18, 9, 33, 2, 21, 100, 16, 1, 101, 16, 0, 110, 32, 255, 111, 32, 255, 148, 32, 4, 149, 57, 184,
+            30, 21, 62, 150, 57, 211, 249, 17, 69, 151, 57, 0, 48, 104, 59, 152, 57, 0, 0, 0, 0, 155, 33, 1, 0, 156, 32, 1, 10, 33, 56, 38, 12, 40, 0,
+            0,
+        ]);
+
+        const buffalo = new BuffaloZcl(buffer);
+
+        expect(buffalo.read(Zcl.BuffaloZclDataType.MI_STRUCT, {})).toStrictEqual({
+            "3": 29,
+            "5": 11710,
+            "8": 4655,
+            "9": 5378,
+            "10": 9784,
+            "12": 0,
+            "100": 1,
+            "101": 0,
+            "110": 255,
+            "111": 255,
+            "148": 4,
+            "149": 0.14562499523162842,
+            "150": 2335.614013671875,
+            "151": 0.0035429000854492188,
+            "152": 0,
+            "155": 1,
+            "156": 1,
+        });
+        expect(buffalo.getPosition()).toStrictEqual(buffer.byteLength);
+    });
+
     it("Writes & Reads big endian uint24", () => {
         const value = 16777200;
         const expectedWritten = [0xff, 0xff, 0xf0];