@project-chip/matter.js 0.4.0 → 0.5.0

package/dist/es/protocol/interaction/InteractionClient.js

@@ -12,91 +12,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { capitalize } from "../../util/String.js";
+import { TlvNoResponse, } from "../../cluster/Cluster.js";
+import { resolveAttributeName, resolveCommandName, resolveEventName } from "../../cluster/ClusterHelper.js";
+import { ImplementationError, MatterError, MatterFlowError, UnexpectedDataError } from "../../common/MatterError.js";
 import { Logger } from "../../log/Logger.js";
-import { IncomingInteractionClientMessenger, InteractionClientMessenger, StatusResponseError } from "./InteractionMessenger.js";
-import { attributePathToId, INTERACTION_PROTOCOL_ID } from "./InteractionServer.js";
 import { normalizeAndDecodeReadAttributeReport } from "./AttributeDataDecoder.js";
-import { TlvNoResponse } from "../../cluster/Cluster.js";
-import { AttributeClient } from "../../cluster/client/AttributeClient.js";
-import { tryCatchAsync } from "../../common/TryCatchHandler.js";
+import { normalizeAndDecodeReadEventReport } from "./EventDataDecoder.js";
+import { IncomingInteractionClientMessenger, InteractionClientMessenger, StatusResponseError, } from "./InteractionMessenger.js";
+import { attributePathToId, clusterPathToId, INTERACTION_PROTOCOL_ID } from "./InteractionServer.js";
 const logger = Logger.get("InteractionClient");
-export function ClusterClient(clusterDef, endpointId, interactionClient) {
-    const { id: clusterId, name, commands: commandDef, attributes: attributeDef } = clusterDef;
-    const attributes = {};
-    const result = {
-        id: clusterId,
-        name,
-        _type: "ClusterClient",
-        endpointId,
-        attributes,
-        commands: {},
-        subscribeAllAttributes: (minIntervalFloorSeconds, maxIntervalCeilingSeconds) => __awaiter(this, void 0, void 0, function* () {
-            if (interactionClient === undefined) {
-                throw new Error("InteractionClient not set");
-            }
-            return yield interactionClient.subscribeMultipleAttributes([{ endpointId: endpointId, clusterId: clusterId }], minIntervalFloorSeconds, maxIntervalCeilingSeconds, (data) => {
-                const { path, value } = data;
-                const attributeName = attributeToId[path.attributeId];
-                if (attributeName === undefined) {
-                    logger.warn("Unknown attribute id", path.attributeId);
-                    return;
-                }
-                attributes[attributeName].update(value);
-            });
-        }),
-        /**
-         * Clones the cluster client, optionally with a new interaction client.
-         * When the clusterClient is the same then also AttributeClients will be reused.
-         *
-         * @param newInteractionClient Optionally a new interactionClient to bind to
-         */
-        _clone(newInteractionClient) {
-            const clonedClusterClient = ClusterClient(clusterDef, endpointId, newInteractionClient !== null && newInteractionClient !== void 0 ? newInteractionClient : interactionClient);
-            if (newInteractionClient === undefined) {
-                // When we keep the InteractionClient we also reuse the AttributeServers bound to it
-                clonedClusterClient.attributes = attributes;
-            }
-            return clonedClusterClient;
-        }
-    };
-    const attributeToId = {};
-    // Add accessors
-    for (const attributeName in attributeDef) {
-        const attribute = attributeDef[attributeName];
-        attributes[attributeName] = new AttributeClient(attribute, attributeName, endpointId, clusterId, () => __awaiter(this, void 0, void 0, function* () { return interactionClient; }));
-        attributeToId[attribute.id] = attributeName;
-        const capitalizedAttributeName = capitalize(attributeName);
-        result[`get${capitalizedAttributeName}Attribute`] = (alwaysRequestFromRemote = false) => __awaiter(this, void 0, void 0, function* () {
-            return yield tryCatchAsync(() => __awaiter(this, void 0, void 0, function* () {
-                return yield attributes[attributeName].get(alwaysRequestFromRemote);
-            }), StatusResponseError, (e) => {
-                const { code } = e;
-                if (code === 134 /* StatusCode.UnsupportedAttribute */) {
-                    return undefined;
-                }
-                throw e;
-            });
-        });
-        result[`set${capitalizedAttributeName}Attribute`] = (value) => __awaiter(this, void 0, void 0, function* () { return attributes[attributeName].set(value); });
-        result[`subscribe${capitalizedAttributeName}Attribute`] = (listener, minIntervalS, maxIntervalS) => __awaiter(this, void 0, void 0, function* () {
-            attributes[attributeName].addListener(listener);
-            attributes[attributeName].subscribe(minIntervalS, maxIntervalS);
-        });
-    }
-    // Add command calls
-    for (const commandName in commandDef) {
-        const { requestId, requestSchema, responseId, responseSchema, optional } = commandDef[commandName];
-        result.commands[commandName] = (request) => __awaiter(this, void 0, void 0, function* () {
-            if (interactionClient === undefined) {
-                throw new Error("InteractionClient not set");
-            }
-            return interactionClient.invoke(endpointId, clusterId, request, requestId, requestSchema, responseId, responseSchema, optional);
-        });
-        result[commandName] = result.commands[commandName];
-    }
-    return result;
-}
+const REQUEST_ALL = [{}];
 export class SubscriptionClient {
     constructor(subscriptionListeners) {
         this.subscriptionListeners = subscriptionListeners;
@@ -111,12 +36,12 @@ export class SubscriptionClient {
             const subscriptionId = dataReport.subscriptionId;
             if (subscriptionId === undefined) {
                 yield messenger.sendStatus(125 /* StatusCode.InvalidSubscription */);
-                throw new Error("Invalid Data report without Subscription ID");
+                throw new UnexpectedDataError("Invalid Data report without Subscription ID");
             }
             const listener = this.subscriptionListeners.get(subscriptionId);
             if (listener === undefined) {
                 yield messenger.sendStatus(125 /* StatusCode.InvalidSubscription */);
-                throw new Error(`Unknown subscription ID ${subscriptionId}`);
+                throw new UnexpectedDataError(`Unknown subscription ID ${subscriptionId}`);
             }
             yield messenger.sendStatus(0 /* StatusCode.Success */);
             listener(dataReport);
@@ -128,58 +53,137 @@ export class InteractionClient {
         this.exchangeProvider = exchangeProvider;
         this.subscriptionListeners = new Map();
         this.subscribedLocalValues = new Map();
+        this.subscribedClusterDataVersions = new Map();
         // TODO: Right now we potentially add multiple handlers for the same protocol, We need to fix this
         this.exchangeProvider.addProtocolHandler(new SubscriptionClient(this.subscriptionListeners));
     }
-    getAllAttributes() {
+    getAllAttributes(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.getMultipleAttributes([{ /* empty means *,*,* */}]);
+            const { dataVersionFilters, isFabricFiltered } = options;
+            return (yield this.getMultipleAttributesAndEvents({
+                attributes: REQUEST_ALL,
+                dataVersionFilters,
+                isFabricFiltered,
+            })).attributeReports;
         });
     }
-    getMultipleAttributes(attributeRequests) {
+    getAllEvents(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { eventFilters, isFabricFiltered } = options;
+            return (yield this.getMultipleAttributesAndEvents({ events: REQUEST_ALL, eventFilters, isFabricFiltered }))
+                .eventReports;
+        });
+    }
+    getAllAttributesAndEvents(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { dataVersionFilters, eventFilters, isFabricFiltered } = options;
+            return this.getMultipleAttributesAndEvents({
+                attributes: REQUEST_ALL,
+                events: REQUEST_ALL,
+                eventFilters,
+                dataVersionFilters,
+                isFabricFiltered,
+            });
+        });
+    }
+    getMultipleAttributes(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { attributes, dataVersionFilters, isFabricFiltered } = options;
+            return (yield this.getMultipleAttributesAndEvents({ attributes, dataVersionFilters, isFabricFiltered }))
+                .attributeReports;
+        });
+    }
+    getMultipleEvents(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { events, eventFilters, isFabricFiltered } = options;
+            return (yield this.getMultipleAttributesAndEvents({ events, eventFilters, isFabricFiltered })).eventReports;
+        });
+    }
+    getMultipleAttributesAndEvents(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { attributes: attributeRequests, dataVersionFilters, events: eventRequests, eventFilters, isFabricFiltered = true, } = options;
+            if (attributeRequests === undefined && eventRequests === undefined) {
+                throw new ImplementationError("When reading attributes and events, at least one must be specified.");
+            }
             return this.withMessenger((messenger) => __awaiter(this, void 0, void 0, function* () {
                 return yield this.processReadRequest(messenger, {
                     attributeRequests,
+                    dataVersionFilters: dataVersionFilters === null || dataVersionFilters === void 0 ? void 0 : dataVersionFilters.map(({ endpointId, clusterId, dataVersion }) => ({
+                        path: { endpointId, clusterId },
+                        dataVersion,
+                    })),
+                    eventRequests,
+                    eventFilters,
+                    isFabricFiltered,
                     interactionModelRevision: 1,
-                    isFabricFiltered: true,
                 });
             }));
         });
     }
-    get(endpointId, clusterId, attribute, alwaysRequestFromRemote = false) {
+    getAttribute(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.getWithVersion(endpointId, clusterId, attribute, alwaysRequestFromRemote);
+            const { endpointId, clusterId, attribute, alwaysRequestFromRemote = false, isFabricFiltered } = options;
+            const response = yield this.getAttributeWithVersion({
+                endpointId,
+                clusterId,
+                attribute,
+                alwaysRequestFromRemote,
+                isFabricFiltered,
+            });
             return response === null || response === void 0 ? void 0 : response.value;
         });
     }
-    getWithVersion(endpointId, clusterId, attribute, alwaysRequestFromRemote = false) {
+    getAttributeWithVersion(options) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { endpointId, clusterId, attribute, alwaysRequestFromRemote = false, isFabricFiltered } = options;
             const { id: attributeId } = attribute;
             if (!alwaysRequestFromRemote) {
-                const localValue = this.subscribedLocalValues.get(attributePathToId({ endpointId, clusterId, attributeId }));
-                if (localValue !== undefined) {
-                    return localValue;
+                const value = this.subscribedLocalValues.get(attributePathToId({ endpointId, clusterId, attributeId }));
+                const version = this.subscribedClusterDataVersions.get(clusterPathToId({ endpointId, clusterId }));
+                if (value !== undefined && version !== undefined) {
+                    return { value, version };
                 }
             }
-            const response = yield this.getMultipleAttributes([{ endpointId, clusterId, attributeId }]);
-            if (response.length === 0) {
+            const { attributeReports } = yield this.getMultipleAttributesAndEvents({
+                attributes: [{ endpointId, clusterId, attributeId }],
+                isFabricFiltered,
+            });
+            if (attributeReports.length === 0) {
                 return undefined;
             }
-            if (response.length > 1) {
-                throw new Error("Unexpected response with more then one attribute");
+            if (attributeReports.length > 1) {
+                throw new UnexpectedDataError("Unexpected response with more then one attribute");
             }
-            return { value: response[0].value, version: response[0].version };
+            return { value: attributeReports[0].value, version: attributeReports[0].version };
+        });
+    }
+    getEvent(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { endpointId, clusterId, event, minimumEventNumber, isFabricFiltered = true } = options;
+            const { id: eventId } = event;
+            const response = yield this.getMultipleAttributesAndEvents({
+                events: [{ endpointId, clusterId, eventId }],
+                eventFilters: minimumEventNumber !== undefined ? [{ eventMin: minimumEventNumber }] : undefined,
+                isFabricFiltered,
+            });
+            return (_a = response === null || response === void 0 ? void 0 : response.eventReports[0]) === null || _a === void 0 ? void 0 : _a.events;
         });
     }
     processReadRequest(messenger, request) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { attributeRequests, eventRequests } = request;
+            logger.debug(`Sending read request to ${messenger.getExchangeChannelName()} for attributes ${attributeRequests === null || attributeRequests === void 0 ? void 0 : attributeRequests.map(path => resolveAttributeName(path)).join(", ")} and events ${eventRequests === null || eventRequests === void 0 ? void 0 : eventRequests.map(path => resolveEventName(path)).join(", ")}`);
             // Send read request and combine all (potentially chunked) responses
             let response = yield messenger.sendReadRequest(request);
-            const result = [];
+            const attributeReports = new Array();
+            const eventReports = new Array();
             while (true) {
                 if (response.attributeReports !== undefined) {
-                    result.push(...response.attributeReports);
+                    attributeReports.push(...response.attributeReports);
+                }
+                if (response.eventReports !== undefined) {
+                    eventReports.push(...response.eventReports);
                 }
                 if (!response.suppressResponse) {
                     yield messenger.sendStatus(0 /* StatusCode.Success */);
@@ -189,15 +193,25 @@ export class InteractionClient {
                 response = yield messenger.readDataReport();
             }
             // Normalize and decode the response
-            return normalizeAndDecodeReadAttributeReport(result);
+            const normalizedResult = {
+                attributeReports: normalizeAndDecodeReadAttributeReport(attributeReports),
+                eventReports: normalizeAndDecodeReadEventReport(eventReports),
+            };
+            logger.debug(`Received read response with attributes ${normalizedResult.attributeReports
+                .map(({ path, value }) => `${resolveAttributeName(path)} = ${Logger.toJSON(value)}`)
+                .join(", ")} and events ${normalizedResult.eventReports
+                .map(({ path, events }) => `${resolveEventName(path)} = ${Logger.toJSON(events)}`)
+                .join(", ")}`);
+            return normalizedResult;
         });
     }
-    set(endpointId, clusterId, attribute, value, dataVersion) {
+    setAttribute(attributeData) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { endpointId, clusterId, attribute, value, dataVersion } = attributeData;
             const response = yield this.setMultipleAttributes([{ endpointId, clusterId, attribute, value, dataVersion }]);
             // Response contains Status error if there was an error on write
             if (response.length) {
-                const { path: { endpointId, clusterId, attributeId }, status } = response[0];
+                const { path: { endpointId, clusterId, attributeId }, status, } = response[0];
                 if (status !== undefined && status !== 0 /* StatusCode.Success */) {
                     throw new StatusResponseError(`Error setting attribute ${endpointId}/${clusterId}/${attributeId}`, status);
                 }
@@ -207,8 +221,13 @@ export class InteractionClient {
     setMultipleAttributes(attributes) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.withMessenger((messenger) => __awaiter(this, void 0, void 0, function* () {
+                logger.debug(`Sending write request: ${attributes
+                    .map(({ endpointId, clusterId, attribute: { id }, value, dataVersion }) => `${resolveAttributeName({ endpointId, clusterId, attributeId: id })} = ${Logger.toJSON(value)} (version=${dataVersion}`)
+                    .join(", ")}`);
                 const writeRequests = attributes.map(({ endpointId, clusterId, attribute: { id, schema }, value, dataVersion }) => ({
-                    path: { endpointId, clusterId, attributeId: id }, data: schema.encodeTlv(value), dataVersion
+                    path: { endpointId, clusterId, attributeId: id },
+                    data: schema.encodeTlv(value),
+                    dataVersion,
                 }));
                 const response = yield messenger.sendWriteCommand({
                     suppressResponse: false,
@@ -218,42 +237,58 @@ export class InteractionClient {
                     interactionModelRevision: 1,
                 });
                 if (response === undefined) {
-                    throw new Error(`No response received`);
+                    throw new MatterFlowError(`No response received.`);
                 }
-                return response.writeResponses.flatMap(({ status: { status, clusterStatus }, path: { nodeId, endpointId, clusterId, attributeId } }) => {
+                return response.writeResponses
+                    .flatMap(({ status: { status, clusterStatus }, path: { nodeId, endpointId, clusterId, attributeId } }) => {
                     var _a;
-                    return { path: { nodeId, endpointId, clusterId, attributeId }, status: (_a = status !== null && status !== void 0 ? status : clusterStatus) !== null && _a !== void 0 ? _a : 1 /* StatusCode.Failure */ };
-                }).filter(({ status }) => status !== 0 /* StatusCode.Success */);
+                    return {
+                        path: { nodeId, endpointId, clusterId, attributeId },
+                        status: (_a = status !== null && status !== void 0 ? status : clusterStatus) !== null && _a !== void 0 ? _a : 1 /* StatusCode.Failure */,
+                    };
+                })
+                    .filter(({ status }) => status !== 0 /* StatusCode.Success */);
             }));
         });
     }
-    subscribe(endpointId, clusterId, attribute, minIntervalFloorSeconds, maxIntervalCeilingSeconds, listener) {
+    subscribeAttribute(options) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { endpointId, clusterId, attribute, minIntervalFloorSeconds, maxIntervalCeilingSeconds, isFabricFiltered = true, listener, knownDataVersion, keepSubscriptions = true, } = options;
             return this.withMessenger((messenger) => __awaiter(this, void 0, void 0, function* () {
                 const { id: attributeId } = attribute;
-                const { report, subscribeResponse: { subscriptionId } } = yield messenger.sendSubscribeRequest({
+                logger.debug(`Sending subscribe request for attribute: ${resolveAttributeName({
+                    endpointId,
+                    clusterId,
+                    attributeId,
+                })}`);
+                const { report, subscribeResponse: { subscriptionId }, } = yield messenger.sendSubscribeRequest({
+                    interactionModelRevision: 1,
                     attributeRequests: [{ endpointId, clusterId, attributeId }],
-                    keepSubscriptions: true,
+                    dataVersionFilters: knownDataVersion !== undefined
+                        ? [{ path: { endpointId, clusterId }, dataVersion: knownDataVersion }]
+                        : undefined,
+                    keepSubscriptions,
                     minIntervalFloorSeconds,
                     maxIntervalCeilingSeconds,
-                    isFabricFiltered: true,
+                    isFabricFiltered,
                 });
                 const subscriptionListener = (dataReport) => {
                     if (!Array.isArray(dataReport.attributeReports) || !dataReport.attributeReports.length) {
-                        logger.debug('Subscription result empty');
+                        logger.debug("Subscription result empty");
                         return;
                     }
                     const data = normalizeAndDecodeReadAttributeReport(dataReport.attributeReports);
                     if (data.length === 0) {
-                        throw new Error('Subscription result reporting undefined/no value not specified');
+                        throw new MatterFlowError("Subscription result reporting undefined/no value not specified");
                     }
                     if (data.length > 1) {
-                        throw new Error("Unexpected response with more then one attribute");
+                        throw new UnexpectedDataError("Unexpected response with more then one attribute");
                     }
-                    const { path: { endpointId, clusterId, attributeId }, value, version } = data[0];
+                    const { path: { endpointId, clusterId, attributeId }, value, version, } = data[0];
                     if (value === undefined)
-                        throw new Error('Subscription result reporting undefined value not specified');
-                    this.subscribedLocalValues.set(attributePathToId({ endpointId, clusterId, attributeId }), { value, version });
+                        throw new MatterFlowError("Subscription result reporting undefined value not specified.");
+                    this.subscribedLocalValues.set(attributePathToId({ endpointId, clusterId, attributeId }), value);
+                    this.subscribedClusterDataVersions.set(clusterPathToId({ endpointId, clusterId }), version);
                     listener === null || listener === void 0 ? void 0 : listener(value, version);
                 };
                 this.subscriptionListeners.set(subscriptionId, subscriptionListener);
@@ -262,79 +297,178 @@ export class InteractionClient {
             }));
         });
     }
-    subscribeAllAttributes(minIntervalFloorSeconds, maxIntervalCeilingSeconds, listener) {
+    subscribeEvent(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.subscribeMultipleAttributes([{}], minIntervalFloorSeconds, maxIntervalCeilingSeconds, listener);
+            return this.withMessenger((messenger) => __awaiter(this, void 0, void 0, function* () {
+                const { endpointId, clusterId, event, minIntervalFloorSeconds, maxIntervalCeilingSeconds, isUrgent, minimumEventNumber, isFabricFiltered = true, listener, } = options;
+                const { id: eventId } = event;
+                logger.debug(`Sending subscribe request for event: ${resolveEventName({ endpointId, clusterId, eventId })}`);
+                const { report, subscribeResponse: { subscriptionId }, } = yield messenger.sendSubscribeRequest({
+                    interactionModelRevision: 1,
+                    eventRequests: [{ endpointId, clusterId, eventId, isUrgent }],
+                    eventFilters: minimumEventNumber !== undefined ? [{ eventMin: minimumEventNumber }] : undefined,
+                    keepSubscriptions: true,
+                    minIntervalFloorSeconds,
+                    maxIntervalCeilingSeconds,
+                    isFabricFiltered,
+                });
+                const subscriptionListener = (dataReport) => {
+                    if (!Array.isArray(dataReport.eventReports) || !dataReport.eventReports.length) {
+                        logger.debug("Subscription result empty");
+                        return;
+                    }
+                    const data = normalizeAndDecodeReadEventReport(dataReport.eventReports);
+                    if (data.length === 0) {
+                        throw new MatterFlowError("Received empty subscription result value.");
+                    }
+                    if (data.length > 1) {
+                        throw new UnexpectedDataError("Unexpected response with more then one attribute.");
+                    }
+                    const { events } = data[0];
+                    if (events === undefined)
+                        throw new MatterFlowError("Subscription result reporting undefined value not specified.");
+                    events.forEach(event => listener === null || listener === void 0 ? void 0 : listener(event));
+                };
+                this.subscriptionListeners.set(subscriptionId, subscriptionListener);
+                subscriptionListener(report);
+                return;
+            }));
+        });
+    }
+    subscribeAllAttributesAndEvents(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { minIntervalFloorSeconds, maxIntervalCeilingSeconds, attributeListener, eventListener, isUrgent, keepSubscriptions = true, isFabricFiltered = true, eventFilters, dataVersionFilters, } = options;
+            return this.subscribeMultipleAttributesAndEvents({
+                attributes: REQUEST_ALL,
+                events: [{ isUrgent }],
+                minIntervalFloorSeconds,
+                maxIntervalCeilingSeconds,
+                keepSubscriptions,
+                isFabricFiltered,
+                attributeListener,
+                eventListener,
+                eventFilters,
+                dataVersionFilters,
+            });
         });
     }
-    subscribeMultipleAttributes(attributeRequests, minIntervalFloorSeconds, maxIntervalCeilingSeconds, listener) {
+    subscribeMultipleAttributesAndEvents(options) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { attributes: attributeRequests, events: eventRequests, minIntervalFloorSeconds, maxIntervalCeilingSeconds, keepSubscriptions = true, isFabricFiltered = true, attributeListener, eventListener, eventFilters, dataVersionFilters, } = options;
             return this.withMessenger((messenger) => __awaiter(this, void 0, void 0, function* () {
-                const { report, subscribeResponse: { subscriptionId } } = yield messenger.sendSubscribeRequest({
+                logger.debug(`Sending subscribe request: attributes: ${attributeRequests
+                    .map(path => resolveAttributeName(path))
+                    .join(", ")} and events: ${eventRequests.map(path => resolveEventName(path)).join(", ")}`);
+                const { report, subscribeResponse: { subscriptionId, maxInterval }, } = yield messenger.sendSubscribeRequest({
+                    interactionModelRevision: 1,
                     attributeRequests,
-                    keepSubscriptions: true,
+                    eventRequests,
+                    keepSubscriptions,
                     minIntervalFloorSeconds,
                     maxIntervalCeilingSeconds,
-                    isFabricFiltered: true,
-                }); // TODO: also initialize all values
+                    isFabricFiltered,
+                    eventFilters,
+                    dataVersionFilters: dataVersionFilters === null || dataVersionFilters === void 0 ? void 0 : dataVersionFilters.map(({ endpointId, clusterId, dataVersion }) => ({
+                        path: { endpointId, clusterId },
+                        dataVersion,
+                    })),
+                });
+                logger.info(`Subscription successfully initialized with ID ${subscriptionId} and maxInterval ${maxInterval}s.`);
                 const subscriptionListener = (dataReport) => {
-                    if (!Array.isArray(dataReport.attributeReports) || !dataReport.attributeReports.length) {
-                        logger.debug('Subscription result empty');
+                    if ((!Array.isArray(dataReport.attributeReports) || !dataReport.attributeReports.length) &&
+                        (!Array.isArray(dataReport.eventReports) || !dataReport.eventReports.length)) {
+                        logger.debug("Subscription result empty");
                         return;
                     }
-                    const values = normalizeAndDecodeReadAttributeReport(dataReport.attributeReports);
-                    values.forEach(data => {
-                        const { path: { endpointId, clusterId, attributeId }, value, version } = data;
-                        if (value === undefined)
-                            throw new Error('Subscription result reporting undefined value not specified');
-                        this.subscribedLocalValues.set(attributePathToId({ endpointId, clusterId, attributeId }), { value, version });
-                        listener === null || listener === void 0 ? void 0 : listener(data);
+                    const { attributeReports, eventReports } = dataReport;
+                    if (attributeReports !== undefined) {
+                        attributeReports.forEach(data => {
+                            const { path: { endpointId, clusterId, attributeId }, value, version, } = data;
+                            logger.debug(`Received attribute update: ${resolveAttributeName({
+                                endpointId,
+                                clusterId,
+                                attributeId,
+                            })} = ${Logger.toJSON(value)} (version=${version})`);
+                            if (value === undefined)
+                                throw new MatterFlowError("Received empty subscription result value.");
+                            this.subscribedLocalValues.set(attributePathToId({ endpointId, clusterId, attributeId }), value);
+                            this.subscribedClusterDataVersions.set(clusterPathToId({ endpointId, clusterId }), version);
+                            attributeListener === null || attributeListener === void 0 ? void 0 : attributeListener(data);
+                        });
+                    }
+                    if (eventReports !== undefined) {
+                        eventReports.forEach(data => {
+                            logger.debug(`Received event update: ${resolveEventName(data.path)}: ${Logger.toJSON(data.events)}`);
+                            eventListener === null || eventListener === void 0 ? void 0 : eventListener(data);
+                        });
+                    }
+                };
+                this.subscriptionListeners.set(subscriptionId, dataReport => {
+                    subscriptionListener({
+                        attributeReports: dataReport.attributeReports !== undefined
+                            ? normalizeAndDecodeReadAttributeReport(dataReport.attributeReports)
+                            : undefined,
+                        eventReports: dataReport.eventReports !== undefined
+                            ? normalizeAndDecodeReadEventReport(dataReport.eventReports)
+                            : undefined,
                     });
+                });
+                const seedReport = {
+                    attributeReports: report.attributeReports !== undefined
+                        ? normalizeAndDecodeReadAttributeReport(report.attributeReports)
+                        : undefined,
+                    eventReports: report.eventReports !== undefined
+                        ? normalizeAndDecodeReadEventReport(report.eventReports)
+                        : undefined,
                 };
-                this.subscriptionListeners.set(subscriptionId, subscriptionListener);
-                subscriptionListener(report);
-                return;
+                subscriptionListener(seedReport);
+                return seedReport;
             }));
         });
     }
     invoke(endpointId, clusterId, request, id, requestSchema, _responseId, responseSchema, optional) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.withMessenger((messenger) => __awaiter(this, void 0, void 0, function* () {
+                logger.debug(`Invoking command: ${resolveCommandName({ endpointId, clusterId, commandId: id })} with ${Logger.toJSON(request)}`);
                 const commandFields = requestSchema.encodeTlv(request);
                 const invokeResponse = yield messenger.sendInvokeCommand({
-                    invokeRequests: [
-                        { commandPath: { endpointId, clusterId, commandId: id }, commandFields }
-                    ],
+                    invokeRequests: [{ commandPath: { endpointId, clusterId, commandId: id }, commandFields }],
                     timedRequest: false,
                     suppressResponse: false,
                     interactionModelRevision: 1,
                 });
                 if (invokeResponse === undefined)
-                    throw new Error("No response received");
+                    throw new MatterFlowError("No response received.");
                 const { invokeResponses } = invokeResponse;
                 if (invokeResponses.length === 0)
-                    throw new Error("No response received");
+                    throw new MatterFlowError("No response received.");
                 const { command, status } = invokeResponses[0];
                 if (status !== undefined) {
                     const resultCode = status.status.status;
                     if (resultCode !== 0 /* StatusCode.Success */)
-                        throw new Error(`Received non-success result: ${resultCode}`);
+                        throw new MatterError(`Received non-success result: ${resultCode}`);
                     if (responseSchema !== TlvNoResponse)
-                        throw new Error("A response was expected for this command");
+                        throw new MatterFlowError("A response was expected for this command.");
                     return undefined; // ResponseType is void, force casting the empty result
                 }
                 if (command !== undefined) {
                     if (command.commandFields === undefined) {
                         if (responseSchema !== TlvNoResponse)
-                            throw new Error("A response was expected for this command");
+                            throw new MatterFlowError("A response was expected for this command.");
                         return undefined; // ResponseType is void, force casting the empty result
                     }
-                    return responseSchema.decodeTlv(command.commandFields);
+                    const response = responseSchema.decodeTlv(command.commandFields);
+                    logger.debug(`Received invoke response: ${resolveCommandName({
+                        endpointId,
+                        clusterId,
+                        commandId: id,
+                    })} with ${Logger.toJSON(response)})}`);
+                    return response;
                 }
                 if (optional) {
                     return undefined; // ResponseType allows undefined for optional commands
                 }
-                throw new Error("Received invoke response with no result nor response");
+                throw new MatterFlowError("Received invoke response with no result nor response.");
             }));
         });
     }
@@ -345,9 +479,12 @@ export class InteractionClient {
                 return yield invoke(messenger);
             }
             finally {
-                messenger.close();
+                yield messenger.close();
             }
         });
     }
+    get session() {
+        return this.exchangeProvider.session;
+    }
 }
 //# sourceMappingURL=InteractionClient.js.map