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

package/dist/cjs/interaction/InteractionClient.js

@@ -0,0 +1,829 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var InteractionClient_exports = {};
+__export(InteractionClient_exports, {
+  InteractionClient: () => InteractionClient,
+  SubscriptionClient: () => SubscriptionClient
+});
+module.exports = __toCommonJS(InteractionClient_exports);
+var import_general = require("#general");
+var import_model = require("#model");
+var import_types = require("#types");
+var import_AttributeDataDecoder = require("./AttributeDataDecoder.js");
+var import_EventDataDecoder = require("./EventDataDecoder.js");
+var import_InteractionMessenger = require("./InteractionMessenger.js");
+var import_InteractionServer = require("./InteractionServer.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = import_general.Logger.get("InteractionClient");
+const REQUEST_ALL = [{}];
+const DEFAULT_TIMED_REQUEST_TIMEOUT_MS = 1e4;
+const DEFAULT_MINIMUM_RESPONSE_TIMEOUT_WITH_FAILSAFE_MS = 3e4;
+class SubscriptionClient {
+  subscriptionListeners = /* @__PURE__ */ new Map();
+  subscriptionUpdateTimers = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  getId() {
+    return import_types.INTERACTION_PROTOCOL_ID;
+  }
+  registerSubscriptionListener(subscriptionId, listener) {
+    this.subscriptionListeners.set(subscriptionId, listener);
+  }
+  removeSubscriptionListener(subscriptionId) {
+    this.subscriptionListeners.delete(subscriptionId);
+  }
+  registerSubscriptionUpdateTimer(subscriptionId, timer) {
+    this.subscriptionUpdateTimers.set(subscriptionId, timer);
+  }
+  removeSubscriptionUpdateTimer(subscriptionId) {
+    this.subscriptionUpdateTimers.get(subscriptionId)?.stop();
+    this.subscriptionUpdateTimers.delete(subscriptionId);
+  }
+  async onNewExchange(exchange) {
+    const messenger = new import_InteractionMessenger.IncomingInteractionClientMessenger(exchange);
+    const dataReport = await messenger.readDataReports(false);
+    const subscriptionId = dataReport.subscriptionId;
+    if (subscriptionId === void 0) {
+      await messenger.sendStatus(import_types.StatusCode.InvalidSubscription);
+      throw new import_general.UnexpectedDataError("Invalid Data report without Subscription ID");
+    }
+    const listener = this.subscriptionListeners.get(subscriptionId);
+    const timer = this.subscriptionUpdateTimers.get(subscriptionId);
+    if (listener === void 0) {
+      await messenger.sendStatus(import_types.StatusCode.InvalidSubscription);
+      logger.info(`Received data for unknown subscription ID ${subscriptionId}. Cancel this subscription.`);
+      if (timer !== void 0) {
+        this.removeSubscriptionUpdateTimer(subscriptionId);
+      }
+      await messenger.close();
+      return;
+    }
+    await messenger.sendStatus(import_types.StatusCode.Success);
+    await messenger.close();
+    if (timer !== void 0) {
+      timer.stop().start();
+    }
+    listener(dataReport);
+  }
+  async close() {
+    this.subscriptionListeners.clear();
+    this.subscriptionUpdateTimers.forEach((timer) => timer.stop());
+    this.subscriptionUpdateTimers.clear();
+  }
+}
+class InteractionClient {
+  constructor(exchangeProvider, address, queue, cachedData) {
+    this.exchangeProvider = exchangeProvider;
+    this.address = address;
+    this.#queue = queue;
+    if (cachedData !== void 0) {
+      this.#cachedData = cachedData;
+    }
+    if (this.exchangeProvider.hasProtocolHandler(import_types.INTERACTION_PROTOCOL_ID)) {
+      const client = this.exchangeProvider.getProtocolHandler(import_types.INTERACTION_PROTOCOL_ID);
+      if (!(client instanceof SubscriptionClient)) {
+        throw new import_general.ImplementationError(
+          `Already existing protocol handler ${import_types.INTERACTION_PROTOCOL_ID} is not a SubscriptionClient.`
+        );
+      }
+      this.subscriptionClient = client;
+    } else {
+      this.subscriptionClient = new SubscriptionClient();
+      this.exchangeProvider.addProtocolHandler(this.subscriptionClient);
+    }
+  }
+  #cachedData = {
+    attributeValues: /* @__PURE__ */ new Map(),
+    clusterDataVersions: /* @__PURE__ */ new Map()
+  };
+  ownSubscriptionIds = /* @__PURE__ */ new Set();
+  subscriptionClient;
+  #queue;
+  registerSubscriptionListener(subscriptionId, listener) {
+    this.ownSubscriptionIds.add(subscriptionId);
+    this.subscriptionClient.registerSubscriptionListener(subscriptionId, listener);
+  }
+  removeSubscription(subscriptionId) {
+    this.ownSubscriptionIds.delete(subscriptionId);
+    this.subscriptionClient.removeSubscriptionListener(subscriptionId);
+    this.subscriptionClient.removeSubscriptionUpdateTimer(subscriptionId);
+  }
+  async getAllAttributes(options = {}) {
+    return (await this.getMultipleAttributesAndEvents({
+      attributes: REQUEST_ALL,
+      ...options
+    })).attributeReports;
+  }
+  async getAllEvents(options = {}) {
+    return (await this.getMultipleAttributesAndEvents({
+      events: REQUEST_ALL,
+      ...options
+    })).eventReports;
+  }
+  async getAllAttributesAndEvents(options = {}) {
+    return this.getMultipleAttributesAndEvents({
+      attributes: REQUEST_ALL,
+      events: REQUEST_ALL,
+      ...options
+    });
+  }
+  async getMultipleAttributes(options = {}) {
+    return (await this.getMultipleAttributesAndEvents(options)).attributeReports;
+  }
+  async getMultipleEvents(options = {}) {
+    return (await this.getMultipleAttributesAndEvents(options)).eventReports;
+  }
+  async getMultipleAttributesAndEvents(options = {}) {
+    const {
+      attributes: attributeRequests,
+      dataVersionFilters,
+      executeQueued,
+      events: eventRequests,
+      enrichCachedAttributeData,
+      eventFilters
+    } = options;
+    if (attributeRequests === void 0 && eventRequests === void 0) {
+      throw new import_general.ImplementationError("When reading attributes and events, at least one must be specified.");
+    }
+    const readPathsCount = (attributeRequests?.length ?? 0) + (eventRequests?.length ?? 0);
+    if (readPathsCount > 9) {
+      logger.debug(
+        "Read interactions with more then 9 paths might be not allowed by the device. Consider splitting then into several read requests."
+      );
+    }
+    logger.debug(
+      `Sending read request: attributes: ${attributeRequests?.map((path) => (0, import_types.resolveAttributeName)(path)).join(", ")} and events: ${eventRequests?.map((path) => (0, import_types.resolveEventName)(path)).join(", ")}`
+    );
+    if (dataVersionFilters !== void 0 && dataVersionFilters?.length > 0) {
+      logger.debug(
+        `Using data version filters: ${dataVersionFilters.map(({ endpointId, clusterId, dataVersion }) => `${endpointId}/${clusterId}=${dataVersion}`).join(", ")}`
+      );
+    }
+    if (eventFilters !== void 0 && eventFilters?.length > 0) {
+      logger.debug(
+        `Using event filters: ${eventFilters.map(({ nodeId, eventMin }) => `${nodeId}=${eventMin}`).join(", ")}`
+      );
+    }
+    return this.withMessenger(async (messenger) => {
+      const { isFabricFiltered = true } = options;
+      const result = await this.processReadRequest(messenger, {
+        attributeRequests,
+        dataVersionFilters: dataVersionFilters?.map(({ endpointId, clusterId, dataVersion }) => ({
+          path: { endpointId, clusterId },
+          dataVersion
+        })),
+        eventRequests,
+        eventFilters,
+        isFabricFiltered,
+        interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION
+      });
+      if (dataVersionFilters !== void 0 && dataVersionFilters.length > 0 && enrichCachedAttributeData) {
+        this.#enrichCachedAttributeData(result.attributeReports, dataVersionFilters);
+      }
+      return result;
+    }, executeQueued);
+  }
+  async getAttribute(options) {
+    const { alwaysRequestFromRemote = false } = options;
+    const response = await this.getAttributeWithVersion({
+      ...options,
+      alwaysRequestFromRemote
+    });
+    return response?.value;
+  }
+  async getAttributeWithVersion(options) {
+    const {
+      endpointId,
+      clusterId,
+      attribute,
+      alwaysRequestFromRemote = false,
+      isFabricFiltered,
+      executeQueued
+    } = options;
+    const { id: attributeId } = attribute;
+    if (!alwaysRequestFromRemote) {
+      const value = this.#cachedData.attributeValues.get(
+        (0, import_InteractionServer.attributePathToId)({ endpointId, clusterId, attributeId })
+      )?.value;
+      const version = this.#cachedData.clusterDataVersions.get(
+        (0, import_InteractionServer.clusterPathToId)({ endpointId, clusterId })
+      )?.dataVersion;
+      if (value !== void 0 && version !== void 0) {
+        return { value, version };
+      }
+    }
+    const { attributeReports } = await this.getMultipleAttributesAndEvents({
+      attributes: [{ endpointId, clusterId, attributeId }],
+      isFabricFiltered,
+      executeQueued
+    });
+    if (attributeReports.length === 0) {
+      return void 0;
+    }
+    if (attributeReports.length > 1) {
+      throw new import_general.UnexpectedDataError("Unexpected response with more then one attribute");
+    }
+    return { value: attributeReports[0].value, version: attributeReports[0].version };
+  }
+  async getEvent(options) {
+    const { endpointId, clusterId, event, minimumEventNumber, isFabricFiltered = true, executeQueued } = options;
+    const { id: eventId } = event;
+    const response = await this.getMultipleAttributesAndEvents({
+      events: [{ endpointId, clusterId, eventId }],
+      eventFilters: minimumEventNumber !== void 0 ? [{ eventMin: minimumEventNumber }] : void 0,
+      isFabricFiltered,
+      executeQueued
+    });
+    return response?.eventReports[0]?.events;
+  }
+  async processReadRequest(messenger, request) {
+    const { attributeRequests, eventRequests } = request;
+    logger.debug(
+      `Sending read request to ${messenger.getExchangeChannelName()} for attributes ${attributeRequests?.map((path) => (0, import_types.resolveAttributeName)(path)).join(", ")} and events ${eventRequests?.map((path) => (0, import_types.resolveEventName)(path)).join(", ")}`
+    );
+    const response = await messenger.sendReadRequest(request);
+    const normalizedResult = {
+      attributeReports: (0, import_AttributeDataDecoder.normalizeAndDecodeReadAttributeReport)(response.attributeReports ?? []),
+      eventReports: (0, import_EventDataDecoder.normalizeAndDecodeReadEventReport)(response.eventReports ?? [])
+    };
+    logger.debug(
+      `Received read response with attributes ${normalizedResult.attributeReports.map(({ path, value }) => `${(0, import_types.resolveAttributeName)(path)} = ${import_general.Logger.toJSON(value)}`).join(", ")} and events ${normalizedResult.eventReports.map(({ path, events }) => `${(0, import_types.resolveEventName)(path)} = ${import_general.Logger.toJSON(events)}`).join(", ")}`
+    );
+    return normalizedResult;
+  }
+  async setAttribute(options) {
+    const { attributeData, asTimedRequest, timedRequestTimeoutMs, suppressResponse, executeQueued } = options;
+    const { endpointId, clusterId, attribute, value, dataVersion } = attributeData;
+    const response = await this.setMultipleAttributes({
+      attributes: [{ endpointId, clusterId, attribute, value, dataVersion }],
+      asTimedRequest,
+      timedRequestTimeoutMs,
+      suppressResponse,
+      executeQueued
+    });
+    if (response.length) {
+      const {
+        path: { endpointId: endpointId2, clusterId: clusterId2, attributeId },
+        status
+      } = response[0];
+      if (status !== void 0 && status !== import_types.StatusCode.Success) {
+        throw new import_types.StatusResponseError(
+          `Error setting attribute ${endpointId2}/${clusterId2}/${attributeId}`,
+          status
+        );
+      }
+    }
+  }
+  async setMultipleAttributes(options) {
+    const { executeQueued } = options;
+    return this.withMessenger(async (messenger) => {
+      const {
+        attributes,
+        asTimedRequest,
+        timedRequestTimeoutMs = DEFAULT_TIMED_REQUEST_TIMEOUT_MS,
+        suppressResponse = false
+        // TODO needs to be TRUE for Group writes
+      } = options;
+      logger.debug(
+        `Sending write request: ${attributes.map(
+          ({ endpointId, clusterId, attribute: { id }, value, dataVersion }) => `${(0, import_types.resolveAttributeName)({ endpointId, clusterId, attributeId: id })} = ${import_general.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, { forWriteInteraction: true }),
+          dataVersion
+        })
+      );
+      const timedRequest = attributes.some(({ attribute: { timed } }) => timed) || asTimedRequest === true || options.timedRequestTimeoutMs !== void 0;
+      if (timedRequest) {
+        await messenger.sendTimedRequest(timedRequestTimeoutMs);
+      }
+      const response = await messenger.sendWriteCommand({
+        suppressResponse,
+        timedRequest,
+        writeRequests,
+        moreChunkedMessages: false,
+        interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION
+      });
+      if (response === void 0) {
+        if (!suppressResponse) {
+          throw new import_general.MatterFlowError(`No response received from write interaction but expected.`);
+        }
+        return [];
+      }
+      return response.writeResponses.flatMap(
+        ({ status: { status, clusterStatus }, path: { nodeId, endpointId, clusterId, attributeId } }) => {
+          return {
+            path: { nodeId, endpointId, clusterId, attributeId },
+            status: status ?? clusterStatus ?? import_types.StatusCode.Failure
+          };
+        }
+      ).filter(({ status }) => status !== import_types.StatusCode.Success);
+    }, executeQueued);
+  }
+  async subscribeAttribute(options) {
+    const { executeQueued } = options;
+    return this.withMessenger(async (messenger) => {
+      const {
+        endpointId,
+        clusterId,
+        attribute,
+        minIntervalFloorSeconds,
+        maxIntervalCeilingSeconds,
+        isFabricFiltered = true,
+        listener,
+        knownDataVersion,
+        keepSubscriptions = true,
+        updateTimeoutHandler
+      } = options;
+      const { id: attributeId } = attribute;
+      logger.debug(
+        `Sending subscribe request for attribute: ${(0, import_types.resolveAttributeName)({
+          endpointId,
+          clusterId,
+          attributeId
+        })}${knownDataVersion !== void 0 ? ` (knownDataVersion=${knownDataVersion})` : ""}`
+      );
+      const {
+        report,
+        subscribeResponse: { subscriptionId, maxInterval }
+      } = await messenger.sendSubscribeRequest({
+        interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION,
+        attributeRequests: [{ endpointId, clusterId, attributeId }],
+        dataVersionFilters: knownDataVersion !== void 0 ? [{ path: { endpointId, clusterId }, dataVersion: knownDataVersion }] : void 0,
+        keepSubscriptions,
+        minIntervalFloorSeconds,
+        maxIntervalCeilingSeconds,
+        isFabricFiltered
+      });
+      const subscriptionListener = (dataReport) => {
+        if (!Array.isArray(dataReport.attributeReports) || !dataReport.attributeReports.length) {
+          logger.debug("Subscription result empty");
+          return;
+        }
+        const data = (0, import_AttributeDataDecoder.normalizeAndDecodeReadAttributeReport)(dataReport.attributeReports);
+        if (data.length === 0) {
+          throw new import_general.MatterFlowError("Subscription result reporting undefined/no value not specified");
+        }
+        if (data.length > 1) {
+          throw new import_general.UnexpectedDataError("Unexpected response with more then one attribute");
+        }
+        const {
+          path: { endpointId: endpointId2, clusterId: clusterId2, attributeId: attributeId2, attributeName },
+          value,
+          version
+        } = data[0];
+        if (value === void 0)
+          throw new import_general.MatterFlowError("Subscription result reporting undefined value not specified.");
+        this.#cachedData.attributeValues.set((0, import_InteractionServer.attributePathToId)({ endpointId: endpointId2, clusterId: clusterId2, attributeId: attributeId2 }), {
+          endpointId: endpointId2,
+          clusterId: clusterId2,
+          attributeId: attributeId2,
+          attributeName,
+          value
+        });
+        this.#cachedData.clusterDataVersions.set((0, import_InteractionServer.clusterPathToId)({ endpointId: endpointId2, clusterId: clusterId2 }), {
+          endpointId: endpointId2,
+          clusterId: clusterId2,
+          dataVersion: version
+        });
+        listener?.(value, version);
+      };
+      this.registerSubscriptionListener(subscriptionId, subscriptionListener);
+      if (updateTimeoutHandler !== void 0) {
+        this.registerSubscriptionUpdateTimer(messenger, subscriptionId, maxInterval, updateTimeoutHandler);
+      }
+      subscriptionListener(report);
+      return;
+    }, executeQueued);
+  }
+  async subscribeEvent(options) {
+    const { executeQueued } = options;
+    return this.withMessenger(async (messenger) => {
+      const {
+        endpointId,
+        clusterId,
+        event,
+        minIntervalFloorSeconds,
+        maxIntervalCeilingSeconds,
+        isUrgent,
+        minimumEventNumber,
+        isFabricFiltered = true,
+        listener,
+        updateTimeoutHandler
+      } = options;
+      const { id: eventId } = event;
+      logger.debug(
+        `Sending subscribe request for event: ${(0, import_types.resolveEventName)({ endpointId, clusterId, eventId })}`
+      );
+      const {
+        report,
+        subscribeResponse: { subscriptionId, maxInterval }
+      } = await messenger.sendSubscribeRequest({
+        interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION,
+        eventRequests: [{ endpointId, clusterId, eventId, isUrgent }],
+        eventFilters: minimumEventNumber !== void 0 ? [{ eventMin: minimumEventNumber }] : void 0,
+        keepSubscriptions: true,
+        minIntervalFloorSeconds,
+        maxIntervalCeilingSeconds,
+        isFabricFiltered
+      });
+      const subscriptionListener = (dataReport) => {
+        if (!Array.isArray(dataReport.eventReports) || !dataReport.eventReports.length) {
+          logger.debug("Subscription result empty");
+          return;
+        }
+        const data = (0, import_EventDataDecoder.normalizeAndDecodeReadEventReport)(dataReport.eventReports);
+        if (data.length === 0) {
+          throw new import_general.MatterFlowError("Received empty subscription result value.");
+        }
+        if (data.length > 1) {
+          throw new import_general.UnexpectedDataError("Unexpected response with more then one attribute.");
+        }
+        const { events } = data[0];
+        if (events === void 0)
+          throw new import_general.MatterFlowError("Subscription result reporting undefined value not specified.");
+        events.forEach((event2) => listener?.(event2));
+      };
+      this.registerSubscriptionListener(subscriptionId, subscriptionListener);
+      if (updateTimeoutHandler !== void 0) {
+        this.registerSubscriptionUpdateTimer(messenger, subscriptionId, maxInterval, updateTimeoutHandler);
+      }
+      subscriptionListener(report);
+      return;
+    }, executeQueued);
+  }
+  async subscribeAllAttributesAndEvents(options) {
+    const { isUrgent } = options;
+    return this.subscribeMultipleAttributesAndEvents({
+      ...options,
+      attributes: REQUEST_ALL,
+      events: [{ isUrgent }]
+    });
+  }
+  async subscribeMultipleAttributesAndEvents(options) {
+    const { attributes: attributeRequests, events: eventRequests, executeQueued } = options;
+    const subscriptionPathsCount = (attributeRequests?.length ?? 0) + (eventRequests?.length ?? 0);
+    if (subscriptionPathsCount > 3) {
+      logger.debug("Subscribe interactions with more then 3 paths might be not allowed by the device.");
+    }
+    return this.withMessenger(async (messenger) => {
+      const {
+        minIntervalFloorSeconds,
+        maxIntervalCeilingSeconds,
+        keepSubscriptions = true,
+        isFabricFiltered = true,
+        attributeListener,
+        eventListener,
+        eventFilters,
+        dataVersionFilters,
+        updateTimeoutHandler,
+        enrichCachedAttributeData
+      } = options;
+      logger.debug(
+        `Sending subscribe request: attributes: ${attributeRequests.map((path) => (0, import_types.resolveAttributeName)(path)).join(", ")} and events: ${eventRequests.map((path) => (0, import_types.resolveEventName)(path)).join(", ")}`
+      );
+      if (dataVersionFilters !== void 0 && dataVersionFilters?.length > 0) {
+        logger.debug(
+          `Using data version filters: ${dataVersionFilters.map(({ endpointId, clusterId, dataVersion }) => `${endpointId}/${clusterId}=${dataVersion}`).join(", ")}`
+        );
+      }
+      if (eventFilters !== void 0 && eventFilters?.length > 0) {
+        logger.debug(
+          `Using event filters: ${eventFilters.map(({ nodeId, eventMin }) => `${nodeId}=${eventMin}`).join(", ")}`
+        );
+      }
+      const {
+        report,
+        subscribeResponse: { subscriptionId, maxInterval }
+      } = await messenger.sendSubscribeRequest({
+        interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION,
+        attributeRequests,
+        eventRequests,
+        keepSubscriptions,
+        minIntervalFloorSeconds,
+        maxIntervalCeilingSeconds,
+        isFabricFiltered,
+        eventFilters,
+        dataVersionFilters: 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) && (!Array.isArray(dataReport.eventReports) || !dataReport.eventReports.length)) {
+          logger.debug("Subscription result empty");
+          return;
+        }
+        const { attributeReports, eventReports } = dataReport;
+        if (attributeReports !== void 0) {
+          attributeReports.forEach((data) => {
+            const {
+              path: { endpointId, clusterId, attributeId, attributeName },
+              value,
+              version
+            } = data;
+            logger.debug(
+              `Received attribute update: ${(0, import_types.resolveAttributeName)({
+                endpointId,
+                clusterId,
+                attributeId
+              })} = ${import_general.Logger.toJSON(value)} (version=${version})`
+            );
+            if (value === void 0) throw new import_general.MatterFlowError("Received empty subscription result value.");
+            const attributeKey = (0, import_InteractionServer.attributePathToId)({ endpointId, clusterId, attributeId });
+            const oldValue = this.#cachedData.attributeValues.get(attributeKey)?.value;
+            this.#cachedData.attributeValues.set(attributeKey, {
+              endpointId,
+              clusterId,
+              attributeId,
+              attributeName,
+              value
+            });
+            this.#cachedData.clusterDataVersions.set((0, import_InteractionServer.clusterPathToId)({ endpointId, clusterId }), {
+              endpointId,
+              clusterId,
+              dataVersion: version
+            });
+            attributeListener?.(
+              data,
+              oldValue !== void 0 ? !(0, import_general.isDeepEqual)(oldValue, value) : void 0,
+              oldValue
+            );
+          });
+        }
+        if (eventReports !== void 0) {
+          eventReports.forEach((data) => {
+            logger.debug(
+              `Received event update: ${(0, import_types.resolveEventName)(data.path)}: ${import_general.Logger.toJSON(data.events)}`
+            );
+            const { events } = data;
+            this.#cachedData.maxEventNumber = events.length === 1 ? events[0].eventNumber : events.reduce(
+              (max, { eventNumber }) => max < eventNumber ? eventNumber : max,
+              this.#cachedData.maxEventNumber ?? events[0].eventNumber
+            );
+            eventListener?.(data);
+          });
+        }
+      };
+      this.registerSubscriptionListener(subscriptionId, (dataReport) => {
+        subscriptionListener({
+          attributeReports: dataReport.attributeReports !== void 0 ? (0, import_AttributeDataDecoder.normalizeAndDecodeReadAttributeReport)(dataReport.attributeReports) : void 0,
+          eventReports: dataReport.eventReports !== void 0 ? (0, import_EventDataDecoder.normalizeAndDecodeReadEventReport)(dataReport.eventReports) : void 0
+        });
+      });
+      if (updateTimeoutHandler !== void 0) {
+        this.registerSubscriptionUpdateTimer(messenger, subscriptionId, maxInterval, updateTimeoutHandler);
+      }
+      const seedReport = {
+        attributeReports: report.attributeReports !== void 0 ? (0, import_AttributeDataDecoder.normalizeAndDecodeReadAttributeReport)(report.attributeReports) : void 0,
+        eventReports: report.eventReports !== void 0 ? (0, import_EventDataDecoder.normalizeAndDecodeReadEventReport)(report.eventReports) : void 0
+      };
+      subscriptionListener(seedReport);
+      if (dataVersionFilters !== void 0 && dataVersionFilters.length > 0 && enrichCachedAttributeData) {
+        this.#enrichCachedAttributeData(seedReport.attributeReports ?? [], dataVersionFilters);
+      }
+      return seedReport;
+    }, executeQueued);
+  }
+  async invoke(options) {
+    const { executeQueued } = options;
+    return this.withMessenger(async (messenger) => {
+      const {
+        endpointId,
+        clusterId,
+        request,
+        command: { requestId, requestSchema, responseId, responseSchema, optional, timed },
+        asTimedRequest,
+        timedRequestTimeoutMs = DEFAULT_TIMED_REQUEST_TIMEOUT_MS,
+        useExtendedFailSafeMessageResponseTimeout = false
+      } = options;
+      const timedRequest = timed || asTimedRequest === true || options.timedRequestTimeoutMs !== void 0;
+      logger.debug(
+        `Invoking command: ${(0, import_types.resolveCommandName)({
+          endpointId,
+          clusterId,
+          commandId: requestId
+        })} with ${import_general.Logger.toJSON(request)}`
+      );
+      requestSchema.validate(request);
+      const commandFields = requestSchema.encodeTlv(request);
+      if (timedRequest) {
+        await messenger.sendTimedRequest(timedRequestTimeoutMs);
+      }
+      const invokeResponse = await messenger.sendInvokeCommand(
+        {
+          invokeRequests: [{ commandPath: { endpointId, clusterId, commandId: requestId }, commandFields }],
+          timedRequest,
+          suppressResponse: false,
+          interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION
+        },
+        useExtendedFailSafeMessageResponseTimeout ? DEFAULT_MINIMUM_RESPONSE_TIMEOUT_WITH_FAILSAFE_MS : void 0
+      );
+      if (invokeResponse === void 0) {
+        throw new import_general.MatterFlowError("No response received from invoke interaction but expected.");
+      }
+      const { invokeResponses } = invokeResponse;
+      if (invokeResponses.length === 0) {
+        throw new import_general.MatterFlowError("Received invoke response with no invoke results.");
+      }
+      const { command, status } = invokeResponses[0];
+      if (status !== void 0) {
+        const resultCode = status.status.status;
+        if (resultCode !== import_types.StatusCode.Success)
+          throw new import_types.StatusResponseError(
+            `Received non-success result: ${resultCode}`,
+            resultCode ?? import_types.StatusCode.Failure,
+            status.status.clusterStatus
+          );
+        if (responseSchema !== import_types.TlvNoResponse)
+          throw new import_general.MatterFlowError("A response was expected for this command.");
+        return void 0;
+      }
+      if (command !== void 0) {
+        const {
+          commandPath: { commandId },
+          commandFields: commandFields2
+        } = command;
+        if (commandId !== responseId) {
+          throw new import_general.MatterFlowError(
+            `Received invoke response with unexpected command ID ${commandId}, expected ${responseId}.`
+          );
+        }
+        if (commandFields2 === void 0) {
+          if (responseSchema !== import_types.TlvNoResponse)
+            throw new import_general.MatterFlowError(`A response was expected for command ${requestId}.`);
+          return void 0;
+        }
+        const response = responseSchema.decodeTlv(commandFields2);
+        logger.debug(
+          `Received invoke response: ${(0, import_types.resolveCommandName)({
+            endpointId,
+            clusterId,
+            commandId: requestId
+          })} with ${import_general.Logger.toJSON(response)})}`
+        );
+        return response;
+      }
+      if (optional) {
+        return void 0;
+      }
+      throw new import_general.MatterFlowError("Received invoke response with no result nor response.");
+    }, executeQueued);
+  }
+  // TODO Add to ClusterClient when needed/when Group communication is implemented
+  async invokeWithSuppressedResponse(options) {
+    const { executeQueued } = options;
+    return this.withMessenger(async (messenger) => {
+      const {
+        endpointId,
+        clusterId,
+        request,
+        command: { requestId, requestSchema, timed },
+        asTimedRequest,
+        timedRequestTimeoutMs = DEFAULT_TIMED_REQUEST_TIMEOUT_MS
+      } = options;
+      const timedRequest = timed || asTimedRequest === true || options.timedRequestTimeoutMs !== void 0;
+      logger.debug(
+        `Invoking command with suppressedResponse: ${(0, import_types.resolveCommandName)({
+          endpointId,
+          clusterId,
+          commandId: requestId
+        })} with ${import_general.Logger.toJSON(request)}`
+      );
+      const commandFields = requestSchema.encodeTlv(request);
+      if (timedRequest) {
+        await messenger.sendTimedRequest(timedRequestTimeoutMs);
+      }
+      const invokeResponse = await messenger.sendInvokeCommand({
+        invokeRequests: [{ commandPath: { endpointId, clusterId, commandId: requestId }, commandFields }],
+        timedRequest,
+        suppressResponse: true,
+        interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION
+      });
+      if (invokeResponse !== void 0) {
+        throw new import_general.MatterFlowError(
+          "Response received from invoke interaction but none expected because response is suppressed."
+        );
+      }
+      logger.debug(
+        `Invoke successful: ${(0, import_types.resolveCommandName)({
+          endpointId,
+          clusterId,
+          commandId: requestId
+        })}`
+      );
+    }, executeQueued);
+  }
+  async withMessenger(invoke, executeQueued = false) {
+    const messenger = new import_InteractionMessenger.InteractionClientMessenger(this.exchangeProvider);
+    try {
+      if (executeQueued) {
+        if (this.#queue === void 0) {
+          throw new import_general.ImplementationError("Cannot execute queued operation without a queue.");
+        }
+        return await this.#queue.add(() => invoke(messenger));
+      }
+      return await invoke(messenger);
+    } finally {
+      await messenger.close();
+    }
+  }
+  registerSubscriptionUpdateTimer(messenger, subscriptionId, maxIntervalS, updateTimeoutHandler) {
+    if (!this.ownSubscriptionIds.has(subscriptionId)) {
+      throw new import_general.MatterFlowError(
+        `Cannot register update timer for subscription ${subscriptionId} because it is not owned by this client.`
+      );
+    }
+    const maxIntervalMs = maxIntervalS * 1e3 + messenger.calculateMaximumPeerResponseTime();
+    const timer = import_general.Time.getTimer("Subscription retry", maxIntervalMs, () => {
+      logger.info(`Subscription ${subscriptionId} timed out after ${maxIntervalMs}ms ...`);
+      this.removeSubscription(subscriptionId);
+      updateTimeoutHandler();
+    }).start();
+    this.subscriptionClient.registerSubscriptionUpdateTimer(subscriptionId, timer);
+  }
+  close() {
+    for (const subscriptionId of this.ownSubscriptionIds) {
+      this.removeSubscription(subscriptionId);
+    }
+    this.#cachedData.attributeValues.clear();
+    this.#cachedData.clusterDataVersions.clear();
+  }
+  get session() {
+    return this.exchangeProvider.session;
+  }
+  get channelType() {
+    return this.exchangeProvider.channelType;
+  }
+  /** Enrich cached data to get complete responses when data version filters were used. */
+  #enrichCachedAttributeData(attributeReports, dataVersionFilters) {
+    const candidates = /* @__PURE__ */ new Map();
+    dataVersionFilters.forEach(({ endpointId, clusterId, dataVersion }) => {
+      if (!candidates.has(endpointId)) {
+        candidates.set(endpointId, /* @__PURE__ */ new Map());
+      }
+      candidates.get(endpointId)?.set(
+        clusterId,
+        this.#cachedData.clusterDataVersions.get((0, import_InteractionServer.clusterPathToId)({ endpointId, clusterId }))?.dataVersion ?? dataVersion
+      );
+    });
+    attributeReports.forEach(({ path: { endpointId, clusterId } }) => {
+      if (candidates.has(endpointId)) {
+        candidates.get(endpointId)?.delete(clusterId);
+      }
+    });
+    this.#cachedData.attributeValues.forEach(({ endpointId, clusterId, attributeId, attributeName, value }) => {
+      const version = candidates.get(endpointId)?.get(clusterId);
+      if (version !== void 0) {
+        logger.debug(`Enriching cached data for ${endpointId}/${clusterId}/${attributeId}=`, value);
+        attributeReports.push({
+          path: { endpointId, clusterId, attributeId, attributeName },
+          value,
+          version
+        });
+      }
+    });
+  }
+  /**
+   * Returns the list (optionally filtered by endpointId and/or clusterId) of the dataVersions of the currently cached
+   * values to use them as knownDataVersion for read or subscription requests.
+   */
+  getCachedClusterDataVersions(filter) {
+    const { endpointId: filterEndpointId, clusterId: filterClusterId } = filter ?? {};
+    return [...this.#cachedData.clusterDataVersions.values()].filter(
+      ({ endpointId, clusterId }) => (filterEndpointId === void 0 || filterEndpointId === endpointId) && (filterClusterId === void 0 || filterClusterId === clusterId)
+    ).map(({ endpointId, clusterId, dataVersion }) => ({ endpointId, clusterId, dataVersion }));
+  }
+  get maxKnownEventNumber() {
+    return this.#cachedData.maxEventNumber;
+  }
+}
+//# sourceMappingURL=InteractionClient.js.map