@matter/protocol 0.11.0-alpha.0-20241005-e3e4e4a7a

package/src/interaction/AttributeDataDecoder.ts

@@ -0,0 +1,266 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Diagnostic, Logger, UnexpectedDataError } from "#general";
+import {
+    ArraySchema,
+    Attribute,
+    AttributeError,
+    AttributeId,
+    AttributeJsType,
+    ClusterId,
+    EndpointNumber,
+    getClusterAttributeById,
+    getClusterById,
+    NodeId,
+    TlvAny,
+    TlvAttributeData,
+    TlvAttributeReport,
+    TlvSchema,
+    TypeFromSchema,
+} from "#types";
+
+const logger = Logger.get("AttributeDataDecoder");
+
+/** Represents a fully qualified and decoded attribute value from a received DataReport */
+export type DecodedAttributeReportValue<T> = {
+    path: {
+        nodeId?: NodeId;
+        endpointId: EndpointNumber;
+        clusterId: ClusterId;
+        attributeId: AttributeId;
+        attributeName: string;
+    };
+    version: number;
+    value: T;
+};
+
+/** Represents a decoded attribute value from a received DataReport where data version could be optional. */
+export type DecodedAttributeValue<T> = Omit<DecodedAttributeReportValue<T>, "version"> & {
+    version?: number;
+};
+
+/**
+ * Parses, normalizes (e.g. un-chunk arrays and resolve Tag compression if used) and decodes the attribute data from
+ * a received DataReport.
+ */
+export function normalizeAndDecodeReadAttributeReport(
+    data: TypeFromSchema<typeof TlvAttributeReport>[],
+): DecodedAttributeReportValue<any>[] {
+    // TODO Decide how to handle the attribute report status field, right now we ignore it
+    const dataValues = data.flatMap(({ attributeData }) => (attributeData !== undefined ? attributeData : []));
+
+    return normalizeAndDecodeAttributeData(dataValues) as DecodedAttributeReportValue<any>[]; // dataVersion existing in incoming data, so must also in outgoing data
+}
+
+export function expandPathsInAttributeData(
+    data: TypeFromSchema<typeof TlvAttributeData>[],
+    acceptWildcardPaths = false,
+): TypeFromSchema<typeof TlvAttributeData>[] {
+    // Fill in missing path elements and restore dataVersion when tag compression is used
+    let lastPath:
+        | {
+              nodeId?: NodeId;
+              endpointId: EndpointNumber;
+              clusterId: ClusterId;
+              attributeId: AttributeId;
+              dataVersion?: number;
+          }
+        | undefined;
+    data.forEach(value => {
+        if (value === undefined) return;
+        const { path } = value;
+        if (path.enableTagCompression) {
+            if (lastPath === undefined) throw new UnexpectedDataError("Tag compression enabled, but no previous path");
+            if (path.nodeId === undefined && lastPath.nodeId !== undefined) path.nodeId = lastPath.nodeId;
+            if (path.endpointId === undefined) path.endpointId = lastPath.endpointId;
+            if (path.clusterId === undefined) path.clusterId = lastPath.clusterId;
+            if (path.attributeId === undefined) path.attributeId = lastPath.attributeId;
+            if (value.dataVersion === undefined && lastPath.dataVersion !== undefined)
+                value.dataVersion = lastPath.dataVersion;
+        } else if (path.endpointId !== undefined && path.clusterId !== undefined && path.attributeId !== undefined) {
+            lastPath = {
+                nodeId: path.nodeId,
+                endpointId: path.endpointId,
+                clusterId: path.clusterId,
+                attributeId: path.attributeId,
+                dataVersion: value.dataVersion,
+            };
+        } else if (!acceptWildcardPaths) {
+            throw new UnexpectedDataError("Tag compression disabled, but path is incomplete: " + Logger.toJSON(path));
+        }
+    });
+    return data;
+}
+
+/**
+ * Normalizes (e.g. prepare data for array un-chinking and resolve Tag compression if used) the attribute details from
+ * a received DataReport.
+ */
+export function normalizeAttributeData(
+    data: TypeFromSchema<typeof TlvAttributeData>[],
+    acceptWildcardPaths = false,
+): TypeFromSchema<typeof TlvAttributeData>[][] {
+    const expandedData = expandPathsInAttributeData(data, acceptWildcardPaths);
+    // Put all returned values into a map to group by path
+    const responseList = new Map<string, TypeFromSchema<typeof TlvAttributeData>[]>();
+    expandedData.forEach(value => {
+        if (!value) return;
+        const {
+            path: { nodeId, endpointId, clusterId, attributeId },
+        } = value;
+        const mapId = `${nodeId}-${endpointId}-${clusterId}-${attributeId}`;
+        const list = responseList.get(mapId) || [];
+        list.push(value);
+        responseList.set(mapId, list);
+    });
+
+    return Array.from(responseList.values());
+}
+
+/**
+ * Normalizes (e.g. un-chunk arrays and resolve Tag compression if used) and decodes the attribute data from a received
+ * DataReport.
+ */
+export function normalizeAndDecodeAttributeData(
+    data: TypeFromSchema<typeof TlvAttributeData>[],
+): DecodedAttributeValue<any>[] {
+    const responseList = normalizeAttributeData(data);
+    const result = new Array<DecodedAttributeValue<any>>();
+    responseList.forEach(values => {
+        const {
+            path: { nodeId, endpointId, clusterId, attributeId },
+            dataVersion,
+        } = values[0];
+
+        if (endpointId === undefined || clusterId === undefined || attributeId === undefined) {
+            throw new UnexpectedDataError(`Invalid attribute path ${endpointId}/${clusterId}/${attributeId}`);
+        }
+        try {
+            const cluster = getClusterById(clusterId);
+            const attributeDetail = getClusterAttributeById(cluster, attributeId);
+            if (attributeDetail === undefined) {
+                logger.debug(
+                    `Decode unknown attribute ${Diagnostic.hex(clusterId)}/${Diagnostic.hex(attributeId)} via the AnySchema.`,
+                );
+
+                const attributeName = `Unknown (${Diagnostic.hex(attributeId)})`;
+                const value = decodeUnknownAttributeValue(values);
+                result.push({
+                    path: { nodeId, endpointId, clusterId, attributeId, attributeName },
+                    version: dataVersion,
+                    value,
+                });
+
+                return;
+            }
+            const { attribute, name } = attributeDetail;
+            const value = decodeValueForAttribute(attribute, values);
+            result.push({
+                path: { nodeId, endpointId, clusterId, attributeId, attributeName: name },
+                version: dataVersion,
+                value,
+            });
+        } catch (error: any) {
+            logger.error(
+                `Error decoding attribute ${endpointId}/${Diagnostic.hex(clusterId)}/${Diagnostic.hex(attributeId)}: ${
+                    error.message
+                }`,
+            );
+        }
+    });
+    return result;
+}
+
+/** Decodes the data for one known attribute identified by its Attribute definition including array un-chunking. */
+function decodeValueForAttribute<A extends Attribute<any, any>>(
+    attribute: A,
+    values: TypeFromSchema<typeof TlvAttributeData>[],
+): AttributeJsType<A> | undefined {
+    const { schema, optional, default: conformanceValue } = attribute;
+
+    // No values, so use default value if available
+    if (!values.length) {
+        if (optional) return undefined;
+        if (conformanceValue === undefined) throw new AttributeError(`Attribute not found.`);
+        return conformanceValue;
+    }
+
+    return decodeAttributeValueWithSchema(schema, values);
+}
+
+export function decodeListAttributeValueWithSchema<T>(
+    schema: TlvSchema<T>,
+    values: TypeFromSchema<typeof TlvAttributeData>[],
+    currentValue?: T,
+): T | undefined {
+    // Return contained multiple tlv values as an array
+    if (!(schema instanceof ArraySchema)) {
+        throw new UnexpectedDataError(`Attribute is not an list but multiple values were returned.`);
+    }
+    return schema.decodeFromChunkedArray(
+        values.map(({ data, path: { listIndex } }) => ({ listIndex, element: data })),
+        currentValue as any,
+    ) as T;
+}
+
+/** Decodes the data for one attribute via a schema including array un-chunking. */
+export function decodeAttributeValueWithSchema<T>(
+    schema: TlvSchema<T>,
+    values: TypeFromSchema<typeof TlvAttributeData>[],
+    defaultValue?: T,
+): T | undefined {
+    // No values, so use default value if available
+    if (!values.length) {
+        return defaultValue;
+    }
+
+    // The value was returned as one Tlv value, so decode it normally
+    if (values.length === 1 && values[0].path.listIndex === undefined) {
+        return schema.decodeTlv(values[0].data);
+    }
+
+    return decodeListAttributeValueWithSchema(schema, values, defaultValue);
+}
+
+/** Decodes the data for one unknown attribute via the AnySchema including array un-chunking. */
+export function decodeUnknownAttributeValue(values: TypeFromSchema<typeof TlvAttributeData>[]): any {
+    const schema = TlvAny;
+    // No values, so use default value if available
+    if (!values.length) {
+        return undefined;
+    }
+
+    // The value was returned as one Tlv value, so decode it normally
+    if (values.length === 1 && values[0].path.listIndex === undefined) {
+        const tlvEncoded = schema.decodeTlv(values[0].data);
+        return schema.decodeAnyTlvStream(tlvEncoded);
+    } else {
+        // Chunked any data
+        const tlvEncoded = new ArraySchema(schema).decodeFromChunkedArray(
+            values.map(({ data, path: { listIndex } }) => ({ listIndex, element: data })),
+        );
+        return tlvEncoded.map(element => schema.decodeAnyTlvStream(element));
+    }
+}
+
+/** Structure the data of a received DataReport into an endpointId/clusterId/attributeName object structure. */
+export function structureReadAttributeDataToClusterObject(data: DecodedAttributeReportValue<any>[]) {
+    const structure: { [key: number]: { [key: number]: { [key: string]: any } } } = {};
+    for (const {
+        path: { endpointId, clusterId, attributeName },
+        value,
+    } of data) {
+        if (structure[endpointId] === undefined) {
+            structure[endpointId] = {};
+        }
+        if (structure[endpointId][clusterId] === undefined) {
+            structure[endpointId][clusterId] = {};
+        }
+        structure[endpointId][clusterId][attributeName] = value;
+    }
+    return structure;
+}

package/src/interaction/AttributeDataEncoder.ts

@@ -0,0 +1,268 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Logger, MatterFlowError } from "#general";
+import {
+    ArraySchema,
+    AttributeId,
+    ClusterId,
+    EndpointNumber,
+    NodeId,
+    TlvAttributePath,
+    TlvAttributeReport,
+    TlvAttributeReportData,
+    TlvDataReport,
+    TlvEncodingOptions,
+    TlvEventData,
+    TlvEventReport,
+    TlvSchema,
+    TlvStream,
+    TypeFromSchema,
+} from "#types";
+
+type FullAttributePath = {
+    nodeId?: NodeId;
+    endpointId: EndpointNumber;
+    clusterId: ClusterId;
+    attributeId: AttributeId;
+    dataVersion?: number;
+};
+
+/** Type for TlvAttributeReport where the real data are represented with the schema and the JS value. */
+export type AttributeReportPayload = Omit<TypeFromSchema<typeof TlvAttributeReport>, "attributeData"> & {
+    attributeData?: AttributeDataPayload;
+    hasFabricSensitiveData: boolean;
+};
+
+/** Type for TlvAttributeReportData where the real data are represented with the schema and the JS value. */
+type AttributeDataPayload = Omit<TypeFromSchema<typeof TlvAttributeReportData>, "data"> & {
+    schema: TlvSchema<any>;
+    payload: any;
+};
+
+/** Type for TlvEventReport where the real data are represented with the schema and the JS value. */
+export type EventReportPayload = Omit<TypeFromSchema<typeof TlvEventReport>, "eventData"> & {
+    eventData?: EventDataPayload;
+    hasFabricSensitiveData: boolean;
+};
+
+/** Type for TlvEventData where the real data are represented with the schema and the JS value. */
+export type EventDataPayload = Omit<TypeFromSchema<typeof TlvEventData>, "data"> & {
+    schema: TlvSchema<any>;
+    payload: any;
+};
+
+/** Type for TlvDataReport where the real data are represented with the schema and the JS value. */
+export type DataReportPayload = Omit<TypeFromSchema<typeof TlvDataReport>, "attributeReports" | "eventReports"> & {
+    attributeReportsPayload?: AttributeReportPayload[];
+    eventReportsPayload?: EventReportPayload[];
+};
+
+/** Encodes an AttributeReportPayload into a TlvStream (used for TlvAny type). */
+export function encodeAttributePayload(
+    attributePayload: AttributeReportPayload,
+    options?: TlvEncodingOptions,
+): TlvStream {
+    const { attributeData, attributeStatus } = attributePayload;
+    if (attributeData === undefined) {
+        return TlvAttributeReport.encodeTlv({ attributeStatus });
+    }
+
+    const { path, schema, payload, dataVersion } = attributeData;
+    return TlvAttributeReport.encodeTlv({
+        attributeData: { path, data: schema.encodeTlv(payload, options), dataVersion },
+    });
+}
+
+/** Encodes an EventReportPayload into a TlvStream (used for TlvAny type). */
+export function encodeEventPayload(eventPayload: EventReportPayload, options?: TlvEncodingOptions): TlvStream {
+    const { eventData, eventStatus } = eventPayload;
+    if (eventData === undefined) {
+        return TlvEventReport.encodeTlv({ eventStatus });
+    }
+
+    const {
+        path,
+        schema,
+        payload,
+        eventNumber,
+        deltaEpochTimestamp,
+        epochTimestamp,
+        deltaSystemTimestamp,
+        systemTimestamp,
+        priority,
+    } = eventData;
+    return TlvEventReport.encodeTlv({
+        eventData: {
+            path,
+            data: schema.encodeTlv(payload, options),
+            priority,
+            systemTimestamp,
+            deltaSystemTimestamp,
+            deltaEpochTimestamp,
+            epochTimestamp,
+            eventNumber,
+        },
+    });
+}
+
+/** Return if an AttributeReportPayload can be chunked or not. */
+export function canAttributePayloadBeChunked(attributePayload: AttributeReportPayload): boolean {
+    const { attributeData } = attributePayload;
+    if (attributeData === undefined) {
+        return false;
+    }
+    const {
+        schema,
+        payload,
+        path: { listIndex },
+    } = attributeData;
+    return schema instanceof ArraySchema && Array.isArray(payload) && payload.length > 0 && listIndex === undefined;
+}
+
+/** Chunk an AttributeReportPayload into multiple AttributeReportPayloads. */
+export function chunkAttributePayload(attributePayload: AttributeReportPayload): AttributeReportPayload[] {
+    const { hasFabricSensitiveData, attributeData } = attributePayload;
+    if (attributeData === undefined) {
+        throw new MatterFlowError(
+            `Cannot chunk an AttributePayload with just a attributeStatus: ${Logger.toJSON(attributePayload)}`,
+        );
+    }
+    const { schema, path, dataVersion, payload } = attributeData;
+    if (!(schema instanceof ArraySchema) || !Array.isArray(payload)) {
+        throw new MatterFlowError(
+            `Cannot chunk an AttributePayload with attributeData that is not an array: ${Logger.toJSON(
+                attributePayload,
+            )}`,
+        );
+    }
+    const chunks = new Array<AttributeReportPayload>();
+    chunks.push({
+        hasFabricSensitiveData: hasFabricSensitiveData,
+        attributeData: { schema, path: { ...path, listIndex: undefined }, payload: [], dataVersion },
+    });
+    payload.forEach(element => {
+        chunks.push({
+            hasFabricSensitiveData: hasFabricSensitiveData,
+            attributeData: {
+                schema: schema.elementSchema,
+                path: { ...path, listIndex: null },
+                payload: element,
+                dataVersion,
+            },
+        });
+    });
+
+    // If the path of the initial AttributePayload was not compressed, we should compress the chunked data
+    // TODO Enable once Tag Compression is supported https://github.com/project-chip/connectedhomeip/issues/29359
+    /*
+    if (path.enableTagCompression !== true) {
+        return compressAttributeDataReportTags(chunks);
+    }
+    */
+
+    return chunks;
+}
+
+/**
+ * Sort function to sort AttributeReportPayloads by nodeId/EndpointId/clusterId/attributeId to generate an ideal
+ * ground for tag compression.
+ */
+export function sortAttributeDataByPath(data1: AttributeReportPayload, data2: AttributeReportPayload) {
+    const { path: path1 } = data1.attributeData ?? data1.attributeStatus ?? {};
+    const { path: path2 } = data2.attributeData ?? data2.attributeStatus ?? {};
+    if (path1?.nodeId !== undefined && path2?.nodeId !== undefined && path1.nodeId !== path2.nodeId) {
+        return path1.nodeId < path2.nodeId ? -1 : 1;
+    }
+    if (path1?.endpointId !== undefined && path2?.endpointId !== undefined && path1.endpointId !== path2.endpointId) {
+        return path1.endpointId < path2.endpointId ? -1 : 1;
+    }
+    if (path1?.clusterId !== undefined && path2?.clusterId !== undefined && path1.clusterId !== path2.clusterId) {
+        return path1.clusterId < path2.clusterId ? -1 : 1;
+    }
+    if (
+        path1?.attributeId !== undefined &&
+        path2?.attributeId !== undefined &&
+        path1.attributeId !== path2.attributeId
+    ) {
+        return path1.attributeId < path2.attributeId ? -1 : 1;
+    }
+    return 0;
+}
+
+/** Sort and use Tag compression to compress a list of AttributeReportPayloads. */
+export function compressAttributeDataReportTags(data: AttributeReportPayload[]) {
+    let lastFullPath: FullAttributePath | undefined;
+
+    return data.sort(sortAttributeDataByPath).map(({ hasFabricSensitiveData, attributeData, attributeStatus }) => {
+        if (attributeData !== undefined) {
+            const { path, dataVersion } = attributeData;
+            const compressedPath = compressPath(path, dataVersion, lastFullPath);
+            const { enableTagCompression } = compressedPath.path;
+            attributeData = {
+                ...attributeData,
+                path: compressedPath.path,
+                dataVersion: enableTagCompression ? undefined : dataVersion,
+            };
+            lastFullPath = compressedPath.lastFullPath;
+        }
+        if (attributeStatus !== undefined) {
+            const { path } = attributeStatus;
+            const compressedPath = compressPath(path, undefined, lastFullPath);
+            attributeStatus = { ...attributeStatus, path: compressedPath.path };
+            lastFullPath = compressedPath.lastFullPath;
+        }
+        return { hasFabricSensitiveData, attributeData, attributeStatus };
+    });
+}
+
+/** Helper method to compress one path and preserve the state for the next path. */
+function compressPath(
+    path: TypeFromSchema<typeof TlvAttributePath>,
+    dataVersion: number | undefined,
+    lastFullPath: FullAttributePath | undefined,
+): { path: TypeFromSchema<typeof TlvAttributePath>; lastFullPath?: FullAttributePath } {
+    const { nodeId, endpointId, clusterId, attributeId } = path;
+
+    // Should never happen but typing likes it better that way
+    if (endpointId === undefined || clusterId === undefined || attributeId === undefined) {
+        return { path, lastFullPath };
+    }
+
+    const newFullPath = {
+        path: { ...path, enableTagCompression: undefined },
+        lastFullPath: { nodeId, endpointId, clusterId, attributeId, dataVersion },
+    };
+    // We have no stored Full path, so we take this as starting point
+    if (lastFullPath === undefined) {
+        return newFullPath;
+    }
+
+    // When dataVersion differs we can't compress
+    if (dataVersion !== undefined && dataVersion !== lastFullPath.dataVersion) {
+        return newFullPath;
+    }
+
+    // Based on Specs in DataReports AttributeId and CLusterId SHALL always be present in the path
+    let compressedElements = 0;
+    // Assume we can compress elements in the path
+    const compressedPath = { ...path, enableTagCompression: true };
+    if (endpointId === lastFullPath.endpointId) {
+        delete compressedPath.endpointId;
+        compressedElements++;
+    }
+    if (nodeId === lastFullPath.nodeId && nodeId !== undefined) {
+        // No need to count if undefined
+        delete compressedPath.nodeId;
+        compressedElements++;
+    }
+
+    // Nothing was compressed, so we use this as new full path
+    if (compressedElements === 0) {
+        return newFullPath;
+    }
+
+    return { path: compressedPath, lastFullPath };
+}

package/src/interaction/EventDataDecoder.ts

@@ -0,0 +1,133 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Diagnostic, Logger, UnexpectedDataError } from "#general";
+import {
+    ClusterId,
+    EndpointNumber,
+    EventId,
+    EventNumber,
+    EventPriority,
+    getClusterById,
+    getClusterEventById,
+    NodeId,
+    TlvAny,
+    TlvEventData,
+    TlvEventReport,
+    TlvStream,
+    TypeFromSchema,
+} from "#types";
+
+const logger = Logger.get("EventDataDecoder");
+
+export type DecodedEventData<T> = {
+    eventNumber: EventNumber;
+    priority: EventPriority;
+    epochTimestamp?: number | bigint;
+    systemTimestamp?: number | bigint;
+    deltaEpochTimestamp?: number | bigint;
+    deltaSystemTimestamp?: number | bigint;
+    data?: T;
+};
+
+export type DecodedEventReportValue<T> = {
+    path: {
+        nodeId?: NodeId;
+        endpointId: EndpointNumber;
+        clusterId: ClusterId;
+        eventId: EventId;
+        eventName: string;
+    };
+    events: DecodedEventData<T>[];
+};
+
+export function normalizeAndDecodeReadEventReport(
+    data: TypeFromSchema<typeof TlvEventReport>[],
+): DecodedEventReportValue<any>[] {
+    // TODO Decide how to handle the attribute report status field, right now we ignore it
+    const dataValues = data.flatMap(({ eventData }) => (eventData !== undefined ? eventData : []));
+
+    return normalizeAndDecodeEventData(dataValues);
+}
+
+export function normalizeEventData(
+    data: TypeFromSchema<typeof TlvEventData>[],
+): TypeFromSchema<typeof TlvEventData>[][] {
+    // Put all returned values into a map to group by path
+    const responseList = new Map<string, TypeFromSchema<typeof TlvEventData>[]>(); // TODO CHECK
+    data.forEach(value => {
+        if (!value) return;
+        const {
+            path: { nodeId, endpointId, clusterId, eventId },
+        } = value;
+        const mapId = `${nodeId}-${endpointId}-${clusterId}-${eventId}`;
+        const list = responseList.get(mapId) || [];
+        list.push(value);
+        responseList.set(mapId, list);
+    });
+
+    return Array.from(responseList.values());
+}
+
+export function normalizeAndDecodeEventData(
+    data: TypeFromSchema<typeof TlvEventData>[],
+): DecodedEventReportValue<any>[] {
+    const responseList = normalizeEventData(data);
+    const result = new Array<DecodedEventReportValue<any>>();
+    responseList.forEach(values => {
+        const {
+            path: { nodeId, endpointId, clusterId, eventId },
+        } = values[0];
+
+        if (endpointId === undefined || clusterId === undefined || eventId === undefined) {
+            throw new UnexpectedDataError(`Invalid event path ${endpointId}/${clusterId}/${eventId}`);
+        }
+        try {
+            const cluster = getClusterById(clusterId);
+            const eventDetail = getClusterEventById(cluster, eventId);
+            if (eventDetail === undefined) {
+                logger.debug(
+                    `Decode unknown event ${Diagnostic.hex(clusterId)}/${Diagnostic.hex(eventId)} via the AnySchema.`,
+                );
+
+                const eventName = `Unknown (${Diagnostic.hex(eventId)})`;
+
+                const events = values.map(eventData => ({
+                    ...eventData,
+                    data: eventData.data === undefined ? undefined : decodeUnknownEventValue(eventData.data),
+                    path: undefined,
+                }));
+                result.push({ path: { nodeId, endpointId, clusterId, eventId, eventName }, events });
+
+                return;
+            }
+            const {
+                event: { schema },
+                name,
+            } = eventDetail;
+            const events = values.map(eventData => ({
+                ...eventData,
+                data: eventData.data === undefined ? undefined : schema.decodeTlv(eventData.data),
+                path: undefined,
+            }));
+            result.push({ path: { nodeId, endpointId, clusterId, eventId, eventName: name }, events });
+        } catch (error: any) {
+            logger.error(`Error decoding event ${endpointId}/${clusterId}/${eventId}: ${error.message}`);
+        }
+    });
+    return result;
+}
+
+export function decodeUnknownEventValue(data: TlvStream): any {
+    const schema = TlvAny;
+
+    if (data.length === 0) {
+        return undefined;
+    }
+
+    const tlvEncoded = schema.decodeTlv(data);
+    return schema.decodeAnyTlvStream(tlvEncoded);
+}