@willieee802/zigbee-herdsman 0.49.3 → 0.50.0

package/test/controller.test.ts

@@ -10,6 +10,7 @@ import Request from "../src/controller/helpers/request";
 import zclTransactionSequenceNumber from "../src/controller/helpers/zclTransactionSequenceNumber";
 import {Device, Endpoint, Group} from "../src/controller/model";
 import {InterviewState} from "../src/controller/model/device";
+import type {TCustomCluster} from "../src/controller/tstype";
 import type * as Models from "../src/models";
 import * as Utils from "../src/utils";
 import {setLogger} from "../src/utils/logger";
@@ -207,9 +208,11 @@ const mockAdapterSendZdo = vi
 
 let iasZoneReadState170Count = 0;
 let enroll170 = true;
+let enrollRspThrow = false;
 let configureReportStatus = 0;
 let configureReportDefaultRsp = false;
 let lastSentZclFrameToEndpoint: Buffer | undefined;
+let readManufacturerCode: number | undefined;
 
 const restoreMocksendZclFrameToEndpoint = () => {
     mocksendZclFrameToEndpoint.mockImplementation((_ieeeAddr, networkAddress, endpoint, frame: Zcl.Frame) => {
@@ -223,24 +226,31 @@ const restoreMocksendZclFrameToEndpoint = () => {
             const payload: {[key: string]: unknown}[] = [];
             const cluster = frame.cluster;
             for (const item of frame.payload) {
-                if (item.attrId !== 65314) {
-                    const attribute = cluster.getAttribute(item.attrId);
+                if (item.attrId === 65314) {
+                    payload.push({
+                        attrId: item.attrId,
+                        status: Zcl.Status.SUCCESS,
+                        dataType: Zcl.DataType.UINT16,
+                        attrData: 0x4312,
+                    });
+                } else {
+                    const attribute = Zcl.Utils.getClusterAttribute(cluster, item.attrId, readManufacturerCode);
 
                     if (attribute) {
                         if (frame.isCluster("ssIasZone") && item.attrId === 0) {
                             iasZoneReadState170Count++;
                             payload.push({
                                 attrId: item.attrId,
+                                status: Zcl.Status.SUCCESS,
                                 dataType: attribute.type,
                                 attrData: iasZoneReadState170Count === 2 && enroll170 ? 1 : 0,
-                                status: 0,
                             });
                         } else {
                             payload.push({
                                 attrId: item.attrId,
+                                status: Zcl.Status.SUCCESS,
                                 dataType: attribute.type,
                                 attrData: MOCK_DEVICES[networkAddress]!.attributes![endpoint][attribute.name],
-                                status: 0,
                             });
                         }
                     }
@@ -260,12 +270,16 @@ const restoreMocksendZclFrameToEndpoint = () => {
                 10,
                 `${frame.command.name}Rsp`,
                 frame.cluster.ID,
-                {status: 0, groupid: 1},
+                {status: Zcl.Status.SUCCESS, groupid: 1},
                 {},
             );
             return {clusterID: frame.cluster.ID, header: responseFrame.header, data: responseFrame.toBuffer()};
         }
 
+        if (frame.header.isSpecific && frame.command.name === "enrollRsp" && frame.cluster.name === "ssIasZone" && enrollRspThrow) {
+            throw new Error("ias-zone-failure");
+        }
+
         if (
             networkAddress === 170 &&
             frame.header.isGlobal &&
@@ -301,7 +315,7 @@ const restoreMocksendZclFrameToEndpoint = () => {
         if (frame.header.isGlobal && frame.isCommand("write")) {
             const payload: {[key: string]: unknown}[] = [];
             for (const item of frame.payload) {
-                payload.push({attrId: item.attrId, status: 0});
+                payload.push({attrId: item.attrId, status: Zcl.Status.SUCCESS});
             }
 
             const responseFrame = Zcl.Frame.create(0, 1, true, undefined, 10, "writeRsp", 0, payload, {});
@@ -460,6 +474,78 @@ const options = {
 
 const databaseContents = () => fs.readFileSync(options.databasePath).toString();
 
+const CUSTOM_CLUSTERS = {
+    hvacThermostat: {
+        name: "hvacThermostat",
+        ID: 0x0201,
+        attributes: {
+            viessmannWindowOpenInternal: {
+                name: "viessmannWindowOpenInternal",
+                ID: 0x4000,
+                type: Zcl.DataType.ENUM8,
+                manufacturerCode: Zcl.ManufacturerCode.VIESSMANN_ELEKTRONIK_GMBH,
+                write: true,
+                max: 0xff,
+            },
+        },
+        commands: {},
+        commandsResponse: {},
+    },
+    closuresWindowCovering: {
+        name: "closuresWindowCovering",
+        ID: Zcl.Clusters.closuresWindowCovering.ID,
+        attributes: {
+            calibrationMode: {
+                name: "calibrationMode",
+                ID: 0xf002,
+                type: Zcl.DataType.ENUM8,
+                manufacturerCode: Zcl.ManufacturerCode.LEGRAND_GROUP,
+                write: true,
+                max: 0xff,
+            },
+            tuyaMotorReversal: {name: "tuyaMotorReversal", ID: 0xf002, type: Zcl.DataType.ENUM8, write: true, max: 0xff},
+        },
+        commands: {},
+        commandsResponse: {},
+    },
+    lightingColorCtrl: {
+        name: "lightingColorCtrl",
+        ID: Zcl.Clusters.lightingColorCtrl.ID,
+        attributes: {},
+        commands: {
+            tuyaMoveToHueAndSaturationBrightness: {
+                name: "tuyaMoveToHueAndSaturationBrightness",
+                ID: 0x06,
+                parameters: [
+                    {name: "hue", type: Zcl.DataType.UINT8, max: 0xff},
+                    {name: "saturation", type: Zcl.DataType.UINT8, max: 0xff},
+                    {name: "transtime", type: Zcl.DataType.UINT16, max: 0xffff},
+                    {name: "brightness", type: Zcl.DataType.UINT8, max: 0xff},
+                ],
+            },
+        },
+        commandsResponse: {},
+    },
+} satisfies CustomClusters;
+
+interface CustomClustersTypes extends Record<string, TCustomCluster> {
+    hvacThermostat: {
+        attributes: {
+            viessmannWindowOpenInternal: number;
+        };
+        commands: never;
+        commandResponses: never;
+    };
+    closuresWindowCovering: {
+        attributes: {
+            calibrationMode: number;
+            tuyaMotorReversal: number;
+        };
+        commands: never;
+        commandResponses: never;
+    };
+}
+
 describe("Controller", () => {
     let controller: Controller;
     let mockedDate: Date;
@@ -480,6 +566,7 @@ describe("Controller", () => {
 
     beforeEach(() => {
         vi.setSystemTime(mockedDate);
+        readManufacturerCode = undefined;
         sendZdoResponseStatus = Zdo.Status.SUCCESS;
         for (const m of mocksRestore) m.mockRestore();
         for (const m of mocksClear) m.mockClear();
@@ -490,6 +577,7 @@ describe("Controller", () => {
         configureReportStatus = 0;
         configureReportDefaultRsp = false;
         enroll170 = true;
+        enrollRspThrow = false;
         options.network.channelList = [15];
 
         for (const event in events) {
@@ -2297,8 +2385,7 @@ describe("Controller", () => {
 
     it("Device joins and interview iAs enrollment succeeds", async () => {
         await controller.start();
-        const event = mockAdapterEvents.deviceJoined({networkAddress: 170, ieeeAddr: "0x170"});
-        await event;
+        await mockAdapterEvents.deviceJoined({networkAddress: 170, ieeeAddr: "0x170"});
         expect(events.deviceInterview.length).toBe(2);
         expect(events.deviceInterview[0].status).toBe("started");
         // @ts-expect-error private but deep cloned
@@ -2325,7 +2412,6 @@ describe("Controller", () => {
             command: {
                 ID: 2,
                 name: "write",
-                parameters: expect.any(Array),
                 response: 4,
             },
         });
@@ -2337,7 +2423,7 @@ describe("Controller", () => {
         expect(deepClone(enrollRsp[3])).toStrictEqual({
             header: {
                 frameControl: {reservedBits: 0, frameType: 1, direction: 0, disableDefaultResponse: true, manufacturerSpecific: false},
-                transactionSequenceNumber: 11,
+                transactionSequenceNumber: 1,
                 commandIdentifier: 0,
             },
             payload: {enrollrspcode: 0, zoneid: 23},
@@ -2368,6 +2454,20 @@ describe("Controller", () => {
         expect(events.deviceInterview[1].device._ieeeAddr).toBe("0x170");
     });
 
+    it("Device joins and interview iAs enrollment throws", async () => {
+        await controller.start();
+        enrollRspThrow = true;
+        await mockAdapterEvents.deviceJoined({networkAddress: 170, ieeeAddr: "0x170"});
+
+        expect(events.deviceInterview.length).toBe(2);
+        expect(events.deviceInterview[0].status).toBe("started");
+        // @ts-expect-error private but deep cloned
+        expect(events.deviceInterview[0].device._ieeeAddr).toBe("0x170");
+        expect(events.deviceInterview[1].status).toBe("failed");
+        // @ts-expect-error private but deep cloned
+        expect(events.deviceInterview[1].device._ieeeAddr).toBe("0x170");
+    });
+
     it("Device joins, shouldnt enroll when already enrolled", async () => {
         await controller.start();
         iasZoneReadState170Count = 1;
@@ -2532,9 +2632,9 @@ describe("Controller", () => {
         const endpointReadSpy = vi.spyOn(endpoint, "read");
         const endpointDefaultResponseSpy = vi.spyOn(endpoint, "defaultResponse");
 
-        deviceOnZclDataSpy.mockImplementationOnce(async (a, b, c) => {
+        deviceOnZclDataSpy.mockImplementationOnce(async (a, b, c, d) => {
             await mockAdapterEvents.deviceLeave({networkAddress: 129, ieeeAddr: undefined});
-            await device.onZclData(a, b, c);
+            await device.onZclData(a, b, c, d);
         });
 
         await mockAdapterEvents.zclPayload({
@@ -2600,8 +2700,17 @@ describe("Controller", () => {
     });
 
     it("Receive cluster command", async () => {
-        const buffer = Buffer.from([0x05, 0x7c, 0x11, 0x1d, 0x07, 0x00, 0x01, 0x0d, 0x00]);
-        const frame = Zcl.Frame.fromBuffer(5, Zcl.Header.fromBuffer(buffer), buffer, {});
+        const frame = Zcl.Frame.create(
+            Zcl.FrameType.SPECIFIC,
+            Zcl.Direction.SERVER_TO_CLIENT,
+            false,
+            undefined,
+            29,
+            "addRsp",
+            "genScenes",
+            {status: 0, groupId: 10, sceneId: 2},
+            {},
+        );
         await controller.start();
         await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
         await mockAdapterEvents.zclPayload({
@@ -2618,24 +2727,25 @@ describe("Controller", () => {
         expect(events.message.length).toBe(1);
         const expected = {
             cluster: "genScenes",
-            type: "commandTradfriArrowSingle",
+            type: "commandAddRsp",
             device: expect.any(Device),
             endpoint: expect.any(Endpoint),
             data: {
-                value: 256,
-                value2: 13,
+                groupId: 10,
+                sceneId: 2,
+                status: 0,
             },
             linkquality: 19,
             groupID: 10,
             meta: {
                 zclTransactionSequenceNumber: 29,
-                manufacturerCode: 4476,
+                manufacturerCode: undefined,
                 frameControl: {
                     reservedBits: 0,
-                    direction: 0,
+                    direction: 1,
                     disableDefaultResponse: false,
                     frameType: 1,
-                    manufacturerSpecific: true,
+                    manufacturerSpecific: false,
                 },
                 rawData: expect.any(Buffer),
             },
@@ -2680,21 +2790,14 @@ describe("Controller", () => {
 
     it("Receive zclData send default response", async () => {
         const frame = Zcl.Frame.create(
-            1,
-            1,
+            Zcl.FrameType.SPECIFIC,
+            Zcl.Direction.SERVER_TO_CLIENT,
             false,
-            4476,
+            Zcl.ManufacturerCode.IKEA_OF_SWEDEN,
             29,
-            1,
-            5,
-            {
-                groupid: 1,
-                sceneid: 1,
-                status: 0,
-                transtime: 0,
-                scenename: "",
-                extensionfieldsets: [],
-            },
+            "viewRsp",
+            "genScenes",
+            {groupid: 1, sceneid: 1, status: 0, transtime: 0, scenename: "", extensionfieldsets: []},
             {},
         );
         await controller.start();
@@ -2986,11 +3089,8 @@ describe("Controller", () => {
     it("Respond to read of attribute", async () => {
         await controller.start();
         await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
-        const device = controller.getDeviceByIeeeAddr("0x129")!;
-        const endpoint = device.getEndpoint(1)!;
-        endpoint.saveClusterAttributeKeyValue("hvacThermostat", {systemMode: 3});
         mocksendZclFrameToEndpoint.mockClear();
-        const frame = Zcl.Frame.create(0, 0, true, undefined, 40, 0, 513, [{attrId: 28}, {attrId: 290}], {});
+        const frame = Zcl.Frame.create(0, 0, true, undefined, 40, "read", "genTime", [{attrId: 0x0000}, {attrId: 0xfffa}], {});
         await mockAdapterEvents.zclPayload({
             wasBroadcast: false,
             address: 129,
@@ -3013,12 +3113,38 @@ describe("Controller", () => {
                 transactionSequenceNumber: 40,
                 commandIdentifier: 1,
             },
-            payload: [{attrId: 28, attrData: 3, dataType: 48, status: 0}],
+            payload: [
+                {attrId: 0xfffa, status: Zcl.Status.UNSUPPORTED_ATTRIBUTE},
+                {attrId: 0x0000, attrData: expect.any(Number), dataType: Zcl.DataType.UTC, status: Zcl.Status.SUCCESS},
+            ],
             cluster: null,
-            command: expect.objectContaining({
-                ID: 1,
-                name: "readRsp",
-            }),
+            command: expect.objectContaining({ID: 1, name: "readRsp"}),
+        });
+    });
+
+    it("Sends read response for unsupported attribute", async () => {
+        await controller.start();
+        await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
+        const device = controller.getDeviceByIeeeAddr("0x129")!;
+        const endpoint = device.getEndpoint(1)!;
+        mocksendZclFrameToEndpoint.mockClear();
+
+        endpoint.readResponse("genGroups", 1, {nameSupport: undefined}, {srcEndpoint: 1});
+
+        expect(mocksendZclFrameToEndpoint).toHaveBeenCalledTimes(1);
+        const call = mocksendZclFrameToEndpoint.mock.calls[0];
+        expect(call[0]).toBe("0x129");
+        expect(call[1]).toBe(129);
+        expect(call[2]).toBe(1);
+        expect(deepClone({...call[3], cluster: null})).toStrictEqual({
+            header: {
+                frameControl: {reservedBits: 0, frameType: 0, direction: 1, disableDefaultResponse: true, manufacturerSpecific: false},
+                transactionSequenceNumber: 1,
+                commandIdentifier: 1,
+            },
+            payload: [{attrId: 0x0000, status: Zcl.Status.UNSUPPORTED_ATTRIBUTE}],
+            cluster: null,
+            command: expect.objectContaining({ID: 1, name: "readRsp"}),
         });
     });
 
@@ -3330,12 +3456,13 @@ describe("Controller", () => {
         await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
         const device = controller.getDeviceByIeeeAddr("0x129")!;
         device.addCustomCluster("genBasic", {
+            name: "genBasic",
             ID: 0,
             commands: {},
             commandsResponse: {},
             attributes: {
-                customAttr: {ID: 256, type: Zcl.DataType.UINT8},
-                aDifferentZclVersion: {ID: 0, type: Zcl.DataType.UINT8},
+                customAttr: {name: "customAttr", ID: 256, type: Zcl.DataType.UINT8},
+                aDifferentZclVersion: {name: "aDifferentZclVersion", ID: 0, type: Zcl.DataType.UINT8},
             },
         });
         const buffer = Buffer.from([24, 169, 10, 0, 1, 24, 3, 0, 0, 24, 1, 2, 0, 24, 1]);
@@ -3348,11 +3475,12 @@ describe("Controller", () => {
 
         // Should allow to extend an already extended cluster again.
         device.addCustomCluster("genBasic", {
+            name: "genBasic",
             ID: 0,
             commands: {},
             commandsResponse: {},
             attributes: {
-                customAttrSecondOverride: {ID: 256, type: Zcl.DataType.UINT8},
+                customAttrSecondOverride: {name: "customAttrSecondOverride", ID: 256, type: Zcl.DataType.UINT8},
             },
         });
         await mockAdapterEvents.zclPayload(payload);
@@ -3366,10 +3494,11 @@ describe("Controller", () => {
         await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
         const device = controller.getDeviceByIeeeAddr("0x129")!;
         device.addCustomCluster("myCustomCluster", {
+            name: "myCustomCluster",
             ID: 9123,
             commands: {},
             commandsResponse: {},
-            attributes: {superAttribute: {ID: 0, type: Zcl.DataType.UINT8}},
+            attributes: {superAttribute: {name: "superAttribute", ID: 0, type: Zcl.DataType.UINT8}},
         });
         const buffer = Buffer.from([24, 169, 10, 0, 1, 24, 3, 0, 0, 24, 1]);
         const header = Zcl.Header.fromBuffer(buffer);
@@ -3393,10 +3522,11 @@ describe("Controller", () => {
         await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
         const device = controller.getDeviceByIeeeAddr("0x129")!;
         device.addCustomCluster("myCustomCluster", {
+            name: "myCustomCluster",
             ID: Zcl.Clusters.genBasic.ID,
             commands: {},
             commandsResponse: {},
-            attributes: {customAttr: {ID: 256, type: Zcl.DataType.UINT8}},
+            attributes: {customAttr: {name: "customAttr", ID: 256, type: Zcl.DataType.UINT8}},
         });
         const buffer = Buffer.from([24, 169, 10, 0, 1, 24, 3, 0, 0, 24, 1]);
         const header = Zcl.Header.fromBuffer(buffer);
@@ -3462,17 +3592,28 @@ describe("Controller", () => {
         }
 
         device.addCustomCluster("hvacThermostat", {
+            name: "hvacThermostat",
             ID: 0x0201,
             attributes: {
-                localTemperatureCalibration: {ID: 0x0010, type: Zcl.DataType.INT8, write: true, min: -50, max: 50, default: 0},
+                localTemperatureCalibration: {
+                    name: "localTemperatureCalibration",
+                    ID: 0x0010,
+                    type: Zcl.DataType.INT8,
+                    write: true,
+                    min: -50,
+                    max: 50,
+                    default: 0,
+                },
             },
             commands: {},
             commandsResponse: {},
         });
         device.addCustomCluster("hvacThermostat", {
+            name: "hvacThermostat",
             ID: Zcl.Clusters.hvacThermostat.ID,
             attributes: {
                 operatingMode: {
+                    name: "operatingMode",
                     ID: 0x4007,
                     type: Zcl.DataType.ENUM8,
                     manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
@@ -3480,6 +3621,7 @@ describe("Controller", () => {
                     max: 0xff,
                 },
                 heatingDemand: {
+                    name: "heatingDemand",
                     ID: 0x4020,
                     type: Zcl.DataType.ENUM8,
                     manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
@@ -3487,6 +3629,7 @@ describe("Controller", () => {
                     max: 0xff,
                 },
                 valveAdaptStatus: {
+                    name: "valveAdaptStatus",
                     ID: 0x4022,
                     type: Zcl.DataType.ENUM8,
                     manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
@@ -3494,6 +3637,7 @@ describe("Controller", () => {
                     max: 0xff,
                 },
                 unknownAttribute0: {
+                    name: "unknownAttribute0",
                     ID: 0x4025,
                     type: Zcl.DataType.ENUM8,
                     manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
@@ -3501,6 +3645,7 @@ describe("Controller", () => {
                     max: 0xff,
                 },
                 remoteTemperature: {
+                    name: "remoteTemperature",
                     ID: 0x4040,
                     type: Zcl.DataType.INT16,
                     manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
@@ -3508,6 +3653,7 @@ describe("Controller", () => {
                     min: -32768,
                 },
                 unknownAttribute1: {
+                    name: "unknownAttribute1",
                     ID: 0x4041,
                     type: Zcl.DataType.ENUM8,
                     manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
@@ -3515,6 +3661,7 @@ describe("Controller", () => {
                     max: 0xff,
                 },
                 windowOpenMode: {
+                    name: "windowOpenMode",
                     ID: 0x4042,
                     type: Zcl.DataType.ENUM8,
                     manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
@@ -3522,6 +3669,7 @@ describe("Controller", () => {
                     max: 0xff,
                 },
                 boostHeating: {
+                    name: "boostHeating",
                     ID: 0x4043,
                     type: Zcl.DataType.ENUM8,
                     manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
@@ -3529,14 +3677,23 @@ describe("Controller", () => {
                     max: 0xff,
                 },
                 cableSensorTemperature: {
+                    name: "cableSensorTemperature",
                     ID: 0x4052,
                     type: Zcl.DataType.INT16,
                     manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
                     write: true,
                     min: -32768,
                 },
-                valveType: {ID: 0x4060, type: Zcl.DataType.ENUM8, manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH, write: true, max: 0xff},
+                valveType: {
+                    name: "valveType",
+                    ID: 0x4060,
+                    type: Zcl.DataType.ENUM8,
+                    manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+                    write: true,
+                    max: 0xff,
+                },
                 unknownAttribute2: {
+                    name: "unknownAttribute2",
                     ID: 0x4061,
                     type: Zcl.DataType.ENUM8,
                     manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
@@ -3544,15 +3701,30 @@ describe("Controller", () => {
                     max: 0xff,
                 },
                 cableSensorMode: {
+                    name: "cableSensorMode",
                     ID: 0x4062,
                     type: Zcl.DataType.ENUM8,
                     manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
                     write: true,
                     max: 0xff,
                 },
-                heaterType: {ID: 0x4063, type: Zcl.DataType.ENUM8, manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH, write: true, max: 0xff},
-                errorState: {ID: 0x5000, type: Zcl.DataType.BITMAP8, manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH, write: true},
+                heaterType: {
+                    name: "heaterType",
+                    ID: 0x4063,
+                    type: Zcl.DataType.ENUM8,
+                    manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+                    write: true,
+                    max: 0xff,
+                },
+                errorState: {
+                    name: "errorState",
+                    ID: 0x5000,
+                    type: Zcl.DataType.BITMAP8,
+                    manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+                    write: true,
+                },
                 automaticValveAdapt: {
+                    name: "automaticValveAdapt",
                     ID: 0x5010,
                     type: Zcl.DataType.ENUM8,
                     manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
@@ -3561,7 +3733,7 @@ describe("Controller", () => {
                 },
             },
             commands: {
-                calibrateValve: {ID: 0x41, parameters: []},
+                calibrateValve: {name: "calibrateValve", ID: 0x41, parameters: []},
             },
             commandsResponse: {},
         });
@@ -3590,11 +3762,13 @@ describe("Controller", () => {
             ),
         ).rejects.toThrow("localTemperatureCalibration requires max of 50");
 
+        readManufacturerCode = Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH;
         await expect(
             endpoint.read<"hvacThermostat", BoschThermostatCluster>("hvacThermostat", ["boostHeating", "operatingMode"], {
                 manufacturerCode: Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
             }),
         ).resolves.toStrictEqual({16391: 0, 16451: 0});
+        readManufacturerCode = undefined;
     });
 
     it("Send zcl command to all no options", async () => {
@@ -3625,8 +3799,11 @@ describe("Controller", () => {
         await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
         const device = controller.getDeviceByIeeeAddr("0x129")!;
         device.addCustomCluster("ssIasZone", {
+            name: "ssIasZone",
             ID: Zcl.Clusters.ssIasZone.ID,
-            commands: {boschSmokeAlarmSiren: {ID: 0x80, parameters: [{name: "data", type: Zcl.DataType.UINT16, max: 0xffff}]}},
+            commands: {
+                boschSmokeAlarmSiren: {name: "boschSmokeAlarmSiren", ID: 0x80, parameters: [{name: "data", type: Zcl.DataType.UINT16, max: 0xffff}]},
+            },
             commandsResponse: {},
             attributes: {},
         });
@@ -4032,13 +4209,24 @@ describe("Controller", () => {
         expect(device.checkinInterval).toBeUndefined();
         expect(device.pendingRequestTimeout).toStrictEqual(0);
         mocksendZclFrameToEndpoint.mockClear();
-        mocksendZclFrameToEndpoint.mockReturnValueOnce(null);
+        mocksendZclFrameToEndpoint.mockReturnValueOnce(undefined);
+        const newCheckinInterval = 204;
         mocksendZclFrameToEndpoint.mockImplementationOnce((_ieeeAddr, _networkAddress, _endpoint, frame: Zcl.Frame) => {
-            const payload = [{attrId: 0, status: 0, dataType: 35, attrData: 204}];
+            const payload = [
+                {
+                    attrId: Zcl.Clusters.genPollCtrl.attributes.checkinInterval.ID,
+                    status: Zcl.Status.SUCCESS,
+                    dataType: Zcl.DataType.UINT32,
+                    attrData: newCheckinInterval,
+                },
+            ];
             const responseFrame = Zcl.Frame.create(0, 1, true, undefined, 10, "readRsp", frame.cluster.ID, payload, {});
             return {header: responseFrame.header, data: responseFrame.toBuffer(), clusterID: frame.cluster.ID};
         });
-        mocksendZclFrameToEndpoint.mockImplementationOnce(() => vi.advanceTimersByTime(10));
+        mocksendZclFrameToEndpoint.mockImplementationOnce(() => {
+            vi.advanceTimersByTime(10);
+            return undefined;
+        });
         let frame = Zcl.Frame.create(
             Zcl.FrameType.SPECIFIC,
             Zcl.Direction.SERVER_TO_CLIENT,
@@ -4061,10 +4249,9 @@ describe("Controller", () => {
             groupID: undefined,
         });
         await flushPromises();
-        expect(device.checkinInterval).toStrictEqual(51);
-        expect(device.pendingRequestTimeout).toStrictEqual(51000);
+        expect(device.checkinInterval).toStrictEqual(newCheckinInterval / 4);
+        expect(device.pendingRequestTimeout).toStrictEqual((newCheckinInterval / 4) * 1000);
         expect(mocksendZclFrameToEndpoint).toHaveBeenCalledTimes(3);
-        device.checkinInterval = 50;
 
         mocksendZclFrameToEndpoint.mockClear();
         frame = Zcl.Frame.create(
@@ -4095,6 +4282,36 @@ describe("Controller", () => {
         expect(call[3].cluster.name).toBe("genPollCtrl");
         expect(call[3].command.name).toBe("checkinRsp");
         expect(call[3].payload).toStrictEqual({startFastPolling: 0, fastPollTimeout: 0});
+
+        await mockAdapterEvents.zdoResponse(Zdo.ClusterId.END_DEVICE_ANNOUNCE, [
+            Zdo.Status.SUCCESS,
+            {
+                nwkAddress: 174,
+                eui64: "0x174",
+                capabilities: {
+                    allocateAddress: 0,
+                    alternatePANCoordinator: 0,
+                    deviceType: 0,
+                    powerSource: 0,
+                    reserved1: 0,
+                    reserved2: 0,
+                    rxOnWhenIdle: 0,
+                    securityCapability: 0,
+                },
+            },
+        ]);
+
+        // doesn't reset on announce
+        expect(device.checkinInterval).toStrictEqual(newCheckinInterval / 4);
+        expect(device.pendingRequestTimeout).toStrictEqual((newCheckinInterval / 4) * 1000);
+
+        device.removeFromDatabase();
+
+        await mockAdapterEvents.deviceJoined({networkAddress: 174, ieeeAddr: "0x174"});
+
+        // resets on join
+        expect(device.checkinInterval).toStrictEqual(DEFAULT_184_CHECKIN_INTERVAL / 4);
+        expect(device.pendingRequestTimeout).toStrictEqual((DEFAULT_184_CHECKIN_INTERVAL / 4) * 1000);
     });
 
     it("Poll control unsupported", async () => {
@@ -4437,11 +4654,11 @@ describe("Controller", () => {
         mocksendZclFrameToEndpoint.mockClear();
 
         // @ts-expect-error private
-        endpoint._configuredReportings = [{cluster: 65281, attrId: 269, minRepIntval: 60, maxRepIntval: 900, repChange: 1}];
+        endpoint._configuredReportings = [{cluster: 0xfc57, attrId: 0x0005, minRepIntval: 60, maxRepIntval: 900, repChange: 1}];
 
-        await endpoint.configureReporting("manuSpecificSinope", [
+        await endpoint.configureReporting("manuSpecificAmazonWWAH", [
             {
-                attribute: "roomTemperature",
+                attribute: "macRetryCount",
                 minimumReportInterval: 1,
                 maximumReportInterval: 10,
                 reportableChange: 1,
@@ -4449,8 +4666,8 @@ describe("Controller", () => {
         ]);
 
         expect(endpoint.configuredReportings.length).toBe(1);
-        expect(endpoint.configuredReportings[0].attribute.name).toBe("roomTemperature");
-        expect(endpoint.configuredReportings[0].cluster.name).toBe("manuSpecificSinope");
+        expect(endpoint.configuredReportings[0].attribute.name).toBe("macRetryCount");
+        expect(endpoint.configuredReportings[0].cluster.name).toBe("manuSpecificAmazonWWAH");
     });
 
     it("Endpoint configure reporting for manufacturer specific attribute", async () => {
@@ -4459,9 +4676,10 @@ describe("Controller", () => {
         const device = controller.getDeviceByIeeeAddr("0x129")!;
         // @ts-expect-error private
         device._manufacturerID = 4641;
+        device.addCustomCluster("hvacThermostat", CUSTOM_CLUSTERS.hvacThermostat);
         const endpoint = device.getEndpoint(1)!;
         mocksendZclFrameToEndpoint.mockClear();
-        await endpoint.configureReporting(
+        await endpoint.configureReporting<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>(
             "hvacThermostat",
             [
                 {
@@ -4478,7 +4696,7 @@ describe("Controller", () => {
         expect(call[0]).toBe("0x129");
         expect(call[1]).toBe(129);
         expect(call[2]).toBe(1);
-        expect(deepClone(call[3])).toStrictEqual(
+        expect(deepClone(call[3])).toMatchObject(
             deepClone(
                 Zcl.Frame.create(
                     Zcl.FrameType.GLOBAL,
@@ -4489,12 +4707,13 @@ describe("Controller", () => {
                     "configReport",
                     513,
                     [{attrId: 16384, dataType: 48, direction: 0, maxRepIntval: 10, minRepIntval: 1, repChange: 1}],
-                    {},
+                    CUSTOM_CLUSTERS,
                 ),
             ),
         );
 
         expect(endpoint.configuredReportings.length).toBe(1);
+
         expect({...endpoint.configuredReportings[0], cluster: undefined}).toStrictEqual({
             attribute: expect.objectContaining({ID: 16384, type: 48, manufacturerCode: 4641, name: "viessmannWindowOpenInternal"}),
             minimumReportInterval: 1,
@@ -4510,9 +4729,10 @@ describe("Controller", () => {
         const device = controller.getDeviceByIeeeAddr("0x129")!;
         // @ts-expect-error private
         device._manufacturerID = Zcl.ManufacturerCode.VIESSMANN_ELEKTRONIK_GMBH;
+        device.addCustomCluster("hvacThermostat", CUSTOM_CLUSTERS.hvacThermostat);
         const endpoint = device.getEndpoint(1)!;
         mocksendZclFrameToEndpoint.mockClear();
-        await endpoint.configureReporting("hvacThermostat", [
+        await endpoint.configureReporting<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>("hvacThermostat", [
             {
                 attribute: "viessmannWindowOpenInternal",
                 minimumReportInterval: 1,
@@ -4525,7 +4745,7 @@ describe("Controller", () => {
         expect(call[0]).toBe("0x129");
         expect(call[1]).toBe(129);
         expect(call[2]).toBe(1);
-        expect(deepClone(call[3])).toStrictEqual(
+        expect(deepClone(call[3])).toMatchObject(
             deepClone(
                 Zcl.Frame.create(
                     Zcl.FrameType.GLOBAL,
@@ -4565,7 +4785,7 @@ describe("Controller", () => {
         expect(deepClone(endpoint.configuredReportings)).toStrictEqual([
             {
                 cluster: deepClone(genPowerCfg),
-                attribute: genPowerCfg.getAttribute("mainsFrequency"),
+                attribute: Zcl.Utils.getClusterAttribute(genPowerCfg, "mainsFrequency", undefined),
                 minimumReportInterval: 1,
                 maximumReportInterval: 10,
                 reportableChange: 1,
@@ -4578,7 +4798,7 @@ describe("Controller", () => {
         expect(deepClone(endpoint.configuredReportings)).toStrictEqual([
             {
                 cluster: deepClone(genPowerCfg),
-                attribute: genPowerCfg.getAttribute("mainsFrequency"),
+                attribute: Zcl.Utils.getClusterAttribute(genPowerCfg, "mainsFrequency", undefined),
                 minimumReportInterval: 3,
                 maximumReportInterval: 100,
                 reportableChange: 2,
@@ -4591,14 +4811,14 @@ describe("Controller", () => {
         expect(deepClone(endpoint.configuredReportings)).toStrictEqual([
             {
                 cluster: deepClone(genPowerCfg),
-                attribute: genPowerCfg.getAttribute("mainsFrequency"),
+                attribute: Zcl.Utils.getClusterAttribute(genPowerCfg, "mainsFrequency", undefined),
                 minimumReportInterval: 3,
                 maximumReportInterval: 100,
                 reportableChange: 2,
             },
             {
                 cluster: deepClone(msOccupancySensing),
-                attribute: msOccupancySensing.getAttribute("occupancy"),
+                attribute: Zcl.Utils.getClusterAttribute(msOccupancySensing, "occupancy", undefined),
                 minimumReportInterval: 3,
                 maximumReportInterval: 100,
                 reportableChange: 2,
@@ -4611,7 +4831,7 @@ describe("Controller", () => {
         expect(deepClone(endpoint.configuredReportings)).toStrictEqual([
             {
                 cluster: deepClone(genPowerCfg),
-                attribute: genPowerCfg.getAttribute("mainsFrequency"),
+                attribute: Zcl.Utils.getClusterAttribute(genPowerCfg, "mainsFrequency", undefined),
                 minimumReportInterval: 3,
                 maximumReportInterval: 100,
                 reportableChange: 2,
@@ -4927,14 +5147,37 @@ describe("Controller", () => {
         await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
         const device = controller.getDeviceByIeeeAddr("0x129")!;
         const endpoint = device.getEndpoint(1)!;
-        const genBasic = Zcl.Utils.getCluster("genBasic", undefined, {});
         const saveClusterAttributeReportConfigSpy = vi.spyOn(endpoint, "saveClusterAttributeReportConfig");
 
-        endpoint.saveClusterAttributeReportConfig(genBasic.ID, Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC, [
+        interface SchneiderGenBasic {
+            attributes: {schneiderMeterRadioPower: number};
+            commands: Record<string, never>;
+            commandResponses: Record<string, never>;
+        }
+
+        device.addCustomCluster("genBasic", {
+            name: "genBasic",
+            ID: 0x0000,
+            attributes: {
+                schneiderMeterRadioPower: {
+                    name: "schneiderMeterRadioPower",
+                    ID: 0xe200,
+                    type: Zcl.DataType.INT8,
+                    manufacturerCode: Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
+                    write: true,
+                    min: -128,
+                    max: 127,
+                },
+            },
+            commands: {},
+            commandsResponse: {},
+        });
+
+        endpoint.saveClusterAttributeReportConfig(Zcl.Clusters.genBasic.ID, Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC, [
             {
                 status: Zcl.Status.SUCCESS,
                 direction: Zcl.Direction.CLIENT_TO_SERVER,
-                attrId: genBasic.attributes.schneiderMeterRadioPower.ID,
+                attrId: 0xe200,
                 dataType: Zcl.DataType.INT8,
                 minRepIntval: 80,
                 maxRepIntval: 300,
@@ -4949,7 +5192,7 @@ describe("Controller", () => {
                 {
                     status: Zcl.Status.SUCCESS,
                     direction: Zcl.Direction.CLIENT_TO_SERVER,
-                    attrId: genBasic.attributes.schneiderMeterRadioPower.ID,
+                    attrId: 0xe200,
                     dataType: Zcl.DataType.INT8,
                     minRepIntval: 15,
                     maxRepIntval: 213,
@@ -4972,9 +5215,16 @@ describe("Controller", () => {
 
         expect(deepClone(endpoint.configuredReportings)).toStrictEqual([
             {
-                cluster: deepClone(genBasic),
+                cluster: expect.objectContaining({
+                    ID: 0x0000,
+                    name: "genBasic",
+                    attributes: expect.objectContaining({
+                        zclVersion: expect.objectContaining({ID: 0x0000}),
+                        schneiderMeterRadioPower: expect.objectContaining({ID: 0xe200}),
+                    }),
+                }),
                 attribute: expect.objectContaining({
-                    ID: genBasic.attributes.schneiderMeterRadioPower.ID,
+                    ID: 0xe200,
                     name: "schneiderMeterRadioPower",
                     type: Zcl.DataType.INT8,
                     manufacturerCode: Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
@@ -4985,7 +5235,7 @@ describe("Controller", () => {
             },
         ]);
 
-        await endpoint.readReportingConfig("genBasic", [{attribute: "schneiderMeterRadioPower"}], {
+        await endpoint.readReportingConfig<"genBasic", SchneiderGenBasic>("genBasic", [{attribute: "schneiderMeterRadioPower"}], {
             manufacturerCode: Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
         });
 
@@ -5002,9 +5252,9 @@ describe("Controller", () => {
                     Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
                     9,
                     "readReportConfig",
-                    genBasic.ID,
-                    [{direction: Zcl.Direction.CLIENT_TO_SERVER, attrId: genBasic.attributes.schneiderMeterRadioPower.ID}],
-                    {},
+                    Zcl.Clusters.genBasic.ID,
+                    [{direction: Zcl.Direction.CLIENT_TO_SERVER, attrId: 0xe200}],
+                    device.customClusters,
                 ),
             ),
         );
@@ -5012,9 +5262,16 @@ describe("Controller", () => {
 
         expect(deepClone(endpoint.configuredReportings)).toStrictEqual([
             {
-                cluster: deepClone(genBasic),
+                cluster: expect.objectContaining({
+                    ID: 0x0000,
+                    name: "genBasic",
+                    attributes: expect.objectContaining({
+                        zclVersion: expect.objectContaining({ID: 0x0000}),
+                        schneiderMeterRadioPower: expect.objectContaining({ID: 0xe200}),
+                    }),
+                }),
                 attribute: expect.objectContaining({
-                    ID: genBasic.attributes.schneiderMeterRadioPower.ID,
+                    ID: 0xe200,
                     name: "schneiderMeterRadioPower",
                     type: Zcl.DataType.INT8,
                     manufacturerCode: Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
@@ -5203,10 +5460,11 @@ describe("Controller", () => {
         const endpoint = device.getEndpoint(1)!;
         mocksendZclFrameToEndpoint.mockClear();
         device.addCustomCluster("manuSpecificAssaDoorLock", {
+            name: "manuSpecificAssaDoorLock",
             ID: 0xfc00,
             attributes: {},
             commands: {
-                getBatteryLevel: {ID: 0x12, parameters: []},
+                getBatteryLevel: {name: "getBatteryLevel", ID: 0x12, parameters: []},
             },
             commandsResponse: {},
         });
@@ -5223,6 +5481,7 @@ describe("Controller", () => {
         const device = controller.getDeviceByIeeeAddr("0x129")!;
         const endpoint = device.getEndpoint(1)!;
         mocksendZclFrameToEndpoint.mockClear();
+        device.addCustomCluster("lightingColorCtrl", CUSTOM_CLUSTERS.lightingColorCtrl);
         await endpoint.command("lightingColorCtrl", "tuyaMoveToHueAndSaturationBrightness", {hue: 1, saturation: 1, transtime: 0, brightness: 22});
         expect(mocksendZclFrameToEndpoint.mock.calls[0][0]).toBe("0x129");
         expect(mocksendZclFrameToEndpoint.mock.calls[0][1]).toBe(129);
@@ -5468,14 +5727,15 @@ describe("Controller", () => {
         const device = controller.getDeviceByIeeeAddr("0x129")!;
         // @ts-expect-error private
         device._manufacturerID = Zcl.ManufacturerCode.VIESSMANN_ELEKTRONIK_GMBH;
+        device.addCustomCluster("hvacThermostat", CUSTOM_CLUSTERS.hvacThermostat);
         const endpoint = device.getEndpoint(1)!;
-        await endpoint.write("hvacThermostat", {viessmannWindowOpenInternal: 1});
+        await endpoint.write<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>("hvacThermostat", {viessmannWindowOpenInternal: 1});
         expect(mocksendZclFrameToEndpoint).toHaveBeenCalledTimes(1);
         const call = mocksendZclFrameToEndpoint.mock.calls[0];
         expect(call[0]).toBe("0x129");
         expect(call[1]).toBe(129);
         expect(call[2]).toBe(1);
-        expect(deepClone(call[3])).toStrictEqual(
+        expect(deepClone(call[3])).toMatchObject(
             deepClone(
                 Zcl.Frame.create(
                     Zcl.FrameType.GLOBAL,
@@ -5486,7 +5746,7 @@ describe("Controller", () => {
                     "write",
                     513,
                     [{attrId: 16384, attrData: 1, dataType: 48}],
-                    {},
+                    CUSTOM_CLUSTERS,
                 ),
             ),
         );
@@ -5746,17 +6006,29 @@ describe("Controller", () => {
         await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
         mocksendZclFrameToEndpoint.mockClear();
         const device = controller.getDeviceByIeeeAddr("0x129")!;
-        // @ts-expect-error private
-        device._manufacturerID = Zcl.ManufacturerCode.VIESSMANN_ELEKTRONIK_GMBH;
+        readManufacturerCode = Zcl.ManufacturerCode.VIESSMANN_ELEKTRONIK_GMBH;
+        device.addCustomCluster("hvacThermostat", CUSTOM_CLUSTERS.hvacThermostat);
         const endpoint = device.getEndpoint(1)!;
-        await endpoint.read("hvacThermostat", ["viessmannWindowOpenInternal"]);
+        await endpoint.read<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>("hvacThermostat", ["viessmannWindowOpenInternal"]);
         expect(mocksendZclFrameToEndpoint).toHaveBeenCalledTimes(1);
         const call = mocksendZclFrameToEndpoint.mock.calls[0];
         expect(call[0]).toBe("0x129");
         expect(call[1]).toBe(129);
         expect(call[2]).toBe(1);
-        expect(deepClone(call[3])).toStrictEqual(
-            deepClone(Zcl.Frame.create(Zcl.FrameType.GLOBAL, Zcl.Direction.CLIENT_TO_SERVER, true, 4641, 9, "read", 513, [{attrId: 16384}], {})),
+        expect(deepClone(call[3])).toMatchObject(
+            deepClone(
+                Zcl.Frame.create(
+                    Zcl.FrameType.GLOBAL,
+                    Zcl.Direction.CLIENT_TO_SERVER,
+                    true,
+                    4641,
+                    9,
+                    "read",
+                    513,
+                    [{attrId: 16384}],
+                    CUSTOM_CLUSTERS,
+                ),
+            ),
         );
         expect(call[4]).toBe(10000);
     });
@@ -5914,7 +6186,7 @@ describe("Controller", () => {
         expect(Array.from(group6.members)).toStrictEqual([device2.getEndpoint(1)]);
         expect(Array.from(group7.members)).toStrictEqual([device2.getEndpoint(1)]);
         expect(deepClone(call[3])).toStrictEqual(
-            deepClone(Zcl.Frame.create(Zcl.FrameType.SPECIFIC, Zcl.Direction.CLIENT_TO_SERVER, true, undefined, 23, "removeAll", 4, {}, {})),
+            deepClone(Zcl.Frame.create(Zcl.FrameType.SPECIFIC, Zcl.Direction.CLIENT_TO_SERVER, true, undefined, 22, "removeAll", 4, {}, {})),
         );
     });
 
@@ -7323,10 +7595,11 @@ describe("Controller", () => {
         await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
         const device = controller.getDeviceByIeeeAddr("0x129")!;
         device.addCustomCluster("myCustomCluster", {
+            name: "myCustomCluster",
             ID: 9123,
             commands: {},
             commandsResponse: {},
-            attributes: {superAttribute: {ID: 0, type: Zcl.DataType.UINT8}},
+            attributes: {superAttribute: {name: "superAttribute", ID: 0, type: Zcl.DataType.UINT8}},
         });
         const buffer = Buffer.from([24, 169, 99, 0, 1, 24, 3, 0, 0, 24, 1]);
         const header = Zcl.Header.fromBuffer(buffer);
@@ -8346,13 +8619,6 @@ describe("Controller", () => {
         mocksendZclFrameToEndpoint.mockClear();
         mocksendZclFrameToEndpoint.mockReturnValueOnce(null);
 
-        // onZclData is called via mockAdapterEvents, but we need to wait until it has finished
-        const origOnZclData = device.onZclData;
-        device.onZclData = (a, b, c) => {
-            const f = origOnZclData.call(device, a, b, c);
-            vi.advanceTimersByTime(10);
-            return f;
-        };
         const nextTick = new Promise(process.nextTick);
 
         const result = endpoint.write("genOnOff", {onTime: 1}, {disableResponse: true, sendPolicy: "bulk"});
@@ -8424,6 +8690,128 @@ describe("Controller", () => {
         expect(fastpollstop[3].payload).toStrictEqual({});
     });
 
+    it("Send to device with pendingRequestTimeout > 0, retry on timeout error", async () => {
+        await controller.start();
+        await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
+        const frame = Zcl.Frame.create(
+            Zcl.FrameType.GLOBAL,
+            Zcl.Direction.SERVER_TO_CLIENT,
+            true,
+            undefined,
+            1,
+            "report",
+            "genPowerCfg",
+            [{attrId: 33, dataType: 32, attrData: 84}],
+            {},
+        );
+        const data = {
+            wasBroadcast: false,
+            address: "0x129",
+            clusterID: frame.cluster.ID,
+            data: frame.toBuffer(),
+            header: frame.header,
+            endpoint: 1,
+            linkquality: 50,
+            groupID: 0,
+        };
+        const device = controller.getDeviceByIeeeAddr("0x129")!;
+        const endpoint = device.getEndpoint(1)!;
+        const group = controller.createGroup(1);
+        device.checkinInterval = 3_600;
+
+        expect(device.pendingRequestTimeout).toStrictEqual(3_600_000);
+
+        mocksendZclFrameToEndpoint.mockClear();
+        mocksendZclFrameToEndpoint.mockImplementationOnce(async () => {
+            await vi.advanceTimersByTimeAsync(10_000);
+            throw new Error("timeout");
+        });
+
+        const p = endpoint.addToGroup(group);
+
+        expect(mocksendZclFrameToEndpoint).toHaveBeenCalledTimes(1);
+
+        await vi.advanceTimersByTimeAsync(1000);
+        await mockAdapterEvents.zclPayload(data);
+
+        await expect(p).resolves.toStrictEqual(undefined);
+
+        expect(mocksendZclFrameToEndpoint).toHaveBeenCalledTimes(2);
+    });
+
+    it("Send to device with pendingRequestTimeout > 0, fails on non-timeout error", async () => {
+        await controller.start();
+        await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
+        const frame = Zcl.Frame.create(
+            Zcl.FrameType.GLOBAL,
+            Zcl.Direction.SERVER_TO_CLIENT,
+            true,
+            undefined,
+            1,
+            "report",
+            "genPowerCfg",
+            [{attrId: 33, dataType: 32, attrData: 84}],
+            {},
+        );
+        const data = {
+            wasBroadcast: false,
+            address: "0x129",
+            clusterID: frame.cluster.ID,
+            data: frame.toBuffer(),
+            header: frame.header,
+            endpoint: 1,
+            linkquality: 50,
+            groupID: 0,
+        };
+        const failureFrame = Zcl.Frame.create(
+            Zcl.FrameType.GLOBAL,
+            Zcl.Direction.SERVER_TO_CLIENT,
+            true,
+            undefined,
+            2,
+            "defaultRsp",
+            "genGroups",
+            {cmdId: 0, statusCode: Zcl.Status.UNSUPPORTED_CLUSTER},
+            {},
+        );
+        const failureData = {
+            wasBroadcast: false,
+            address: "0x129",
+            clusterID: failureFrame.cluster.ID,
+            data: failureFrame.toBuffer(),
+            header: failureFrame.header,
+            endpoint: 1,
+            linkquality: 50,
+            groupID: 0,
+        };
+        const device = controller.getDeviceByIeeeAddr("0x129")!;
+        const endpoint = device.getEndpoint(1)!;
+        const group = controller.createGroup(1);
+        device.checkinInterval = 3_600;
+        expect(device.pendingRequestTimeout).toStrictEqual(3_600_000);
+
+        mocksendZclFrameToEndpoint.mockClear();
+        mocksendZclFrameToEndpoint.mockImplementationOnce(async () => {
+            await vi.advanceTimersByTimeAsync(150);
+            await mockAdapterEvents.zclPayload(failureData);
+
+            return failureData;
+        });
+
+        const p = endpoint.addToGroup(group);
+
+        expect(mocksendZclFrameToEndpoint).toHaveBeenCalledTimes(1);
+
+        await expect(p).rejects.toThrow(/UNSUPPORTED_CLUSTER/);
+
+        expect(mocksendZclFrameToEndpoint).toHaveBeenCalledTimes(1);
+
+        await vi.advanceTimersByTimeAsync(1000);
+        await mockAdapterEvents.zclPayload(data);
+
+        expect(mocksendZclFrameToEndpoint).toHaveBeenCalledTimes(1);
+    });
+
     it("Handle retransmitted Xiaomi messages", async () => {
         await controller.start();
         await mockAdapterEvents.deviceJoined({networkAddress: 175, ieeeAddr: "0x175"});
@@ -8479,111 +8867,274 @@ describe("Controller", () => {
         expect(result.missingRouters[0].ieeeAddr).toBe("0x129");
     });
 
-    // ZCLFrame with manufacturer specific flag and manufacturer code defined, to generic device
-    // ZCLFrameConverter should not modify specific frames!
-    it("Should resolve manufacturer specific cluster attribute names on specific ZCL frames: generic target device", async () => {
-        const buffer = Buffer.from([28, 33, 16, 13, 1, 2, 240, 0, 48, 4]);
-        await controller.start();
-        await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
+    describe("ZCL frame converter attributeKeyValue", () => {
+        // ZCLFrame with manufacturer specific flag and manufacturer code defined, to generic device
+        // ZCLFrameConverter should not modify specific frames!
+        it("Should resolve manufacturer specific cluster attribute names on specific ZCL frames: generic target device", async () => {
+            const buffer = Buffer.from([28, 33, 16, 13, 1, 2, 240, 0, 48, 4]);
+            await controller.start();
+            await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
+            const device = controller.getDeviceByIeeeAddr("0x129")!;
+            device.addCustomCluster("closuresWindowCovering", CUSTOM_CLUSTERS.closuresWindowCovering);
 
-        const frame = Zcl.Frame.fromBuffer(
-            Zcl.Utils.getCluster("closuresWindowCovering", undefined, {}).ID,
-            Zcl.Header.fromBuffer(buffer),
-            buffer,
-            {},
-        );
-        await mockAdapterEvents.zclPayload({
-            wasBroadcast: false,
-            address: "0x129",
-            clusterID: frame.cluster.ID,
-            data: frame.toBuffer(),
-            header: frame.header,
-            endpoint: 1,
-            linkquality: 50,
-            groupID: 0,
+            const frame = Zcl.Frame.fromBuffer(
+                Zcl.Utils.getCluster("closuresWindowCovering", undefined, CUSTOM_CLUSTERS).ID,
+                Zcl.Header.fromBuffer(buffer),
+                buffer,
+                CUSTOM_CLUSTERS,
+            );
+            await mockAdapterEvents.zclPayload({
+                wasBroadcast: false,
+                address: "0x129",
+                clusterID: frame.cluster.ID,
+                data: frame.toBuffer(),
+                header: frame.header,
+                endpoint: 1,
+                linkquality: 50,
+                groupID: 0,
+            });
+            expect(events.message.length).toBe(1);
+            expect(events.message[0].data).toMatchObject({calibrationMode: 4});
+            expect(events.message[0].data).not.toMatchObject({tuyaMotorReversal: 4});
         });
-        expect(events.message.length).toBe(1);
-        expect(events.message[0].data).toMatchObject({calibrationMode: 4});
-        expect(events.message[0].data).not.toMatchObject({tuyaMotorReversal: 4});
-    });
 
-    // ZCLFrame with manufacturer specific flag and manufacturer code defined, to specific device
-    // ZCLFrameConverter should not modify specific frames!
-    it("Should resolve manufacturer specific cluster attribute names on specific ZCL frames: specific target device", async () => {
-        const buffer = Buffer.from([28, 33, 16, 13, 1, 2, 240, 0, 48, 4]);
-        await controller.start();
-        await mockAdapterEvents.deviceJoined({networkAddress: 177, ieeeAddr: "0x177"});
-        const frame = Zcl.Frame.fromBuffer(
-            Zcl.Utils.getCluster("closuresWindowCovering", undefined, {}).ID,
-            Zcl.Header.fromBuffer(buffer),
-            buffer,
-            {},
-        );
-        await mockAdapterEvents.zclPayload({
-            wasBroadcast: false,
-            address: "0x177",
-            clusterID: frame.cluster.ID,
-            data: frame.toBuffer(),
-            header: frame.header,
-            endpoint: 1,
-            linkquality: 50,
-            groupID: 0,
+        // ZCLFrame with manufacturer specific flag and manufacturer code defined, to specific device
+        // ZCLFrameConverter should not modify specific frames!
+        it("Should resolve manufacturer specific cluster attribute names on specific ZCL frames: specific target device", async () => {
+            const buffer = Buffer.from([28, 33, 16, 13, 1, 2, 240, 0, 48, 4]);
+            await controller.start();
+            await mockAdapterEvents.deviceJoined({networkAddress: 177, ieeeAddr: "0x177"});
+            const device = controller.getDeviceByIeeeAddr("0x177")!;
+            device.addCustomCluster("closuresWindowCovering", CUSTOM_CLUSTERS.closuresWindowCovering);
+
+            const frame = Zcl.Frame.fromBuffer(
+                Zcl.Utils.getCluster("closuresWindowCovering", undefined, CUSTOM_CLUSTERS).ID,
+                Zcl.Header.fromBuffer(buffer),
+                buffer,
+                CUSTOM_CLUSTERS,
+            );
+            await mockAdapterEvents.zclPayload({
+                wasBroadcast: false,
+                address: "0x177",
+                clusterID: frame.cluster.ID,
+                data: frame.toBuffer(),
+                header: frame.header,
+                endpoint: 1,
+                linkquality: 50,
+                groupID: 0,
+            });
+            expect(events.message.length).toBe(1);
+            expect(events.message[0].data).toMatchObject({calibrationMode: 4});
+            expect(events.message[0].data).not.toMatchObject({tuyaMotorReversal: 4});
         });
-        expect(events.message.length).toBe(1);
-        expect(events.message[0].data).toMatchObject({calibrationMode: 4});
-        expect(events.message[0].data).not.toMatchObject({tuyaMotorReversal: 4});
-    });
 
-    // ZCLFrame without manufacturer specific flag or manufacturer code set, to generic device
-    it("Should resolve generic cluster attribute names on generic ZCL frames: generic target device", async () => {
-        const buffer = Buffer.from([24, 242, 10, 2, 240, 48, 4]);
-        await controller.start();
-        await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
-        const frame = Zcl.Frame.fromBuffer(
-            Zcl.Utils.getCluster("closuresWindowCovering", undefined, {}).ID,
-            Zcl.Header.fromBuffer(buffer),
-            buffer,
-            {},
-        );
-        await mockAdapterEvents.zclPayload({
-            wasBroadcast: false,
-            address: "0x129",
-            clusterID: frame.cluster.ID,
-            data: frame.toBuffer(),
-            header: frame.header,
-            endpoint: 1,
-            linkquality: 50,
-            groupID: 0,
+        // ZCLFrame without manufacturer specific flag or manufacturer code set, to generic device
+        it("Should resolve generic cluster attribute names on generic ZCL frames: generic target device", async () => {
+            const buffer = Buffer.from([24, 242, 10, 2, 240, 48, 4]);
+            await controller.start();
+            await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
+            const device = controller.getDeviceByIeeeAddr("0x129")!;
+            device.addCustomCluster("closuresWindowCovering", CUSTOM_CLUSTERS.closuresWindowCovering);
+
+            const frame = Zcl.Frame.fromBuffer(
+                Zcl.Utils.getCluster("closuresWindowCovering", undefined, CUSTOM_CLUSTERS).ID,
+                Zcl.Header.fromBuffer(buffer),
+                buffer,
+                CUSTOM_CLUSTERS,
+            );
+            await mockAdapterEvents.zclPayload({
+                wasBroadcast: false,
+                address: "0x129",
+                clusterID: frame.cluster.ID,
+                data: frame.toBuffer(),
+                header: frame.header,
+                endpoint: 1,
+                linkquality: 50,
+                groupID: 0,
+            });
+            expect(events.message.length).toBe(1);
+            expect(events.message[0].data).toMatchObject({tuyaMotorReversal: 4});
+            expect(events.message[0].data).not.toMatchObject({calibrationMode: 4});
+        });
+
+        // ZCLFrame without manufacturer specific flag set or manufacturer code set, to specific device (Legrand only)
+        it("Should resolve manufacturer specific cluster attribute names on generic ZCL frames: Legrand target device", async () => {
+            const buffer = Buffer.from([24, 242, 10, 2, 240, 48, 4]);
+            await controller.start();
+            await mockAdapterEvents.deviceJoined({networkAddress: 177, ieeeAddr: "0x177"});
+            const device = controller.getDeviceByIeeeAddr("0x177")!;
+            device.addCustomCluster("closuresWindowCovering", CUSTOM_CLUSTERS.closuresWindowCovering);
+
+            const frame = Zcl.Frame.fromBuffer(
+                Zcl.Utils.getCluster("closuresWindowCovering", undefined, CUSTOM_CLUSTERS).ID,
+                Zcl.Header.fromBuffer(buffer),
+                buffer,
+                CUSTOM_CLUSTERS,
+            );
+            await mockAdapterEvents.zclPayload({
+                wasBroadcast: false,
+                address: "0x177",
+                clusterID: frame.cluster.ID,
+                data: frame.toBuffer(),
+                header: frame.header,
+                endpoint: 1,
+                linkquality: 50,
+                groupID: 0,
+            });
+            expect(events.message.length).toBe(1);
+            expect(events.message[0].data).toMatchObject({calibrationMode: 4});
+            expect(events.message[0].data).not.toMatchObject({tuyaMotorReversal: 4});
+        });
+
+        it("Should drop non-success records from readRsp payloads", async () => {
+            await controller.start();
+            await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
+            const device = controller.getDeviceByIeeeAddr("0x129")!;
+            device.updateGenBasic({swBuildId: "2.16"});
+
+            const frame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.SERVER_TO_CLIENT,
+                true,
+                undefined,
+                10,
+                "readRsp",
+                Zcl.Clusters.genBasic.ID,
+                [
+                    {attrId: 0x0005, status: Zcl.Status.SUCCESS, dataType: Zcl.DataType.CHAR_STR, attrData: "myModelID"},
+                    {attrId: 0x4000, status: Zcl.Status.UNSUPPORTED_ATTRIBUTE},
+                ],
+                {},
+            );
+            await mockAdapterEvents.zclPayload({
+                wasBroadcast: false,
+                address: "0x129",
+                clusterID: frame.cluster.ID,
+                data: frame.toBuffer(),
+                header: frame.header,
+                endpoint: 1,
+                linkquality: 50,
+                groupID: 0,
+            });
+
+            expect(events.message.length).toBe(1);
+            expect(events.message[0].data).toStrictEqual({modelId: "myModelID"});
+            expect(device.softwareBuildID).toStrictEqual("2.16");
+            expect(device.modelID).toStrictEqual("myModelID");
         });
-        expect(events.message.length).toBe(1);
-        expect(events.message[0].data).toMatchObject({tuyaMotorReversal: 4});
-        expect(events.message[0].data).not.toMatchObject({calibrationMode: 4});
     });
 
-    // ZCLFrame without manufacturer specific flag set or manufacturer code set, to specific device (Legrand only)
-    it("Should resolve manufacturer specific cluster attribute names on generic ZCL frames: Legrand target device", async () => {
-        const buffer = Buffer.from([24, 242, 10, 2, 240, 48, 4]);
-        await controller.start();
-        await mockAdapterEvents.deviceJoined({networkAddress: 177, ieeeAddr: "0x177"});
-        const frame = Zcl.Frame.fromBuffer(
-            Zcl.Utils.getCluster("closuresWindowCovering", undefined, {}).ID,
-            Zcl.Header.fromBuffer(buffer),
-            buffer,
-            {},
-        );
-        await mockAdapterEvents.zclPayload({
-            wasBroadcast: false,
-            address: "0x177",
-            clusterID: frame.cluster.ID,
-            data: frame.toBuffer(),
-            header: frame.header,
-            endpoint: 1,
-            linkquality: 50,
-            groupID: 0,
+    describe("ZCL frame converter attributeList", () => {
+        // ZCLFrame with manufacturer specific flag and manufacturer code defined, to generic device
+        // ZCLFrameConverter should not modify specific frames!
+        it("Should resolve manufacturer specific cluster attribute names on specific ZCL frames: generic target device", async () => {
+            const buffer = Buffer.from([28, 33, 16, 13, 0, 2, 240]);
+            await controller.start();
+            await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
+            const device = controller.getDeviceByIeeeAddr("0x129")!;
+            device.addCustomCluster("closuresWindowCovering", CUSTOM_CLUSTERS.closuresWindowCovering);
+
+            const frame = Zcl.Frame.fromBuffer(
+                Zcl.Utils.getCluster("closuresWindowCovering", undefined, CUSTOM_CLUSTERS).ID,
+                Zcl.Header.fromBuffer(buffer),
+                buffer,
+                {},
+            );
+            await mockAdapterEvents.zclPayload({
+                wasBroadcast: false,
+                address: "0x129",
+                clusterID: frame.cluster.ID,
+                data: frame.toBuffer(),
+                header: frame.header,
+                endpoint: 1,
+                linkquality: 50,
+                groupID: 0,
+            });
+            expect(events.message.length).toBe(1);
+            expect(events.message[0].data).toStrictEqual(["calibrationMode"]);
+        });
+
+        // ZCLFrame with manufacturer specific flag and manufacturer code defined, to specific device
+        // ZCLFrameConverter should not modify specific frames!
+        it("Should resolve manufacturer specific cluster attribute names on specific ZCL frames: specific target device", async () => {
+            const buffer = Buffer.from([28, 33, 16, 13, 0, 2, 240]);
+            await controller.start();
+            await mockAdapterEvents.deviceJoined({networkAddress: 177, ieeeAddr: "0x177"});
+            const device = controller.getDeviceByIeeeAddr("0x177")!;
+            device.addCustomCluster("closuresWindowCovering", CUSTOM_CLUSTERS.closuresWindowCovering);
+            const frame = Zcl.Frame.fromBuffer(
+                Zcl.Utils.getCluster("closuresWindowCovering", undefined, CUSTOM_CLUSTERS).ID,
+                Zcl.Header.fromBuffer(buffer),
+                buffer,
+                {},
+            );
+            await mockAdapterEvents.zclPayload({
+                wasBroadcast: false,
+                address: "0x177",
+                clusterID: frame.cluster.ID,
+                data: frame.toBuffer(),
+                header: frame.header,
+                endpoint: 1,
+                linkquality: 50,
+                groupID: 0,
+            });
+            expect(events.message.length).toBe(1);
+            expect(events.message[0].data).toStrictEqual(["calibrationMode"]);
+        });
+
+        // ZCLFrame without manufacturer specific flag or manufacturer code set, to generic device
+        it("Should resolve generic cluster attribute names on generic ZCL frames: generic target device", async () => {
+            const buffer = Buffer.from([24, 242, 0, 2, 240]);
+            await controller.start();
+            await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
+            const device = controller.getDeviceByIeeeAddr("0x129")!;
+            device.addCustomCluster("closuresWindowCovering", CUSTOM_CLUSTERS.closuresWindowCovering);
+            const frame = Zcl.Frame.fromBuffer(
+                Zcl.Utils.getCluster("closuresWindowCovering", undefined, CUSTOM_CLUSTERS).ID,
+                Zcl.Header.fromBuffer(buffer),
+                buffer,
+                {},
+            );
+            await mockAdapterEvents.zclPayload({
+                wasBroadcast: false,
+                address: "0x129",
+                clusterID: frame.cluster.ID,
+                data: frame.toBuffer(),
+                header: frame.header,
+                endpoint: 1,
+                linkquality: 50,
+                groupID: 0,
+            });
+            expect(events.message.length).toBe(1);
+            expect(events.message[0].data).toStrictEqual(["tuyaMotorReversal"]);
+        });
+
+        // ZCLFrame without manufacturer specific flag set or manufacturer code set, to specific device (Legrand only)
+        it("Should resolve manufacturer specific cluster attribute names on generic ZCL frames: Legrand target device", async () => {
+            const buffer = Buffer.from([24, 242, 0, 2, 240]);
+            await controller.start();
+            await mockAdapterEvents.deviceJoined({networkAddress: 177, ieeeAddr: "0x177"});
+            const device = controller.getDeviceByIeeeAddr("0x177")!;
+            device.addCustomCluster("closuresWindowCovering", CUSTOM_CLUSTERS.closuresWindowCovering);
+            const frame = Zcl.Frame.fromBuffer(
+                Zcl.Utils.getCluster("closuresWindowCovering", undefined, CUSTOM_CLUSTERS).ID,
+                Zcl.Header.fromBuffer(buffer),
+                buffer,
+                {},
+            );
+            await mockAdapterEvents.zclPayload({
+                wasBroadcast: false,
+                address: "0x177",
+                clusterID: frame.cluster.ID,
+                data: frame.toBuffer(),
+                header: frame.header,
+                endpoint: 1,
+                linkquality: 50,
+                groupID: 0,
+            });
+            expect(events.message.length).toBe(1);
+            expect(events.message[0].data).toStrictEqual(["calibrationMode"]);
         });
-        expect(events.message.length).toBe(1);
-        expect(events.message[0].data).toMatchObject({calibrationMode: 4});
-        expect(events.message[0].data).not.toMatchObject({tuyaMotorReversal: 4});
     });
 
     it("zclCommand", async () => {
@@ -9347,10 +9898,11 @@ describe("Controller", () => {
         const device = controller.getDeviceByIeeeAddr("0x177")!;
 
         device.addCustomCluster("manuHerdsman", {
+            name: "manuHerdsman",
             ID: 64513,
             commands: {},
             commandsResponse: {},
-            attributes: {customAttr: {ID: 0, type: Zcl.DataType.UINT8, write: true}},
+            attributes: {customAttr: {name: "customAttr", ID: 0, type: Zcl.DataType.UINT8, write: true}},
         });
 
         const group = controller.createGroup(34);
@@ -9402,20 +9954,21 @@ describe("Controller", () => {
 
         const device2 = controller.getDeviceByIeeeAddr("0x178")!;
         device2.addCustomCluster("manuHerdsman", {
+            name: "manuHerdsman",
             ID: 64513,
             commands: {},
             commandsResponse: {},
-            attributes: {customAttr: {ID: 0, type: Zcl.DataType.UINT8}},
+            attributes: {customAttr: {name: "customAttr", ID: 0, type: Zcl.DataType.UINT8}},
         });
         group.addMember(device2.getEndpoint(2)!);
 
         await expect(async () => {
             await group.write("manuHerdsman", {customAttr: 14}, {});
-        }).rejects.toThrow(new Error(`Cluster with name 'manuHerdsman' does not exist`));
+        }).rejects.toThrow(new Zcl.StatusError(Zcl.Status.UNSUPPORTED_CLUSTER, "manuHerdsman"));
 
         await expect(async () => {
             await group.read("manuHerdsman", ["customAttr"], {});
-        }).rejects.toThrow(new Error(`Cluster with name 'manuHerdsman' does not exist`));
+        }).rejects.toThrow(new Zcl.StatusError(Zcl.Status.UNSUPPORTED_CLUSTER, "manuHerdsman"));
 
         await group.write<"manuHerdsman", CustomManuHerdsman>("manuHerdsman", {customAttr: 14}, {direction: Zcl.Direction.SERVER_TO_CLIENT});
         await group.read<"manuHerdsman", CustomManuHerdsman>("manuHerdsman", ["customAttr"], {direction: Zcl.Direction.SERVER_TO_CLIENT});
@@ -9441,20 +9994,21 @@ describe("Controller", () => {
 
         const device3 = controller.getDeviceByIeeeAddr("0x176")!;
         device3.addCustomCluster("manuHerdsman", {
+            name: "manuHerdsman",
             ID: 64513,
             commands: {},
             commandsResponse: {},
-            attributes: {customAttr: {ID: 0, type: Zcl.DataType.UINT8}},
+            attributes: {customAttr: {name: "customAttr", ID: 0, type: Zcl.DataType.UINT8}},
         });
         group.addMember(device3.getEndpoint(1)!);
 
         await expect(async () => {
             await group.write("manuHerdsman", {customAttr: 56}, {});
-        }).rejects.toThrow(new Error(`Cluster with name 'manuHerdsman' does not exist`));
+        }).rejects.toThrow(new Zcl.StatusError(Zcl.Status.UNSUPPORTED_CLUSTER, "manuHerdsman"));
 
         await expect(async () => {
             await group.read("manuHerdsman", ["customAttr"], {});
-        }).rejects.toThrow(new Error(`Cluster with name 'manuHerdsman' does not exist`));
+        }).rejects.toThrow(new Zcl.StatusError(Zcl.Status.UNSUPPORTED_CLUSTER, "manuHerdsman"));
     });
 
     it("does not read/write to group with non-common custom clusters", async () => {
@@ -9464,10 +10018,11 @@ describe("Controller", () => {
         const device = controller.getDeviceByIeeeAddr("0x177")!;
 
         device.addCustomCluster("manuHerdsman", {
+            name: "manuHerdsman",
             ID: 64513,
             commands: {},
             commandsResponse: {},
-            attributes: {customAttr: {ID: 0, type: Zcl.DataType.UINT8}},
+            attributes: {customAttr: {name: "customAttr", ID: 0, type: Zcl.DataType.UINT8}},
         });
 
         const group = controller.createGroup(34);
@@ -9481,11 +10036,11 @@ describe("Controller", () => {
 
         await expect(async () => {
             await group.write("manuHerdsman", {customAttr: 34}, {});
-        }).rejects.toThrow(new Error(`Cluster with name 'manuHerdsman' does not exist`));
+        }).rejects.toThrow(new Zcl.StatusError(Zcl.Status.UNSUPPORTED_CLUSTER, "manuHerdsman"));
 
         await expect(async () => {
             await group.read("manuHerdsman", ["customAttr"], {});
-        }).rejects.toThrow(new Error(`Cluster with name 'manuHerdsman' does not exist`));
+        }).rejects.toThrow(new Zcl.StatusError(Zcl.Status.UNSUPPORTED_CLUSTER, "manuHerdsman"));
     });
 
     it("sends & receives command to group with custom cluster when common to all members", async () => {
@@ -9495,12 +10050,14 @@ describe("Controller", () => {
         const device = controller.getDeviceByIeeeAddr("0x179")!;
 
         device.addCustomCluster("manuSpecificInovelli", {
+            name: "manuSpecificInovelli",
             ID: 64561,
             manufacturerCode: Zcl.ManufacturerCode.V_MARK_ENTERPRISES_INC,
             // omitted for brevity (unused here)
             attributes: {},
             commands: {
                 ledEffect: {
+                    name: "ledEffect",
                     ID: 1,
                     parameters: [
                         {name: "effect", type: Zcl.DataType.UINT8},
@@ -9510,6 +10067,7 @@ describe("Controller", () => {
                     ],
                 },
                 individualLedEffect: {
+                    name: "individualLedEffect",
                     ID: 3,
                     parameters: [
                         {name: "led", type: Zcl.DataType.UINT8},
@@ -9521,10 +10079,7 @@ describe("Controller", () => {
                 },
             },
             commandsResponse: {
-                bogus: {
-                    ID: 1,
-                    parameters: [{name: "xyz", type: Zcl.DataType.UINT8}],
-                },
+                bogus: {name: "bogus", ID: 1, parameters: [{name: "xyz", type: Zcl.DataType.UINT8}]},
             },
         });
 
@@ -9617,7 +10172,7 @@ describe("Controller", () => {
                 level: 200,
                 duration: 15,
             });
-        }).rejects.toThrow(new Error(`Cluster with name 'manuSpecificInovelli' does not exist`));
+        }).rejects.toThrow(new Zcl.StatusError(Zcl.Status.UNSUPPORTED_CLUSTER, "manuSpecificInovelli"));
     });
 
     it("Updates a device genBasic properties", async () => {
@@ -9863,10 +10418,12 @@ describe("Controller", () => {
 
         const myCustomClusters: CustomClusters = {
             zhSpe: {
+                name: "zhSpe",
                 ID: 0xffc1,
                 attributes: {},
                 commands: {
                     readMe: {
+                        name: "readMe",
                         ID: 0,
                         parameters: [{name: "size", type: Zcl.DataType.UINT8}],
                     },
@@ -9949,7 +10506,7 @@ describe("Controller", () => {
 
         // coverage: prevent crash in onZclPayload when ZCL metadata validation fails
         expect(mockLogger.debug).toHaveBeenCalledWith(
-            "Ignoring attribute modelId from response: Error: modelId requires max length of 32",
+            "Ignoring attribute modelId from response: Error: Status 'INVALID_VALUE' modelId requires max length of 32",
             "zh:controller:zcl",
         );
         expect(device.genBasic.modelId).toStrictEqual(" other multi-endpoint device");
@@ -9959,6 +10516,7 @@ describe("Controller", () => {
         await controller.start();
         await mockAdapterEvents.deviceJoined({networkAddress: 129, ieeeAddr: "0x129"});
         const device = controller.getDeviceByIeeeAddr("0x129")!;
+        device.addCustomCluster("hvacThermostat", CUSTOM_CLUSTERS.hvacThermostat);
         const endpoint = device.getEndpoint(1)!;
         const zclCommandSpy = vi.spyOn(endpoint, "zclCommand");
 
@@ -9985,24 +10543,24 @@ describe("Controller", () => {
         await expect(endpoint.write("hvacThermostat", writePayloadRaw)).rejects.toThrow(
             "Cannot have attributes with different manufacturerCode in single 'write' call",
         );
-        await expect(endpoint.read("hvacThermostat", readPayload)).rejects.toThrow(
+        await expect(endpoint.read<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>("hvacThermostat", readPayload)).rejects.toThrow(
             "Cannot have attributes with different manufacturerCode in single 'read' call",
         );
-        await expect(endpoint.read("hvacThermostat", readPayloadRaw)).rejects.toThrow(
+        await expect(endpoint.read<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>("hvacThermostat", readPayloadRaw)).rejects.toThrow(
             "Cannot have attributes with different manufacturerCode in single 'read' call",
         );
-        await expect(endpoint.configureReporting("hvacThermostat", configureReportingPayload)).rejects.toThrow(
-            "Cannot have attributes with different manufacturerCode in single 'configureReporting' call",
-        );
-        await expect(endpoint.configureReporting("hvacThermostat", configureReportingPayloadRaw)).rejects.toThrow(
-            "Cannot have attributes with different manufacturerCode in single 'configureReporting' call",
-        );
-        await expect(endpoint.readReportingConfig("hvacThermostat", readReportingConfigPayload)).rejects.toThrow(
-            "Cannot have attributes with different manufacturerCode in single 'readReportingConfig' call",
-        );
-        await expect(endpoint.readReportingConfig("hvacThermostat", readReportingConfigPayloadRaw)).rejects.toThrow(
-            "Cannot have attributes with different manufacturerCode in single 'readReportingConfig' call",
-        );
+        await expect(
+            endpoint.configureReporting<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>("hvacThermostat", configureReportingPayload),
+        ).rejects.toThrow("Cannot have attributes with different manufacturerCode in single 'configureReporting' call");
+        await expect(
+            endpoint.configureReporting<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>("hvacThermostat", configureReportingPayloadRaw),
+        ).rejects.toThrow("Cannot have attributes with different manufacturerCode in single 'configureReporting' call");
+        await expect(
+            endpoint.readReportingConfig<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>("hvacThermostat", readReportingConfigPayload),
+        ).rejects.toThrow("Cannot have attributes with different manufacturerCode in single 'readReportingConfig' call");
+        await expect(
+            endpoint.readReportingConfig<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>("hvacThermostat", readReportingConfigPayloadRaw),
+        ).rejects.toThrow("Cannot have attributes with different manufacturerCode in single 'readReportingConfig' call");
 
         //-- with override manufacturer code
 
@@ -10014,24 +10572,40 @@ describe("Controller", () => {
         await expect(endpoint.write("hvacThermostat", writePayloadRaw, manufOpts)).rejects.toThrow(
             "Cannot have attributes with different manufacturerCode in single 'write' call",
         );
-        await expect(endpoint.read("hvacThermostat", readPayload, manufOpts)).rejects.toThrow(
-            "Cannot have attributes with different manufacturerCode in single 'read' call",
-        );
-        await expect(endpoint.read("hvacThermostat", readPayloadRaw, manufOpts)).rejects.toThrow(
-            "Cannot have attributes with different manufacturerCode in single 'read' call",
-        );
-        await expect(endpoint.configureReporting("hvacThermostat", configureReportingPayload, manufOpts)).rejects.toThrow(
-            "Cannot have attributes with different manufacturerCode in single 'configureReporting' call",
-        );
-        await expect(endpoint.configureReporting("hvacThermostat", configureReportingPayloadRaw, manufOpts)).rejects.toThrow(
-            "Cannot have attributes with different manufacturerCode in single 'configureReporting' call",
-        );
-        await expect(endpoint.readReportingConfig("hvacThermostat", readReportingConfigPayload, manufOpts)).rejects.toThrow(
-            "Cannot have attributes with different manufacturerCode in single 'readReportingConfig' call",
-        );
-        await expect(endpoint.readReportingConfig("hvacThermostat", readReportingConfigPayloadRaw, manufOpts)).rejects.toThrow(
-            "Cannot have attributes with different manufacturerCode in single 'readReportingConfig' call",
-        );
+        await expect(
+            endpoint.read<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>("hvacThermostat", readPayload, manufOpts),
+        ).rejects.toThrow("Cannot have attributes with different manufacturerCode in single 'read' call");
+        await expect(
+            endpoint.read<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>("hvacThermostat", readPayloadRaw, manufOpts),
+        ).rejects.toThrow("Cannot have attributes with different manufacturerCode in single 'read' call");
+        await expect(
+            endpoint.configureReporting<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>(
+                "hvacThermostat",
+                configureReportingPayload,
+                manufOpts,
+            ),
+        ).rejects.toThrow("Cannot have attributes with different manufacturerCode in single 'configureReporting' call");
+        await expect(
+            endpoint.configureReporting<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>(
+                "hvacThermostat",
+                configureReportingPayloadRaw,
+                manufOpts,
+            ),
+        ).rejects.toThrow("Cannot have attributes with different manufacturerCode in single 'configureReporting' call");
+        await expect(
+            endpoint.readReportingConfig<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>(
+                "hvacThermostat",
+                readReportingConfigPayload,
+                manufOpts,
+            ),
+        ).rejects.toThrow("Cannot have attributes with different manufacturerCode in single 'readReportingConfig' call");
+        await expect(
+            endpoint.readReportingConfig<"hvacThermostat", CustomClustersTypes["hvacThermostat"]>(
+                "hvacThermostat",
+                readReportingConfigPayloadRaw,
+                manufOpts,
+            ),
+        ).rejects.toThrow("Cannot have attributes with different manufacturerCode in single 'readReportingConfig' call");
 
         expect(zclCommandSpy).toHaveBeenCalledTimes(0);
     });