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

package/dist/esm/interaction/InteractionClient.js

@@ -0,0 +1,827 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  ImplementationError,
+  Logger,
+  MatterFlowError,
+  Time,
+  UnexpectedDataError,
+  isDeepEqual
+} from "#general";
+import { Specification } from "#model";
+import {
+  INTERACTION_PROTOCOL_ID,
+  StatusCode,
+  StatusResponseError,
+  TlvNoResponse,
+  resolveAttributeName,
+  resolveCommandName,
+  resolveEventName
+} from "#types";
+import { normalizeAndDecodeReadAttributeReport } from "./AttributeDataDecoder.js";
+import { normalizeAndDecodeReadEventReport } from "./EventDataDecoder.js";
+import {
+  IncomingInteractionClientMessenger,
+  InteractionClientMessenger
+} from "./InteractionMessenger.js";
+import { attributePathToId, clusterPathToId } from "./InteractionServer.js";
+const logger = 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 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 IncomingInteractionClientMessenger(exchange);
+    const dataReport = await messenger.readDataReports(false);
+    const subscriptionId = dataReport.subscriptionId;
+    if (subscriptionId === void 0) {
+      await messenger.sendStatus(StatusCode.InvalidSubscription);
+      throw new 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(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(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(INTERACTION_PROTOCOL_ID)) {
+      const client = this.exchangeProvider.getProtocolHandler(INTERACTION_PROTOCOL_ID);
+      if (!(client instanceof SubscriptionClient)) {
+        throw new ImplementationError(
+          `Already existing protocol handler ${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 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) => resolveAttributeName(path)).join(", ")} and events: ${eventRequests?.map((path) => 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: 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(
+        attributePathToId({ endpointId, clusterId, attributeId })
+      )?.value;
+      const version = this.#cachedData.clusterDataVersions.get(
+        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 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) => resolveAttributeName(path)).join(", ")} and events ${eventRequests?.map((path) => resolveEventName(path)).join(", ")}`
+    );
+    const response = await messenger.sendReadRequest(request);
+    const normalizedResult = {
+      attributeReports: normalizeAndDecodeReadAttributeReport(response.attributeReports ?? []),
+      eventReports: normalizeAndDecodeReadEventReport(response.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;
+  }
+  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 !== StatusCode.Success) {
+        throw new 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 }) => `${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, { 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: Specification.INTERACTION_MODEL_REVISION
+      });
+      if (response === void 0) {
+        if (!suppressResponse) {
+          throw new 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 ?? StatusCode.Failure
+          };
+        }
+      ).filter(({ status }) => status !== 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: ${resolveAttributeName({
+          endpointId,
+          clusterId,
+          attributeId
+        })}${knownDataVersion !== void 0 ? ` (knownDataVersion=${knownDataVersion})` : ""}`
+      );
+      const {
+        report,
+        subscribeResponse: { subscriptionId, maxInterval }
+      } = await messenger.sendSubscribeRequest({
+        interactionModelRevision: 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 = normalizeAndDecodeReadAttributeReport(dataReport.attributeReports);
+        if (data.length === 0) {
+          throw new MatterFlowError("Subscription result reporting undefined/no value not specified");
+        }
+        if (data.length > 1) {
+          throw new 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 MatterFlowError("Subscription result reporting undefined value not specified.");
+        this.#cachedData.attributeValues.set(attributePathToId({ endpointId: endpointId2, clusterId: clusterId2, attributeId: attributeId2 }), {
+          endpointId: endpointId2,
+          clusterId: clusterId2,
+          attributeId: attributeId2,
+          attributeName,
+          value
+        });
+        this.#cachedData.clusterDataVersions.set(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: ${resolveEventName({ endpointId, clusterId, eventId })}`
+      );
+      const {
+        report,
+        subscribeResponse: { subscriptionId, maxInterval }
+      } = await messenger.sendSubscribeRequest({
+        interactionModelRevision: 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 = 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 === void 0)
+          throw new 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) => resolveAttributeName(path)).join(", ")} and events: ${eventRequests.map((path) => 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: 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: ${resolveAttributeName({
+                endpointId,
+                clusterId,
+                attributeId
+              })} = ${Logger.toJSON(value)} (version=${version})`
+            );
+            if (value === void 0) throw new MatterFlowError("Received empty subscription result value.");
+            const attributeKey = 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(clusterPathToId({ endpointId, clusterId }), {
+              endpointId,
+              clusterId,
+              dataVersion: version
+            });
+            attributeListener?.(
+              data,
+              oldValue !== void 0 ? !isDeepEqual(oldValue, value) : void 0,
+              oldValue
+            );
+          });
+        }
+        if (eventReports !== void 0) {
+          eventReports.forEach((data) => {
+            logger.debug(
+              `Received event update: ${resolveEventName(data.path)}: ${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 ? normalizeAndDecodeReadAttributeReport(dataReport.attributeReports) : void 0,
+          eventReports: dataReport.eventReports !== void 0 ? normalizeAndDecodeReadEventReport(dataReport.eventReports) : void 0
+        });
+      });
+      if (updateTimeoutHandler !== void 0) {
+        this.registerSubscriptionUpdateTimer(messenger, subscriptionId, maxInterval, updateTimeoutHandler);
+      }
+      const seedReport = {
+        attributeReports: report.attributeReports !== void 0 ? normalizeAndDecodeReadAttributeReport(report.attributeReports) : void 0,
+        eventReports: report.eventReports !== void 0 ? 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: ${resolveCommandName({
+          endpointId,
+          clusterId,
+          commandId: requestId
+        })} with ${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: Specification.INTERACTION_MODEL_REVISION
+        },
+        useExtendedFailSafeMessageResponseTimeout ? DEFAULT_MINIMUM_RESPONSE_TIMEOUT_WITH_FAILSAFE_MS : void 0
+      );
+      if (invokeResponse === void 0) {
+        throw new MatterFlowError("No response received from invoke interaction but expected.");
+      }
+      const { invokeResponses } = invokeResponse;
+      if (invokeResponses.length === 0) {
+        throw new MatterFlowError("Received invoke response with no invoke results.");
+      }
+      const { command, status } = invokeResponses[0];
+      if (status !== void 0) {
+        const resultCode = status.status.status;
+        if (resultCode !== StatusCode.Success)
+          throw new StatusResponseError(
+            `Received non-success result: ${resultCode}`,
+            resultCode ?? StatusCode.Failure,
+            status.status.clusterStatus
+          );
+        if (responseSchema !== TlvNoResponse)
+          throw new 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 MatterFlowError(
+            `Received invoke response with unexpected command ID ${commandId}, expected ${responseId}.`
+          );
+        }
+        if (commandFields2 === void 0) {
+          if (responseSchema !== TlvNoResponse)
+            throw new MatterFlowError(`A response was expected for command ${requestId}.`);
+          return void 0;
+        }
+        const response = responseSchema.decodeTlv(commandFields2);
+        logger.debug(
+          `Received invoke response: ${resolveCommandName({
+            endpointId,
+            clusterId,
+            commandId: requestId
+          })} with ${Logger.toJSON(response)})}`
+        );
+        return response;
+      }
+      if (optional) {
+        return void 0;
+      }
+      throw new 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: ${resolveCommandName({
+          endpointId,
+          clusterId,
+          commandId: requestId
+        })} with ${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: Specification.INTERACTION_MODEL_REVISION
+      });
+      if (invokeResponse !== void 0) {
+        throw new MatterFlowError(
+          "Response received from invoke interaction but none expected because response is suppressed."
+        );
+      }
+      logger.debug(
+        `Invoke successful: ${resolveCommandName({
+          endpointId,
+          clusterId,
+          commandId: requestId
+        })}`
+      );
+    }, executeQueued);
+  }
+  async withMessenger(invoke, executeQueued = false) {
+    const messenger = new InteractionClientMessenger(this.exchangeProvider);
+    try {
+      if (executeQueued) {
+        if (this.#queue === void 0) {
+          throw new 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 MatterFlowError(
+        `Cannot register update timer for subscription ${subscriptionId} because it is not owned by this client.`
+      );
+    }
+    const maxIntervalMs = maxIntervalS * 1e3 + messenger.calculateMaximumPeerResponseTime();
+    const timer = 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(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;
+  }
+}
+export {
+  InteractionClient,
+  SubscriptionClient
+};
+//# sourceMappingURL=InteractionClient.js.map