@matter/protocol 0.16.0-alpha.0-20251213-e83db3732 → 0.16.0-alpha.0-20251217-038f88085

package/dist/esm/interaction/InteractionClient.js

@@ -1,1047 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { ReadScope } from "#action/client/ReadScope.js";
-import { AccessControl } from "#clusters/access-control";
-import { Mark } from "#common/Mark.js";
-import {
-  Diagnostic,
-  Duration,
-  Environmental,
-  ImplementationError,
-  Logger,
-  MatterFlowError,
-  Seconds,
-  UnexpectedDataError,
-  isDeepEqual,
-  serialize
-} from "#general";
-import { Specification } from "#model";
-import { PeerAddress, PeerAddressMap } from "#peer/PeerAddress.js";
-import { PeerSet } from "#peer/PeerSet.js";
-import {
-  ArraySchema,
-  FabricIndex,
-  ObjectSchema,
-  StatusCode,
-  StatusResponseError,
-  TlvNoResponse,
-  resolveAttributeName,
-  resolveCommandName,
-  resolveEventName
-} from "#types";
-import { ReconnectableExchangeProvider } from "../protocol/ExchangeProvider.js";
-import { InteractionClientMessenger } from "./InteractionMessenger.js";
-import { Subscription } from "./Subscription.js";
-import { SubscriptionClient } from "./SubscriptionClient.js";
-const logger = Logger.get("InteractionClient");
-const REQUEST_ALL = [{}];
-const DEFAULT_TIMED_REQUEST_TIMEOUT = Seconds(10);
-const DEFAULT_MINIMUM_RESPONSE_TIMEOUT_WITH_FAILSAFE = Seconds(30);
-const AclClusterId = AccessControl.Complete.id;
-const AclAttributeId = AccessControl.Complete.attributes.acl.id;
-const AclExtensionAttributeId = AccessControl.Complete.attributes.extension.id;
-function isAclOrExtensionPath(path) {
-  const { clusterId, attributeId } = path;
-  return clusterId === AclClusterId && (attributeId === AclAttributeId || attributeId === AclExtensionAttributeId);
-}
-class InteractionClientProvider {
-  #peers;
-  #clients = new PeerAddressMap();
-  #subscriptionClient = new SubscriptionClient();
-  constructor(peers) {
-    this.#peers = peers;
-    this.#peers.deleted.on((peer) => this.#onPeerLoss(peer.address));
-    this.#peers.disconnected.on((peer) => this.#onPeerLoss(peer.address));
-  }
-  static [Environmental.create](env) {
-    const instance = new InteractionClientProvider(env.get(PeerSet));
-    env.set(InteractionClientProvider, instance);
-    return instance;
-  }
-  get peers() {
-    return this.#peers;
-  }
-  get subscriptionClient() {
-    return this.#subscriptionClient;
-  }
-  async connect(address, options) {
-    await this.#peers.connect(address, options);
-    return this.getInteractionClient(address, options);
-  }
-  async interactionClientFor(session) {
-    const exchangeProvider = await this.#peers.exchangeProviderFor(session);
-    return new InteractionClient(
-      exchangeProvider,
-      this.#subscriptionClient,
-      void 0,
-      this.#peers.interactionQueue
-    );
-  }
-  async getInteractionClient(address, options = {}) {
-    let client = this.#clients.get(address);
-    if (client !== void 0) {
-      return client;
-    }
-    const isGroupAddress = PeerAddress.isGroup(address);
-    const nodeStore = isGroupAddress ? void 0 : this.#peers.get(address)?.descriptor.dataStore;
-    await nodeStore?.construction;
-    const exchangeProvider = await this.#peers.exchangeProviderFor(address, options);
-    client = new InteractionClient(
-      exchangeProvider,
-      this.#subscriptionClient,
-      address,
-      this.#peers.interactionQueue,
-      nodeStore
-    );
-    this.#clients.set(address, client);
-    return client;
-  }
-  #onPeerLoss(address) {
-    const client = this.#clients.get(address);
-    if (client !== void 0) {
-      client.close();
-      this.#clients.delete(address);
-    }
-  }
-}
-class InteractionClient {
-  #exchangeProvider;
-  #nodeStore;
-  #ownSubscriptionIds = /* @__PURE__ */ new Set();
-  #queue;
-  #address;
-  isGroupAddress;
-  // TODO - SubscriptionClient is used by CommissioningController but not ClientNode.  However InteractionClient *is*
-  // used by ClientNode to perform commissioning, during which time SubscriptionClient is unnecessary. So this should
-  // be set after commissioning
-  //
-  // If we remove CommissioningController then this entire class goes away; if we first move commissioning to
-  // ClientInteraction then this should become required
-  #subscriptionClient;
-  constructor(exchangeProvider, subscriptionClient, address, queue, nodeStore) {
-    this.#exchangeProvider = exchangeProvider;
-    this.#nodeStore = nodeStore;
-    this.#subscriptionClient = subscriptionClient;
-    this.#queue = queue;
-    this.#address = address;
-    this.isGroupAddress = address !== void 0 ? PeerAddress.isGroup(address) : false;
-  }
-  get address() {
-    if (this.#address === void 0) {
-      throw new ImplementationError("This InteractionClient is not bound to a specific peer.");
-    }
-    return this.#address;
-  }
-  get isReconnectable() {
-    return this.#exchangeProvider instanceof ReconnectableExchangeProvider;
-  }
-  get channelUpdated() {
-    if (this.#exchangeProvider instanceof ReconnectableExchangeProvider) {
-      return this.#exchangeProvider.channelUpdated;
-    }
-    throw new ImplementationError("ExchangeProvider does not support channelUpdated");
-  }
-  /** Calculates the current maximum response time for a message use in additional logic like timers. */
-  maximumPeerResponseTime(expectedProcessingTime) {
-    return this.#exchangeProvider.maximumPeerResponseTime(expectedProcessingTime);
-  }
-  removeSubscription(subscriptionId) {
-    this.#ownSubscriptionIds.delete(subscriptionId);
-    this.#subscriptionClient?.delete(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 getMultipleAttributesAndStatus(options = {}) {
-    const { attributeReports, attributeStatus } = await this.getMultipleAttributesAndEvents(options);
-    return { attributeData: attributeReports, attributeStatus };
-  }
-  async getMultipleEvents(options = {}) {
-    return (await this.getMultipleAttributesAndEvents(options)).eventReports;
-  }
-  async getMultipleEventsAndStatus(options = {}) {
-    const { eventReports, eventStatus } = await this.getMultipleAttributesAndEvents(options);
-    return { eventData: eventReports, eventStatus };
-  }
-  async getMultipleAttributesAndEvents(options = {}) {
-    if (this.isGroupAddress) {
-      throw new ImplementationError("Reading data from group addresses is not supported.");
-    }
-    const {
-      attributes: attributeRequests,
-      dataVersionFilters,
-      executeQueued,
-      events: eventRequests,
-      enrichCachedAttributeData,
-      eventFilters,
-      isFabricFiltered = true,
-      attributeChangeListener
-    } = 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."
-      );
-    }
-    const result = await this.withMessenger(async (messenger) => {
-      return await this.processReadRequest(
-        messenger,
-        {
-          attributeRequests,
-          dataVersionFilters: dataVersionFilters?.map(({ endpointId, clusterId, dataVersion }) => ({
-            path: { endpointId, clusterId },
-            dataVersion
-          })),
-          eventRequests,
-          eventFilters,
-          isFabricFiltered,
-          interactionModelRevision: Specification.INTERACTION_MODEL_REVISION
-        },
-        attributeChangeListener
-      );
-    }, executeQueued);
-    if (dataVersionFilters !== void 0 && dataVersionFilters.length > 0 && enrichCachedAttributeData) {
-      this.#enrichCachedAttributeData(result.attributeReports, dataVersionFilters);
-    }
-    return result;
-  }
-  async getAttribute(options) {
-    const { requestFromRemote } = options;
-    const response = await this.getAttributeWithVersion({
-      ...options,
-      requestFromRemote
-    });
-    return response?.value;
-  }
-  getStoredAttribute(options) {
-    return this.getStoredAttributeWithVersion(options)?.value;
-  }
-  getStoredAttributeWithVersion(options) {
-    if (this.isGroupAddress) {
-      throw new ImplementationError("Reading data from group addresses is not supported.");
-    }
-    const { endpointId, clusterId, attribute } = options;
-    const { id: attributeId } = attribute;
-    if (this.#nodeStore !== void 0) {
-      const { value, version } = this.#nodeStore.retrieveAttribute(endpointId, clusterId, attributeId) ?? {};
-      if (value !== void 0 && version !== void 0) {
-        return { value, version };
-      }
-    }
-    return void 0;
-  }
-  async getAttributeWithVersion(options) {
-    if (this.isGroupAddress) {
-      throw new ImplementationError("Reading data from group addresses is not supported.");
-    }
-    const {
-      endpointId,
-      clusterId,
-      attribute,
-      requestFromRemote,
-      isFabricFiltered,
-      executeQueued,
-      attributeChangeListener
-    } = options;
-    const { id: attributeId } = attribute;
-    if (this.#nodeStore !== void 0) {
-      if (!requestFromRemote) {
-        const { value, version } = this.#nodeStore.retrieveAttribute(endpointId, clusterId, attributeId) ?? {};
-        if (value !== void 0 && version !== void 0) {
-          return { value, version };
-        }
-      }
-      if (requestFromRemote === false) {
-        return void 0;
-      }
-    }
-    const { attributeReports } = await this.getMultipleAttributesAndEvents({
-      attributes: [{ endpointId, clusterId, attributeId }],
-      isFabricFiltered,
-      executeQueued,
-      attributeChangeListener
-    });
-    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, attributeChangeListener) {
-    const { attributeRequests, eventRequests, dataVersionFilters, eventFilters, isFabricFiltered } = request;
-    logger.debug(() => [
-      "Read",
-      Mark.OUTBOUND,
-      messenger.exchange.via,
-      Diagnostic.dict({
-        attributes: attributeRequests?.length ? attributeRequests?.map((path) => resolveAttributeName(path)).join(", ") : void 0,
-        events: eventRequests?.length ? eventRequests?.map((path) => resolveEventName(path)).join(", ") : void 0,
-        dataVersionFilters: dataVersionFilters?.length ? dataVersionFilters.map(
-          ({ path: { endpointId, clusterId }, dataVersion }) => `${endpointId}/${clusterId}=${dataVersion}`
-        ).join(", ") : void 0,
-        eventFilters: eventFilters?.length ? eventFilters.map(({ nodeId, eventMin }) => `${nodeId}=${eventMin}`).join(", ") : void 0,
-        fabricFiltered: isFabricFiltered
-      })
-    ]);
-    await messenger.sendReadRequest(request);
-    const scope = ReadScope(request);
-    const response = await messenger.readAggregateDataReport(
-      (chunk) => this.processAttributeUpdates(scope, chunk, attributeChangeListener)
-    );
-    const { attributeReports, attributeStatus, eventReports, eventStatus } = response;
-    if (attributeReports.length || eventReports.length || attributeStatus?.length || eventStatus?.length) {
-      logger.debug(() => [
-        "Read",
-        Mark.INBOUND,
-        messenger.exchange.via,
-        Diagnostic.dict({
-          attributes: attributeReports.length ? attributeReports.map(({ path, value }) => `${resolveAttributeName(path)}=${serialize(value)}`).join(", ") : void 0,
-          events: eventReports.length ? eventReports.map(({ path }) => resolveEventName(path)).join(", ") : void 0,
-          attributeStatus: attributeStatus?.length ? attributeStatus.map(({ path }) => resolveAttributeName(path)).join(", ") : void 0,
-          eventStatus: eventStatus?.length ? eventStatus.map(({ path }) => resolveEventName(path)).join(", ") : void 0,
-          fabricFiltered: isFabricFiltered
-        })
-      ]);
-    } else {
-      logger.debug("Read", Mark.INBOUND, messenger.exchange.via, "empty response");
-    }
-    return response;
-  }
-  async setAttribute(options) {
-    const { attributeData, asTimedRequest, timedRequestTimeout, suppressResponse, executeQueued, chunkLists } = options;
-    const { endpointId, clusterId, attribute, value, dataVersion } = attributeData;
-    const response = await this.setMultipleAttributes({
-      attributes: [{ endpointId, clusterId, attribute, value, dataVersion }],
-      asTimedRequest,
-      timedRequestTimeout,
-      suppressResponse,
-      executeQueued,
-      chunkLists
-    });
-    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;
-    const {
-      attributes,
-      asTimedRequest,
-      timedRequestTimeout = DEFAULT_TIMED_REQUEST_TIMEOUT,
-      suppressResponse = this.isGroupAddress,
-      chunkLists = true
-      // Should be true currently to stay in sync with chip sdk
-    } = options;
-    if (this.isGroupAddress) {
-      if (!suppressResponse) {
-        throw new ImplementationError("Writing attributes on a group address can not return a response.");
-      }
-      if (attributes.some(
-        ({ endpointId, clusterId, attribute }) => endpointId !== void 0 || clusterId === void 0 || attribute.id === void 0
-      )) {
-        throw new ImplementationError("Not all attribute write paths are valid for group address writes.");
-      }
-    }
-    const writeRequests = attributes.flatMap(
-      ({ endpointId, clusterId, attribute: { id, schema }, value, dataVersion }) => {
-        if (chunkLists && Array.isArray(value) && schema instanceof ArraySchema && // As implemented for Matter 1.4.2 in https://github.com/project-chip/connectedhomeip/pull/38263
-        // Acl writes will no longer be chunked by default, all others still
-        // Will be streamlined later ... see https://github.com/project-chip/connectedhomeip/issues/38270
-        !isAclOrExtensionPath({ clusterId, attributeId: id })) {
-          return schema.encodeAsChunkedArray(value, { forWriteInteraction: true }).map(({ element: data, listIndex }) => ({
-            path: { endpointId, clusterId, attributeId: id, listIndex },
-            data,
-            dataVersion
-          }));
-        }
-        return [
-          {
-            path: { endpointId, clusterId, attributeId: id },
-            data: schema.encodeTlv(value, { forWriteInteraction: true }),
-            dataVersion
-          }
-        ];
-      }
-    );
-    const timedRequest = attributes.some(({ attribute: { timed } }) => timed) || asTimedRequest === true || options.timedRequestTimeout !== void 0;
-    if (this.isGroupAddress && timedRequest) {
-      throw new ImplementationError("Timed requests are not supported for group address writes.");
-    }
-    const response = await this.withMessenger(
-      async (messenger) => {
-        if (timedRequest) {
-          await messenger.sendTimedRequest(timedRequestTimeout);
-        }
-        logger.debug(() => [
-          "Write",
-          Mark.OUTBOUND,
-          messenger.exchange.via,
-          Diagnostic.dict({
-            attributes: attributes.map(
-              ({ endpointId, clusterId, attribute: { id }, value, dataVersion }) => `${resolveAttributeName({ endpointId, clusterId, attributeId: id })} = ${Diagnostic.json(
-                value
-              )} (version=${dataVersion})`
-            ).join(", ")
-          })
-        ]);
-        return await messenger.sendWriteCommand({
-          suppressResponse,
-          timedRequest,
-          writeRequests,
-          moreChunkedMessages: false,
-          interactionModelRevision: Specification.INTERACTION_MODEL_REVISION
-        });
-      },
-      executeQueued
-    );
-    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);
-  }
-  async subscribeAttribute(options) {
-    if (this.isGroupAddress) {
-      throw new ImplementationError("Subscribing to attributes on a group address is not supported.");
-    }
-    const {
-      endpointId,
-      clusterId,
-      attribute,
-      minIntervalFloorSeconds,
-      maxIntervalCeilingSeconds,
-      isFabricFiltered = true,
-      listener,
-      knownDataVersion,
-      keepSubscriptions = true,
-      updateTimeoutHandler,
-      updateReceived,
-      executeQueued
-    } = options;
-    const { id: attributeId } = attribute;
-    if (!keepSubscriptions) {
-      for (const subscriptionId2 of this.#ownSubscriptionIds) {
-        logger.debug(
-          `Removing subscription ${Subscription.idStrOf(subscriptionId2)} from InteractionClient because new subscription replaces it`
-        );
-        this.removeSubscription(subscriptionId2);
-      }
-    }
-    const request = {
-      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 scope = ReadScope(request);
-    const {
-      subscribeResponse: { subscriptionId, maxInterval },
-      report,
-      maximumPeerResponseTime
-    } = await this.withMessenger(async (messenger) => {
-      logger.debug(() => [
-        "Subscribe",
-        Mark.OUTBOUND,
-        messenger.exchange.via,
-        Diagnostic.dict({
-          attributes: resolveAttributeName({ endpointId, clusterId, attributeId }),
-          dataVersionFilter: knownDataVersion,
-          fabricFiltered: isFabricFiltered,
-          minInterval: Duration.format(Seconds(minIntervalFloorSeconds)),
-          maxInterval: Duration.format(Seconds(maxIntervalCeilingSeconds))
-        })
-      ]);
-      await messenger.sendSubscribeRequest(request);
-      const { subscribeResponse, report: report2 } = await messenger.readAggregateSubscribeResponse();
-      return {
-        subscribeResponse,
-        report: report2,
-        maximumPeerResponseTime: this.maximumPeerResponseTime()
-      };
-    }, executeQueued);
-    const subscriptionListener = async (dataReport) => {
-      const { attributeReports } = dataReport;
-      if (attributeReports.length === 0) {
-        throw new MatterFlowError("Subscription result reporting undefined/no value not specified");
-      }
-      if (attributeReports.length > 1) {
-        throw new UnexpectedDataError("Unexpected response with more then one attribute");
-      }
-      const { value, version } = attributeReports[0];
-      if (value === void 0)
-        throw new MatterFlowError("Subscription result reporting undefined value not specified.");
-      await this.#nodeStore?.persistAttributes(attributeReports, scope);
-      listener?.(value, version);
-      updateReceived?.();
-    };
-    await this.#registerSubscription(
-      {
-        id: subscriptionId,
-        maximumPeerResponseTime,
-        maxInterval: Seconds(maxInterval),
-        onData: subscriptionListener,
-        onTimeout: updateTimeoutHandler
-      },
-      report
-    );
-    return { maxInterval };
-  }
-  async #registerSubscription(subscription, initialReport) {
-    this.#ownSubscriptionIds.add(subscription.id);
-    this.#subscriptionClient?.add(subscription);
-    await subscription.onData(initialReport);
-  }
-  async subscribeEvent(options) {
-    if (this.isGroupAddress) {
-      throw new ImplementationError("Subscribing to events on a group address is not supported.");
-    }
-    const {
-      endpointId,
-      clusterId,
-      event,
-      minIntervalFloor,
-      maxIntervalCeiling,
-      isUrgent,
-      minimumEventNumber,
-      isFabricFiltered = true,
-      listener,
-      updateTimeoutHandler,
-      updateReceived,
-      executeQueued
-    } = options;
-    const { id: eventId } = event;
-    const {
-      report,
-      subscribeResponse: { subscriptionId, maxInterval },
-      maximumPeerResponseTime
-    } = await this.withMessenger(async (messenger) => {
-      logger.debug(() => [
-        "Subscribe",
-        Mark.OUTBOUND,
-        messenger.exchange.via,
-        Diagnostic.dict({
-          events: resolveEventName({ endpointId, clusterId, eventId }),
-          fabricFiltered: isFabricFiltered,
-          minInterval: Duration.format(minIntervalFloor),
-          maxInterval: Duration.format(maxIntervalCeiling)
-        })
-      ]);
-      await messenger.sendSubscribeRequest({
-        interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
-        eventRequests: [{ endpointId, clusterId, eventId, isUrgent }],
-        eventFilters: minimumEventNumber !== void 0 ? [{ eventMin: minimumEventNumber }] : void 0,
-        keepSubscriptions: true,
-        minIntervalFloorSeconds: Seconds.of(minIntervalFloor),
-        maxIntervalCeilingSeconds: Seconds.of(maxIntervalCeiling),
-        isFabricFiltered
-      });
-      const { subscribeResponse, report: report2 } = await messenger.readAggregateSubscribeResponse();
-      return {
-        subscribeResponse,
-        report: report2,
-        maximumPeerResponseTime: this.maximumPeerResponseTime()
-      };
-    }, executeQueued);
-    const subscriptionListener = (dataReport) => {
-      const { eventReports } = dataReport;
-      if (eventReports.length === 0) {
-        throw new MatterFlowError("Received empty subscription result value.");
-      }
-      if (eventReports.length > 1) {
-        throw new UnexpectedDataError("Unexpected response with more then one attribute.");
-      }
-      const { events } = eventReports[0];
-      if (events === void 0)
-        throw new MatterFlowError("Subscription result reporting undefined value not specified.");
-      events.forEach((event2) => listener?.(event2));
-      updateReceived?.();
-    };
-    await this.#registerSubscription(
-      {
-        id: subscriptionId,
-        maximumPeerResponseTime,
-        maxInterval: Seconds(maxInterval),
-        onData: subscriptionListener,
-        onTimeout: updateTimeoutHandler
-      },
-      report
-    );
-    return { maxInterval };
-  }
-  async subscribeAllAttributesAndEvents(options) {
-    const { isUrgent } = options;
-    return this.subscribeMultipleAttributesAndEvents({
-      ...options,
-      attributes: REQUEST_ALL,
-      events: [{ isUrgent }]
-    });
-  }
-  async subscribeMultipleAttributesAndEvents(options) {
-    if (this.isGroupAddress) {
-      throw new ImplementationError("Subscribing to attributes or events on a group address is not supported.");
-    }
-    const {
-      attributes: attributeRequests = [],
-      events: eventRequests = [],
-      executeQueued,
-      minIntervalFloorSeconds,
-      maxIntervalCeilingSeconds,
-      keepSubscriptions = true,
-      isFabricFiltered = true,
-      attributeListener,
-      eventListener,
-      eventFilters,
-      dataVersionFilters,
-      updateTimeoutHandler,
-      updateReceived,
-      enrichCachedAttributeData
-    } = 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.");
-    }
-    if (!keepSubscriptions) {
-      for (const subscriptionId2 of this.#ownSubscriptionIds) {
-        logger.debug(
-          `Removing subscription with ID ${Subscription.idStrOf(subscriptionId2)} from InteractionClient because new subscription replaces it`
-        );
-        this.removeSubscription(subscriptionId2);
-      }
-    }
-    const request = {
-      interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
-      attributeRequests,
-      eventRequests,
-      keepSubscriptions,
-      minIntervalFloorSeconds,
-      maxIntervalCeilingSeconds,
-      isFabricFiltered,
-      eventFilters,
-      dataVersionFilters: dataVersionFilters?.map(({ endpointId, clusterId, dataVersion }) => ({
-        path: { endpointId, clusterId },
-        dataVersion
-      }))
-    };
-    const scope = ReadScope(request);
-    let processNewAttributeChangesInListener = false;
-    const {
-      report,
-      subscribeResponse: { subscriptionId, maxInterval },
-      maximumPeerResponseTime
-    } = await this.withMessenger(async (messenger) => {
-      logger.debug(() => [
-        "Subscribe",
-        Mark.OUTBOUND,
-        messenger.exchange.via,
-        Diagnostic.dict({
-          attributes: attributeRequests.length ? attributeRequests.map((path) => resolveAttributeName(path)).join(", ") : void 0,
-          events: eventRequests.length ? eventRequests.map((path) => resolveEventName(path)).join(", ") : void 0,
-          dataVersionFilter: dataVersionFilters?.length ? dataVersionFilters.map(
-            ({ endpointId, clusterId, dataVersion }) => `${endpointId}/${clusterId}=${dataVersion}`
-          ).join(", ") : void 0,
-          eventFilters: eventFilters?.length ? eventFilters.map(({ nodeId, eventMin }) => `${nodeId}=${eventMin}`).join(", ") : void 0,
-          fabricFiltered: isFabricFiltered,
-          keepSubscriptions,
-          minInterval: Duration.format(Seconds(minIntervalFloorSeconds)),
-          maxInterval: Duration.format(Seconds(maxIntervalCeilingSeconds))
-        })
-      ]);
-      await messenger.sendSubscribeRequest(request);
-      const { subscribeResponse, report: report2 } = await messenger.readAggregateSubscribeResponse(
-        (attributeReports) => this.processAttributeUpdates(scope, attributeReports, attributeListener)
-      );
-      logger.info(
-        "Subscription successful",
-        Mark.INBOUND,
-        messenger.exchange.via,
-        Diagnostic.dict({
-          ...Subscription.diagnosticOf(subscribeResponse.subscriptionId),
-          maxInterval: Duration.format(Seconds(subscribeResponse.maxInterval))
-        })
-      );
-      return {
-        subscribeResponse,
-        report: report2,
-        maximumPeerResponseTime: this.maximumPeerResponseTime()
-      };
-    }, executeQueued);
-    const subscriptionListener = async (dataReport) => {
-      if ((!Array.isArray(dataReport.attributeReports) || !dataReport.attributeReports.length) && (!Array.isArray(dataReport.eventReports) || !dataReport.eventReports.length)) {
-        updateReceived?.();
-        return;
-      }
-      const { attributeReports, eventReports } = dataReport;
-      if (eventReports?.length) {
-        let maxEventNumber = this.#nodeStore?.maxEventNumber ?? eventReports[0].events[0].eventNumber;
-        eventReports.forEach((data) => {
-          logger.debug(
-            `Event update ${Mark.INBOUND} ${resolveEventName(data.path)}: ${Diagnostic.json(data.events)}`
-          );
-          const { events } = data;
-          maxEventNumber = events.length === 1 ? events[0].eventNumber : events.reduce(
-            (max, { eventNumber }) => max < eventNumber ? eventNumber : max,
-            maxEventNumber
-          );
-          eventListener?.(data);
-        });
-        await this.#nodeStore?.updateLastEventNumber(maxEventNumber);
-      }
-      if (processNewAttributeChangesInListener && attributeReports !== void 0) {
-        await this.processAttributeUpdates(scope, attributeReports, attributeListener);
-      }
-      updateReceived?.();
-    };
-    await this.#registerSubscription(
-      {
-        id: subscriptionId,
-        maximumPeerResponseTime,
-        maxInterval: Seconds(maxInterval),
-        onData: (dataReport) => subscriptionListener(dataReport),
-        onTimeout: updateTimeoutHandler
-      },
-      report
-    );
-    processNewAttributeChangesInListener = true;
-    if (dataVersionFilters !== void 0 && dataVersionFilters.length > 0 && enrichCachedAttributeData) {
-      this.#enrichCachedAttributeData(report.attributeReports, dataVersionFilters);
-    }
-    return {
-      ...report,
-      maxInterval
-    };
-  }
-  /**
-   * Process changed attributes, detect changes and persist them to the node store
-   */
-  async processAttributeUpdates(scope, attributeReports, attributeListener) {
-    for (const data of attributeReports) {
-      const {
-        path: { endpointId, clusterId, attributeId },
-        value,
-        version
-      } = data;
-      if (value === void 0) {
-        throw new MatterFlowError("Received empty subscription result value.");
-      }
-      const { value: oldValue, version: oldVersion } = this.#nodeStore?.retrieveAttribute(endpointId, clusterId, attributeId) ?? {};
-      const changed = oldValue !== void 0 ? !isDeepEqual(oldValue, value) : void 0;
-      if (changed !== false || version !== oldVersion) {
-        await this.#nodeStore?.persistAttributes([data], scope);
-      }
-      logger.debug(
-        `Attribute update ${Mark.INBOUND}${changed ? " (value changed)" : ""}: ${resolveAttributeName({
-          endpointId,
-          clusterId,
-          attributeId
-        })} = ${serialize(value)} (version=${version})`
-      );
-      attributeListener?.(data, changed, oldValue);
-    }
-  }
-  async invoke(options) {
-    const { executeQueued } = options;
-    const {
-      endpointId,
-      clusterId,
-      command: { requestId, requestSchema, responseId, responseSchema, optional, timed },
-      asTimedRequest,
-      timedRequestTimeout: timedRequestTimeoutMs = DEFAULT_TIMED_REQUEST_TIMEOUT,
-      expectedProcessingTime,
-      useExtendedFailSafeMessageResponseTimeout = false,
-      skipValidation
-    } = options;
-    let { request } = options;
-    const timedRequest = timed && !skipValidation || asTimedRequest === true || options.timedRequestTimeout !== void 0;
-    if (this.isGroupAddress) {
-      if (endpointId !== void 0) {
-        throw new ImplementationError("Invoking a concrete command on a group address is not supported.");
-      }
-      if (timedRequest) {
-        throw new ImplementationError("Timed requests are not supported for group address invokes.");
-      }
-    }
-    if (requestSchema instanceof ObjectSchema) {
-      if (request === void 0) {
-        request = {};
-      }
-      if (requestSchema.isFabricScoped && request.fabricIndex === void 0) {
-        request.fabricIndex = FabricIndex.NO_FABRIC;
-      }
-    }
-    logger.debug(
-      `Invoking command: ${resolveCommandName({
-        endpointId,
-        clusterId,
-        commandId: requestId
-      })} with ${Diagnostic.json(request)}`
-    );
-    if (!skipValidation) {
-      requestSchema.validate(request);
-    }
-    const commandFields = requestSchema.encodeTlv(request);
-    const invokeResponse = await this.withMessenger(async (messenger) => {
-      if (timedRequest) {
-        await messenger.sendTimedRequest(timedRequestTimeoutMs);
-      }
-      const response = await messenger.sendInvokeCommand(
-        {
-          invokeRequests: [{ commandPath: { endpointId, clusterId, commandId: requestId }, commandFields }],
-          timedRequest,
-          suppressResponse: false,
-          interactionModelRevision: Specification.INTERACTION_MODEL_REVISION
-        },
-        expectedProcessingTime ?? (useExtendedFailSafeMessageResponseTimeout ? DEFAULT_MINIMUM_RESPONSE_TIMEOUT_WITH_FAILSAFE : void 0)
-      );
-      if (response === void 0) {
-        throw new MatterFlowError("No response received from invoke interaction but expected.");
-      }
-      return response;
-    }, executeQueued);
-    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(
-        "Invoke",
-        Mark.INBOUND,
-        resolveCommandName({
-          endpointId,
-          clusterId,
-          commandId: requestId
-        }),
-        "with",
-        Diagnostic.json(response)
-      );
-      return response;
-    }
-    if (optional) {
-      return void 0;
-    }
-    throw new MatterFlowError("Received invoke response with no result nor response.");
-  }
-  // TODO Add to ClusterClient when needed/when Group communication is implemented
-  // TODO Additionally support it without endpoint
-  async invokeWithSuppressedResponse(options) {
-    const { executeQueued } = options;
-    const {
-      endpointId,
-      clusterId,
-      request,
-      command: { requestId, requestSchema, timed },
-      asTimedRequest,
-      timedRequestTimeout = DEFAULT_TIMED_REQUEST_TIMEOUT
-    } = options;
-    const timedRequest = timed || asTimedRequest === true || options.timedRequestTimeout !== void 0;
-    if (this.isGroupAddress) {
-      if (timed) {
-        throw new ImplementationError("Timed requests are not supported for group address invokes.");
-      }
-      if (endpointId !== void 0) {
-        throw new ImplementationError("Invoking a concrete command on a group address is not supported.");
-      }
-    }
-    logger.debug(
-      `Invoking command with suppressedResponse: ${resolveCommandName({
-        endpointId,
-        clusterId,
-        commandId: requestId
-      })} with ${Diagnostic.json(request)}`
-    );
-    const commandFields = requestSchema.encodeTlv(request);
-    await this.withMessenger(async (messenger) => {
-      if (timedRequest) {
-        await messenger.sendTimedRequest(timedRequestTimeout);
-      }
-      const response = await messenger.sendInvokeCommand({
-        invokeRequests: [{ commandPath: { endpointId, clusterId, commandId: requestId }, commandFields }],
-        timedRequest,
-        suppressResponse: true,
-        interactionModelRevision: Specification.INTERACTION_MODEL_REVISION
-      });
-      if (response !== void 0) {
-        throw new MatterFlowError(
-          "Response received from invoke interaction but none expected because response is suppressed."
-        );
-      }
-    }, executeQueued);
-    logger.debug(
-      "Invoke successful",
-      Mark.INBOUND,
-      resolveCommandName({
-        endpointId,
-        clusterId,
-        commandId: requestId
-      })
-    );
-  }
-  async withMessenger(invoke, executeQueued = false) {
-    const messenger = await InteractionClientMessenger.create(this.#exchangeProvider);
-    let result;
-    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));
-      }
-      result = await invoke(messenger);
-    } finally {
-      messenger.close().catch((error) => logger.info(`Error closing messenger: ${error}`));
-    }
-    return result;
-  }
-  removeAllSubscriptions() {
-    for (const subscriptionId of this.#ownSubscriptionIds) {
-      this.removeSubscription(subscriptionId);
-    }
-  }
-  close() {
-    this.removeAllSubscriptions();
-  }
-  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) {
-    if (this.#nodeStore === void 0) {
-      return;
-    }
-    const candidates = /* @__PURE__ */ new Map();
-    for (const { endpointId, clusterId, dataVersion } of dataVersionFilters) {
-      if (!candidates.has(endpointId)) {
-        candidates.set(endpointId, /* @__PURE__ */ new Map());
-      }
-      candidates.get(endpointId)?.set(clusterId, this.#nodeStore.getClusterDataVersion(endpointId, clusterId) ?? dataVersion);
-    }
-    attributeReports.forEach(({ path: { endpointId, clusterId } }) => {
-      if (candidates.has(endpointId)) {
-        candidates.get(endpointId)?.delete(clusterId);
-      }
-    });
-    for (const [endpointId, clusters] of candidates) {
-      for (const [clusterId, version] of clusters) {
-        const clusterValues = this.#nodeStore.retrieveAttributes(endpointId, clusterId);
-        logger.debug(
-          `Enriching cached data (${clusterValues.length} attributes) for ${endpointId}/${clusterId} with version=${version}`
-        );
-        attributeReports.push(...clusterValues);
-      }
-    }
-  }
-  /**
-   * 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) {
-    if (this.#nodeStore === void 0) {
-      return [];
-    }
-    const { endpointId, clusterId } = filter ?? {};
-    return this.#nodeStore.getClusterDataVersions(endpointId, clusterId);
-  }
-  get maxKnownEventNumber() {
-    return this.#nodeStore?.maxEventNumber;
-  }
-  cleanupAttributeData(endpointId, clusterIds) {
-    return this.#nodeStore?.cleanupAttributeData(endpointId, clusterIds);
-  }
-  getAllCachedClusterData() {
-    const result = new Array();
-    this.#enrichCachedAttributeData(result, this.getCachedClusterDataVersions());
-    return result;
-  }
-}
-export {
-  InteractionClient,
-  InteractionClientProvider
-};
-//# sourceMappingURL=InteractionClient.js.map