zigbee-herdsman 5.0.4 → 6.0.1

package/test/greenpower.test.ts

@@ -394,18 +394,6 @@ describe("GreenPower", () => {
             gpdCommandPayload.length,
         );
 
-        {
-            // mock bad frame, allows to bypass options check and validate that this errors out (trying to parse as CHANNEL_REQUEST)
-            const alteredSecurityGpdHeader = Buffer.from(gpdHeader);
-            alteredSecurityGpdHeader[3] = 0;
-            alteredSecurityGpdHeader[4] = 0;
-            const payload = makePayload(addr.sourceId, Buffer.concat([alteredSecurityGpdHeader, gpdCommandPayload]), gpdLink);
-
-            expect(() => {
-                Zcl.Frame.fromBuffer(payload.clusterID, payload.header, payload.data, {});
-            }).toThrow('The value of "offset" is out of range. It must be >= 0 and <= 14. Received 15');
-        }
-
         const payload = makePayload(addr.sourceId, Buffer.concat([gpdHeader, gpdCommandPayload]), gpdLink);
         const frame = Zcl.Frame.fromBuffer(payload.clusterID, payload.header, payload.data, {});
 

package/test/zcl.test.ts

@@ -499,8 +499,8 @@ describe("Zcl", () => {
                         "12": 0,
                         "100": 1,
                         "101": 0,
-                        "110": 255,
-                        "111": 255,
+                        "110": Number.NaN,
+                        "111": Number.NaN,
                         "148": 4,
                         "149": 0.14562499523162842,
                         "150": 2335.614013671875,
@@ -742,7 +742,7 @@ describe("Zcl", () => {
             commandID: 16,
             frameCounter: 1253,
             options: 5280,
-            payloadSize: 255,
+            payloadSize: Number.NaN,
         };
 
         expect(frame.header).toStrictEqual(header);
@@ -750,7 +750,7 @@ describe("Zcl", () => {
     });
 
     it("ZclFrame from buffer GPD with extra data", () => {
-        const buffer = Buffer.from([0x11, 0x00, 0x00, 0xa0, 0x14, 0xfe, 0xf4, 0x46, 0x00, 0xe5, 0x04, 0x00, 0x00, 0x10, 0xff, 0x01]);
+        const buffer = Buffer.from([0x11, 0x00, 0x00, 0xa0, 0x14, 0xfe, 0xf4, 0x46, 0x00, 0xe5, 0x04, 0x00, 0x00, 0x10, 0x01, 0x01]);
         const frame = Zcl.Frame.fromBuffer(Zcl.Clusters.greenPower.ID, Zcl.Header.fromBuffer(buffer)!, buffer, {});
         const header = new Zcl.Header(
             {
@@ -771,7 +771,7 @@ describe("Zcl", () => {
             commandID: 16,
             frameCounter: 1253,
             options: 5280,
-            payloadSize: 255,
+            payloadSize: 1,
         };
 
         expect(frame.header).toStrictEqual(header);
@@ -1951,6 +1951,7 @@ describe("Zcl", () => {
         expect(
             frame.read(BuffaloZclDataType.GPD_FRAME, {
                 payload: {
+                    payloadSize: buffer.length,
                     commandID: 0xe0,
                 },
             }),
@@ -2020,6 +2021,7 @@ describe("Zcl", () => {
         expect(
             frame.read(BuffaloZclDataType.GPD_FRAME, {
                 payload: {
+                    payloadSize: buffer.length,
                     commandID: 0xe0,
                 },
             }),
@@ -2051,6 +2053,7 @@ describe("Zcl", () => {
         expect(
             frame.read(BuffaloZclDataType.GPD_FRAME, {
                 payload: {
+                    payloadSize: buffer.length,
                     commandID: 0xe3,
                 },
             }),
@@ -2404,7 +2407,7 @@ describe("Zcl", () => {
         const buffer = Buffer.alloc(4);
         const expected = Buffer.from([0xff, 0xff, 0xff, 0xff]);
         const buffalo = new BuffaloZcl(buffer);
-        const payload = {hours: undefined, minutes: undefined, seconds: undefined, hundredths: undefined};
+        const payload = {hours: Number.NaN, minutes: Number.NaN, seconds: Number.NaN, hundredths: Number.NaN};
         buffalo.write(DataType.TOD, payload, {});
         expect(buffalo.getBuffer()).toStrictEqual(expected);
     });
@@ -2413,7 +2416,7 @@ describe("Zcl", () => {
         const buffer = Buffer.alloc(4);
         const expected = Buffer.from([0xff, 0xff, 0xff, 0xff]);
         const buffalo = new BuffaloZcl(buffer);
-        const payload = {year: undefined, month: undefined, dayOfMonth: undefined, dayOfWeek: undefined};
+        const payload = {year: Number.NaN, month: Number.NaN, dayOfMonth: Number.NaN, dayOfWeek: Number.NaN};
         buffalo.write(DataType.DATE, payload, {});
         expect(buffalo.getBuffer()).toStrictEqual(expected);
     });
@@ -2779,8 +2782,7 @@ describe("Zcl", () => {
         const buffalo = new BuffaloZcl(Buffer.from([12, 34]));
         const value = buffalo.read(BuffaloZclDataType.USE_DATA_TYPE, {});
         expect(value).toStrictEqual(Buffer.from([12, 34]));
-        // @ts-expect-error protected
-        buffalo.position = 1;
+        buffalo.setPosition(1);
         const value2 = buffalo.read(BuffaloZclDataType.USE_DATA_TYPE, {length: 1});
         expect(value2).toStrictEqual(Buffer.from([34]));
     });
@@ -2801,11 +2803,11 @@ describe("Zcl", () => {
         }).toThrow("Cannot write USE_DATA_TYPE without dataType option specified");
     });
 
-    it("Throws when read GPD_FRAME is missing payload.payloadSize option when payload.commandID is 0xA1", () => {
+    it("Throws when read GPD_FRAME is missing payload.payloadSize option", () => {
         expect(() => {
             const buffalo = new BuffaloZcl(Buffer.alloc(1));
             buffalo.read(BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0xa1}});
-        }).toThrow("Cannot read GPD_FRAME with commandID=0xA1 without payloadSize options specified");
+        }).toThrow("Cannot read GPD_FRAME without required payload options specified");
     });
 
     it("Throws when read LIST_THERMO_TRANSITIONS is missing required payload options", () => {

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

@@ -14,8 +14,7 @@ describe("ZCL Buffalo", () => {
         expect(writeSpy).toHaveBeenCalledWith(value, value.length);
         expect(writeSpy).toHaveBeenCalledTimes(1);
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         // @ts-expect-error invalid on purpose
         buffalo.write(99999, Buffer.from(value), {});
@@ -68,9 +67,11 @@ describe("ZCL Buffalo", () => {
     });
 
     it.each([
+        ["boolean", {value: 1, types: [Zcl.DataType.BOOLEAN]}, {position: 1, write: "writeUInt8", read: "readUInt8"}],
+        ["boolean", {value: 0, types: [Zcl.DataType.BOOLEAN]}, {position: 1, write: "writeUInt8", read: "readUInt8"}],
         [
             "uint8-like",
-            {value: 250, types: [Zcl.DataType.DATA8, Zcl.DataType.BOOLEAN, Zcl.DataType.BITMAP8, Zcl.DataType.UINT8, Zcl.DataType.ENUM8]},
+            {value: 250, types: [Zcl.DataType.DATA8, Zcl.DataType.BITMAP8, Zcl.DataType.UINT8, Zcl.DataType.ENUM8]},
             {position: 1, write: "writeUInt8", read: "readUInt8"},
         ],
         [
@@ -150,17 +151,14 @@ describe("ZCL Buffalo", () => {
         for (const type of payload.types) {
             const buffer = Buffer.alloc(255);
             const buffalo = new BuffaloZcl(buffer);
-            // @ts-expect-error dynamic
-            const writeSpy = vi.spyOn(buffalo, expected.write);
-            // @ts-expect-error dynamic
-            const readSpy = vi.spyOn(buffalo, expected.read);
+            const writeSpy = vi.spyOn(buffalo, expected.write as keyof BuffaloZcl);
+            const readSpy = vi.spyOn(buffalo, expected.read as keyof BuffaloZcl);
 
             buffalo.write(type, payload.value, {});
             expect(writeSpy).toHaveBeenCalledTimes(1);
             expect(buffalo.getPosition()).toStrictEqual(expected.position);
 
-            // @ts-expect-error private
-            buffalo.position = 0;
+            buffalo.setPosition(0);
 
             expect(buffalo.read(type, readOptions)).toStrictEqual(payload.value);
             expect(readSpy).toHaveBeenCalledTimes(1);
@@ -168,6 +166,175 @@ describe("ZCL Buffalo", () => {
         }
     });
 
+    it.each([
+        ["boolean", {value: Number.NaN, types: [Zcl.DataType.BOOLEAN]}, {written: 0xff, position: 1, write: "writeUInt8", read: "readUInt8"}],
+        [
+            "uint8-like",
+            {value: Number.NaN, types: [Zcl.DataType.DATA8, Zcl.DataType.BITMAP8, Zcl.DataType.UINT8, Zcl.DataType.ENUM8]},
+            {written: 0xff, position: 1, write: "writeUInt8", read: "readUInt8"},
+        ],
+        [
+            "uint16-like",
+            {
+                value: Number.NaN,
+                types: [
+                    Zcl.DataType.DATA16,
+                    Zcl.DataType.BITMAP16,
+                    Zcl.DataType.UINT16,
+                    Zcl.DataType.ENUM16,
+                    Zcl.DataType.CLUSTER_ID,
+                    Zcl.DataType.ATTR_ID,
+                ],
+            },
+            {written: 0xffff, position: 2, write: "writeUInt16", read: "readUInt16"},
+        ],
+        [
+            "uint24-like",
+            {value: Number.NaN, types: [Zcl.DataType.DATA24, Zcl.DataType.BITMAP24, Zcl.DataType.UINT24]},
+            {written: 0xffffff, position: 3, write: "writeUInt24", read: "readUInt24"},
+        ],
+        [
+            "uint32-like",
+            {value: Number.NaN, types: [Zcl.DataType.DATA32, Zcl.DataType.BITMAP32, Zcl.DataType.UINT32, Zcl.DataType.UTC, Zcl.DataType.BAC_OID]},
+            {written: 0xffffffff, position: 4, write: "writeUInt32", read: "readUInt32"},
+        ],
+        [
+            "uint40-like",
+            {value: Number.NaN, types: [Zcl.DataType.DATA40, Zcl.DataType.BITMAP40, Zcl.DataType.UINT40]},
+            {written: 0xffffffffff, position: 5, write: "writeUInt40", read: "readUInt40"},
+        ],
+        [
+            "uint48-like",
+            {value: Number.NaN, types: [Zcl.DataType.DATA48, Zcl.DataType.BITMAP48, Zcl.DataType.UINT48]},
+            {written: 0xffffffffffff, position: 6, write: "writeUInt48", read: "readUInt48"},
+        ],
+        [
+            "uint56-like",
+            {value: undefined, types: [Zcl.DataType.DATA56, Zcl.DataType.BITMAP56, Zcl.DataType.UINT56]},
+            {written: 0xffffffffffffffn, position: 7, write: "writeUInt56", read: "readUInt56"},
+        ],
+        [
+            "uint64-like",
+            {value: undefined, types: [Zcl.DataType.DATA64, Zcl.DataType.BITMAP64, Zcl.DataType.UINT64]},
+            {written: 0xffffffffffffffffn, position: 8, write: "writeUInt64", read: "readUInt64"},
+        ],
+        [
+            "octectStr",
+            {value: undefined, types: [Zcl.DataType.OCTET_STR]},
+            {written: 0xff, valueRead: Buffer.from([]), position: 1, write: "writeUInt8", read: "readUInt8"},
+        ],
+        [
+            "longOctectStr",
+            {value: undefined, types: [Zcl.DataType.LONG_OCTET_STR]},
+            {written: 0xffff, valueRead: Buffer.from([]), position: 2, write: "writeUInt16", read: "readUInt16"},
+        ],
+        [
+            "charStr",
+            {value: undefined, types: [Zcl.DataType.CHAR_STR]},
+            {written: 0xff, valueRead: "", position: 1, write: "writeUInt8", read: "readUInt8"},
+        ],
+        [
+            "longCharStr",
+            {value: undefined, types: [Zcl.DataType.LONG_CHAR_STR]},
+            {written: 0xffff, valueRead: "", position: 2, write: "writeUInt16", read: "readUInt16"},
+        ],
+        [
+            "array",
+            {value: undefined, types: [Zcl.DataType.ARRAY]},
+            {written: 0xffff00, valueRead: [], position: 3, write: "writeUInt16", read: "readUInt16"},
+        ],
+        [
+            "struct",
+            {value: undefined, types: [Zcl.DataType.STRUCT]},
+            {written: 0xffff, valueRead: [], position: 2, write: "writeUInt16", read: "readUInt16"},
+        ],
+    ])("Writes & Reads non-value for %s", (_name, payload, expected) => {
+        for (const type of payload.types) {
+            const buffer = Buffer.alloc(255);
+            const buffalo = new BuffaloZcl(buffer);
+            const writeSpy = vi.spyOn(buffalo, expected.write as keyof BuffaloZcl);
+            const readSpy = vi.spyOn(buffalo, expected.read as keyof BuffaloZcl);
+
+            buffalo.write(type, payload.value, {});
+            expect(writeSpy).toHaveBeenCalledTimes(1);
+            expect(buffalo.getPosition()).toStrictEqual(expected.position);
+            const expectedWrittenBuf = Buffer.alloc(expected.position);
+
+            if (typeof expected.written === "bigint") {
+                if (expected.position === 7) {
+                    const unsignedValue = expected.written < 0n ? (1n << 56n) + expected.written : expected.written;
+                    expectedWrittenBuf.writeUIntLE(Number(unsignedValue & 0xffffffffffffn), 0, 6);
+                    expectedWrittenBuf.writeUInt8(Number(unsignedValue >> 48n), 0 + 6);
+                } else {
+                    expectedWrittenBuf.writeBigUInt64LE(expected.written, 0);
+                }
+            } else {
+                expectedWrittenBuf.writeUIntLE(expected.written, 0, expected.position);
+            }
+
+            expect(buffalo.getWritten()).toStrictEqual(expectedWrittenBuf);
+
+            buffalo.setPosition(0);
+
+            expect(buffalo.read(type, {})).toStrictEqual("valueRead" in expected ? expected.valueRead : payload.value);
+            expect(readSpy).toHaveBeenCalledTimes(1);
+            expect(buffalo.getPosition()).toStrictEqual(expected.position);
+        }
+    });
+
+    it.each([
+        ["int8-like", {value: Number.NaN, type: Zcl.DataType.INT8}, {written: -0x80, position: 1, write: "writeInt8", read: "readInt8"}],
+        ["int16-like", {value: Number.NaN, type: Zcl.DataType.INT16}, {written: -0x8000, position: 2, write: "writeInt16", read: "readInt16"}],
+        ["int24-like", {value: Number.NaN, type: Zcl.DataType.INT24}, {written: -0x800000, position: 3, write: "writeInt24", read: "readInt24"}],
+        ["int32-like", {value: Number.NaN, type: Zcl.DataType.INT32}, {written: -0x80000000, position: 4, write: "writeInt32", read: "readInt32"}],
+        ["int40-like", {value: Number.NaN, type: Zcl.DataType.INT40}, {written: -0x8000000000, position: 5, write: "writeInt40", read: "readInt40"}],
+        [
+            "int48-like",
+            {value: Number.NaN, type: Zcl.DataType.INT48},
+            {written: -0x800000000000, position: 6, write: "writeInt48", read: "readInt48"},
+        ],
+        [
+            "int56-like",
+            {value: undefined, type: Zcl.DataType.INT56},
+            {written: -0x80000000000000n, position: 7, write: "writeInt56", read: "readInt56"},
+        ],
+        [
+            "int64-like",
+            {value: undefined, type: Zcl.DataType.INT64},
+            {written: -0x8000000000000000n, position: 8, write: "writeInt64", read: "readInt64"},
+        ],
+    ])("Writes & Reads signed non-value for %s", (_name, payload, expected) => {
+        const buffer = Buffer.alloc(255);
+        const buffalo = new BuffaloZcl(buffer);
+        const writeSpy = vi.spyOn(buffalo, expected.write as keyof BuffaloZcl);
+        const readSpy = vi.spyOn(buffalo, expected.read as keyof BuffaloZcl);
+
+        buffalo.write(payload.type, payload.value, {});
+        expect(writeSpy).toHaveBeenCalledTimes(1);
+        expect(buffalo.getPosition()).toStrictEqual(expected.position);
+        const expectedWrittenBuf = Buffer.alloc(expected.position);
+
+        if (typeof expected.written === "bigint") {
+            if (expected.position === 7) {
+                const unsignedValue = expected.written < 0n ? (1n << 56n) + expected.written : expected.written;
+                expectedWrittenBuf.writeUIntLE(Number(unsignedValue & 0xffffffffffffn), 0, 6);
+                expectedWrittenBuf.writeUInt8(Number(unsignedValue >> 48n), 0 + 6);
+            } else {
+                expectedWrittenBuf.writeBigInt64LE(expected.written, 0);
+            }
+        } else {
+            expectedWrittenBuf.writeIntLE(expected.written, 0, expected.position);
+        }
+
+        expect(buffalo.getWritten()).toStrictEqual(expectedWrittenBuf);
+
+        buffalo.setPosition(0);
+
+        expect(buffalo.read(payload.type, {})).toStrictEqual("valueRead" in expected ? expected.valueRead : payload.value);
+        expect(readSpy).toHaveBeenCalledTimes(1);
+        expect(buffalo.getPosition()).toStrictEqual(expected.position);
+    });
+
     it("Reads whole buffer without length option", () => {
         const value = [1, 2, 3, 4];
         const buffer = Buffer.alloc(4);
@@ -181,8 +348,7 @@ describe("ZCL Buffalo", () => {
         expect(writeSpy).toHaveBeenCalledWith(Buffer.from(value), value.length);
         expect(buffalo.getPosition()).toStrictEqual(value.length);
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.BuffaloZclDataType.BUFFER, {})).toStrictEqual(Buffer.from(value));
         expect(readSpy).toHaveBeenCalledTimes(1);
@@ -204,8 +370,7 @@ describe("ZCL Buffalo", () => {
         expect(writeSpy).toHaveBeenCalledWith(Buffer.from(value), value.length);
         expect(buffalo.getPosition()).toStrictEqual(value.length);
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.BuffaloZclDataType.BUFFER, {length})).toStrictEqual(Buffer.from([value[0], value[1]]));
         expect(readSpy).toHaveBeenCalledTimes(1);
@@ -222,8 +387,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expectedPosition);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from([value.length, ...value]));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.DataType.OCTET_STR, {})).toStrictEqual(Buffer.from(value));
         expect(buffalo.getPosition()).toStrictEqual(expectedPosition);
@@ -238,8 +402,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expectedPosition);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from([value.length, 0 /*length uint16*/, ...value]));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.DataType.LONG_OCTET_STR, {})).toStrictEqual(Buffer.from(value));
         expect(buffalo.getPosition()).toStrictEqual(expectedPosition);
@@ -265,8 +428,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expectedPosition);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expectedValue));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.DataType.CHAR_STR, {})).toStrictEqual(value);
         expect(buffalo.getPosition()).toStrictEqual(expectedPosition);
@@ -318,8 +480,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expectedPosition);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expectedValue));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.DataType.LONG_CHAR_STR, {})).toStrictEqual(value);
         expect(buffalo.getPosition()).toStrictEqual(expectedPosition);
@@ -368,8 +529,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expected.written.length);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expected.written));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.DataType.ARRAY, {})).toStrictEqual(payload.value.elements);
         expect(buffalo.getPosition()).toStrictEqual(expected.written.length);
@@ -463,8 +623,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expected.written.length);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expected.written));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.DataType.STRUCT, {})).toStrictEqual(payload.value);
         expect(buffalo.getPosition()).toStrictEqual(expected.written.length);
@@ -479,8 +638,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expectedWritten.length);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expectedWritten));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.DataType.TOD, {})).toStrictEqual(value);
         expect(buffalo.getPosition()).toStrictEqual(expectedWritten.length);
@@ -495,25 +653,21 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expectedWritten.length);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expectedWritten));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.DataType.DATE, {})).toStrictEqual(value);
         expect(buffalo.getPosition()).toStrictEqual(expectedWritten.length);
     });
 
     it.each([
-        ["octet str", {type: Zcl.DataType.OCTET_STR, position: 1, returned: Buffer.from([])}],
-        ["char str", {type: Zcl.DataType.CHAR_STR, position: 1, returned: ""}],
-        ["long octet str", {type: Zcl.DataType.LONG_OCTET_STR, position: 2, returned: Buffer.from([])}],
-        ["long char str", {type: Zcl.DataType.LONG_CHAR_STR, position: 2, returned: ""}],
-        ["array", {type: Zcl.DataType.ARRAY, position: 3, returned: []}],
-        ["struct", {type: Zcl.DataType.STRUCT, position: 2, returned: []}],
         [
             "time of day",
-            {type: Zcl.DataType.TOD, position: 4, returned: {hours: undefined, minutes: undefined, seconds: undefined, hundredths: undefined}},
+            {type: Zcl.DataType.TOD, position: 4, returned: {hours: Number.NaN, minutes: Number.NaN, seconds: Number.NaN, hundredths: Number.NaN}},
+        ],
+        [
+            "date",
+            {type: Zcl.DataType.DATE, position: 4, returned: {year: Number.NaN, month: Number.NaN, dayOfMonth: Number.NaN, dayOfWeek: Number.NaN}},
         ],
-        ["date", {type: Zcl.DataType.DATE, position: 4, returned: {year: undefined, month: undefined, dayOfMonth: undefined, dayOfWeek: undefined}}],
         ["mi struct", {type: Zcl.BuffaloZclDataType.MI_STRUCT, position: 1, returned: {}}],
     ])("Reads Non-Value for %s", (_name, payload) => {
         const buffalo = new BuffaloZcl(Buffer.alloc(50, 0xff));
@@ -522,13 +676,12 @@ describe("ZCL Buffalo", () => {
     });
 
     it.each([
-        // TODO: others not yet supported
         [
             "time of day",
             {
                 type: Zcl.DataType.TOD,
                 position: 4,
-                value: {hours: undefined, minutes: undefined, seconds: undefined, hundredths: undefined},
+                value: {hours: Number.NaN, minutes: Number.NaN, seconds: Number.NaN, hundredths: Number.NaN},
                 written: [0xff, 0xff, 0xff, 0xff],
             },
         ],
@@ -537,7 +690,7 @@ describe("ZCL Buffalo", () => {
             {
                 type: Zcl.DataType.DATE,
                 position: 4,
-                value: {year: undefined, month: undefined, dayOfMonth: undefined, dayOfWeek: undefined},
+                value: {year: Number.NaN, month: Number.NaN, dayOfMonth: Number.NaN, dayOfWeek: Number.NaN},
                 written: [0xff, 0xff, 0xff, 0xff],
             },
         ],
@@ -550,8 +703,8 @@ describe("ZCL Buffalo", () => {
     });
 
     it.each([
-        ["time of day", {type: Zcl.DataType.TOD, value: {hours: 1, minutes: 2, seconds: undefined, hundredths: 3}, written: [1, 2, 0xff, 3]}],
-        ["date", {type: Zcl.DataType.DATE, value: {year: 1901, month: 2, dayOfMonth: undefined, dayOfWeek: 3}, written: [1, 2, 0xff, 3]}],
+        ["time of day", {type: Zcl.DataType.TOD, value: {hours: 1, minutes: 2, seconds: Number.NaN, hundredths: 3}, written: [1, 2, 0xff, 3]}],
+        ["date", {type: Zcl.DataType.DATE, value: {year: 1901, month: 2, dayOfMonth: Number.NaN, dayOfWeek: 3}, written: [1, 2, 0xff, 3]}],
     ])("Writes & Reads partial Non-Value for %s", (_name, payload) => {
         const buffer = Buffer.alloc(10);
         const buffalo = new BuffaloZcl(buffer);
@@ -559,8 +712,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(payload.written.length);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(payload.written));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(payload.type, {})).toStrictEqual(payload.value);
         expect(buffalo.getPosition()).toStrictEqual(payload.written.length);
@@ -573,17 +725,14 @@ describe("ZCL Buffalo", () => {
     ])("Writes & Reads Use Data Type for %s", (_name, payload, expected) => {
         const buffer = Buffer.alloc(255);
         const buffalo = new BuffaloZcl(buffer);
-        // @ts-expect-error dynamic
-        const writeSpy = vi.spyOn(buffalo, expected.write);
-        // @ts-expect-error dynamic
-        const readSpy = vi.spyOn(buffalo, expected.read);
+        const writeSpy = vi.spyOn(buffalo, expected.write as keyof BuffaloZcl);
+        const readSpy = vi.spyOn(buffalo, expected.read as keyof BuffaloZcl);
 
         buffalo.write(Zcl.BuffaloZclDataType.USE_DATA_TYPE, payload.value, {dataType: payload.type});
         expect(writeSpy).toHaveBeenCalledTimes(1);
         expect(buffalo.getPosition()).toStrictEqual(expected.position);
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.BuffaloZclDataType.USE_DATA_TYPE, {dataType: payload.type})).toStrictEqual(payload.value);
         expect(readSpy).toHaveBeenCalledTimes(1);
@@ -600,15 +749,13 @@ describe("ZCL Buffalo", () => {
         expect(writeSpy).toHaveBeenCalledTimes(1);
         expect(writeSpy).toHaveBeenCalledWith(value, value.length);
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.BuffaloZclDataType.USE_DATA_TYPE, {})).toStrictEqual(Buffer.from(value));
         expect(readSpy).toHaveBeenCalledTimes(1);
         expect(readSpy).toHaveBeenCalledWith(value.length);
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.BuffaloZclDataType.USE_DATA_TYPE, {length: 1})).toStrictEqual(Buffer.from([value[0]]));
         expect(readSpy).toHaveBeenCalledTimes(2);
@@ -648,8 +795,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expectedWritten.length);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expectedWritten));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.BuffaloZclDataType.LIST_ZONEINFO, {length: value.length})).toStrictEqual(value);
         expect(buffalo.getPosition()).toStrictEqual(expectedWritten.length);
@@ -684,8 +830,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expected.written.length);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expected.written));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.BuffaloZclDataType.EXTENSION_FIELD_SETS, {})).toStrictEqual(payload.value);
         expect(buffalo.getPosition()).toStrictEqual(expected.written.length);
@@ -760,8 +905,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expected.written.length);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expected.written));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.BuffaloZclDataType.LIST_THERMO_TRANSITIONS, payload.readOptions)).toStrictEqual(payload.value);
         expect(buffalo.getPosition()).toStrictEqual(expected.written.length);
@@ -817,7 +961,9 @@ describe("ZCL Buffalo", () => {
             const value = [0xff, 0x00];
             const buffalo = new BuffaloZcl(Buffer.from(value), value.length /* pos at end*/);
 
-            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0x1ff, payloadSize: 2}})).toStrictEqual({});
+            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0x1ff, payloadSize: value.length}})).toStrictEqual({
+                raw: Buffer.from([]),
+            });
         });
 
         it("Writes commissioning", () => {
@@ -844,7 +990,7 @@ describe("ZCL Buffalo", () => {
             const value = [0xff /*device*/, 0x00 /*options*/];
             const buffalo = new BuffaloZcl(Buffer.from(value));
 
-            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0xe0}})).toStrictEqual({
+            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {payloadSize: value.length, commandID: 0xe0}})).toStrictEqual({
                 deviceID: 0xff,
                 options: 0x00,
                 extendedOptions: 0x00,
@@ -956,7 +1102,7 @@ describe("ZCL Buffalo", () => {
             ];
             const buffalo = new BuffaloZcl(Buffer.from(value));
 
-            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0xe0}})).toStrictEqual({
+            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {payloadSize: value.length, commandID: 0xe0}})).toStrictEqual({
                 deviceID: 0xff,
                 options: 0x80 | 0x04,
                 extendedOptions: 0x20 | 0x40 | 0x80,
@@ -1013,7 +1159,7 @@ describe("ZCL Buffalo", () => {
             const value = [0xfa];
             const buffalo = new BuffaloZcl(Buffer.from(value));
 
-            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0xe3}})).toStrictEqual({
+            expect(buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {payloadSize: value.length, commandID: 0xe3}})).toStrictEqual({
                 nextChannel: 0xa,
                 nextNextChannel: 0xf,
             });
@@ -1080,11 +1226,11 @@ describe("ZCL Buffalo", () => {
             expect(buffalo.getWritten()).toStrictEqual(Buffer.alloc(0));
         });
 
-        it("Throws when read is missing payload.payloadSize option when payload.commandID is 0xA1", () => {
+        it("Throws when read is missing payload.payloadSize option", () => {
             expect(() => {
                 const buffalo = new BuffaloZcl(Buffer.alloc(1));
                 buffalo.read(Zcl.BuffaloZclDataType.GPD_FRAME, {payload: {commandID: 0xa1}});
-            }).toThrow("Cannot read GPD_FRAME with commandID=0xA1 without payloadSize options specified");
+            }).toThrow("Cannot read GPD_FRAME without required payload options specified");
         });
     });
 
@@ -1102,8 +1248,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expected.written.length);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expected.written));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.BuffaloZclDataType.STRUCTURED_SELECTOR, {})).toStrictEqual(payload.value);
         expect(buffalo.getPosition()).toStrictEqual(expected.written.length);
@@ -1156,8 +1301,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expected.written.length);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expected.written));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.BuffaloZclDataType.LIST_TUYA_DATAPOINT_VALUES, {})).toStrictEqual(payload.value);
         expect(buffalo.getPosition()).toStrictEqual(expected.written.length);
@@ -1206,8 +1350,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expectedWritten.length);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expectedWritten));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.BuffaloZclDataType.LIST_MIBOXER_ZONES, {length: value.length})).toStrictEqual(value);
         expect(buffalo.getPosition()).toStrictEqual(expectedWritten.length);
@@ -1223,8 +1366,7 @@ describe("ZCL Buffalo", () => {
         expect(buffalo.getPosition()).toStrictEqual(expectedPosition);
         expect(buffalo.getWritten()).toStrictEqual(Buffer.from(expectedWritten));
 
-        // @ts-expect-error private
-        buffalo.position = 0;
+        buffalo.setPosition(0);
 
         expect(buffalo.read(Zcl.BuffaloZclDataType.BIG_ENDIAN_UINT24, {})).toStrictEqual(value);
         expect(buffalo.getPosition()).toStrictEqual(expectedPosition);