@matter/node 0.16.0-alpha.0-20251027-17770fb28 → 0.16.0-alpha.0-20251030-e9ca79f93

package/dist/esm/behaviors/thermostat/AtomicWriteHandler.js

@@ -0,0 +1,293 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ClusterBehavior } from "#behavior/index.js";
+import { Thermostat } from "#clusters/thermostat";
+import { BasicSet, Environmental, InternalError, Logger, ObserverGroup, serialize } from "#general";
+import { DataModelPath } from "#model";
+import {
+  AccessControl,
+  assertRemoteActor,
+  FabricManager,
+  hasRemoteActor,
+  PeerAddress,
+  Subject
+} from "#protocol";
+import { AttributeId, NodeId, Status, StatusResponse, StatusResponseError } from "#types";
+import { AtomicWriteState } from "./AtomicWriteState.js";
+const logger = Logger.get("AtomicWriteHandler");
+class AtomicWriteHandler {
+  #observers = new ObserverGroup();
+  #pendingWrites = new BasicSet();
+  constructor(fabricManager) {
+    this.#observers.on(fabricManager.events.deleted, (fabric) => this.#handleFabricRemoval(fabric));
+  }
+  static [Environmental.create](env) {
+    const instance = new AtomicWriteHandler(env.get(FabricManager));
+    env.set(AtomicWriteHandler, instance);
+    return instance;
+  }
+  close() {
+    this.#observers.close();
+    for (const writeState of Array.from(this.#pendingWrites)) {
+      writeState.close();
+    }
+  }
+  /**
+   * Initializes an AtomicWrite state for the given request, context, endpoint and cluster.
+   * It also implements all relevant validation according to the Matter spec.
+   */
+  #initializeState({ requestType, attributeRequests, timeout }, context, endpoint, cluster) {
+    if (!ClusterBehavior.is(cluster) || !cluster.schema) {
+      throw new InternalError("Cluster behavior expected for atomic write handler");
+    }
+    const peerAddress = this.#assertValidPeer(context);
+    if (attributeRequests.length === 0) {
+      throw new StatusResponse.InvalidCommandError("No attribute requests provided");
+    }
+    const attributes = /* @__PURE__ */ new Map();
+    for (const attr of attributeRequests) {
+      const [attributeName, _] = Object.entries(cluster.cluster.attributes).find(
+        ([_2, { id }]) => id === attr
+      ) ?? [];
+      if (attributeName === void 0 || endpoint.stateOf(cluster.id)[attr] === void 0) {
+        throw new StatusResponse.InvalidCommandError(`Attribute ${attr} not supported by cluster`);
+      }
+      if (attributes.has(attr)) {
+        throw new StatusResponse.InvalidCommandError("Duplicate attribute in attribute requests");
+      }
+      attributes.set(attr, attributeName);
+    }
+    const existingState = this.#pendingWrites.find(
+      (s) => PeerAddress.is(s.peerAddress, peerAddress) && s.endpoint.number == endpoint.number && s.clusterId === cluster.cluster.id
+    );
+    if (requestType === Thermostat.RequestType.BeginWrite) {
+      if (timeout === void 0) {
+        throw new StatusResponse.InvalidCommandError("Timeout missing for BeginWrite request");
+      }
+      if (existingState !== void 0 && existingState.attributeRequests.some((attr) => attributeRequests.includes(attr))) {
+        throw new StatusResponse.InvalidCommandError(
+          "An atomic write for at least one of the attributes is already in progress for this peer"
+        );
+      }
+      const initialValues = {};
+      for (const attr of attributeRequests) {
+        initialValues[attr] = endpoint.stateOf(cluster.id)[attr];
+      }
+      const state = new AtomicWriteState(
+        peerAddress,
+        endpoint,
+        cluster.cluster.id,
+        attributeRequests,
+        timeout,
+        attributes,
+        initialValues
+      );
+      this.#pendingWrites.add(state);
+      state.closed.on(() => void this.#pendingWrites.delete(state));
+      logger.debug("Added atomic write state:", state);
+      return state;
+    }
+    if (existingState === void 0) {
+      throw new StatusResponse.InvalidInStateError("No atomic write in progress for this peer");
+    }
+    if (existingState.attributeRequests.length !== attributeRequests.length || !existingState.attributeRequests.every((attr) => attributeRequests.includes(attr))) {
+      throw new StatusResponse.InvalidInStateError("Attribute requests do not match existing atomic write");
+    }
+    return existingState;
+  }
+  /**
+   * Implements the begin write logic for an atomic write.
+   */
+  beginWrite(request, context, endpoint, cluster) {
+    if (!hasRemoteActor(context)) {
+      throw new StatusResponse.InvalidCommandError("AtomicRequest requires a remote actor");
+    }
+    if (!ClusterBehavior.is(cluster) || !cluster.schema) {
+      throw new InternalError("Cluster behavior expected for atomic write handler");
+    }
+    let commandStatusCode = Status.Success;
+    const attributeStatus = request.attributeRequests.map((attr) => {
+      let statusCode = Status.Success;
+      const attributeModel = cluster.schema.conformant.attributes.for(attr);
+      if (!attributeModel?.quality.atomic) {
+        statusCode = Status.InvalidAction;
+      } else if (this.#pendingWriteStateForAttribute(endpoint, cluster, attr) !== void 0) {
+        statusCode = Status.Busy;
+      } else {
+        const { writeLevel } = cluster.supervisor.get(attributeModel).access.limits;
+        const location = {
+          path: DataModelPath.none,
+          endpoint: endpoint.number,
+          cluster: cluster.cluster.id,
+          owningFabric: context.fabric
+        };
+        if (context.authorityAt(writeLevel, location) !== AccessControl.Authority.Granted) {
+          statusCode = Status.UnsupportedAccess;
+        }
+      }
+      if (statusCode !== Status.Success) {
+        commandStatusCode = Status.Failure;
+      }
+      return {
+        attributeId: attr,
+        statusCode
+      };
+    });
+    let timeout;
+    if (commandStatusCode === Status.Success) {
+      const state = this.#initializeState(request, context, endpoint, cluster);
+      timeout = state.timeout;
+    }
+    return {
+      statusCode: commandStatusCode,
+      attributeStatus,
+      timeout
+    };
+  }
+  /**
+   * Handles writing a value for an attribute as part of an ongoing atomic write.
+   * It uses the *$AtomicChanging* event to trigger validation of the partial write.
+   */
+  writeAttribute(context, endpoint, cluster, attribute, value) {
+    const state = this.#assertPendingWriteForAttributeAndPeer(context, endpoint, cluster, attribute);
+    const attributeName = state.attributeNames.get(attribute);
+    logger.debug(`Writing pending value for attribute ${attributeName}, ${attribute} in atomic write`, value);
+    endpoint.eventsOf(cluster.id)[`${attributeName}$AtomicChanging`]?.emit(value, state.pendingAttributeValues[attribute] !== void 0 ? state.pendingAttributeValues[attribute] : state.initialValues[attribute], context);
+    state.pendingAttributeValues[attribute] = value;
+    logger.debug("Atomic write state after current write:", state);
+  }
+  /**
+   * Implements the commit logic for an atomic write.
+   */
+  async commitWrite(request, context, endpoint, cluster, clusterState) {
+    const state = this.#initializeState(request, context, endpoint, cluster);
+    let commandStatusCode = Status.Success;
+    const attributeStatus = [];
+    for (const [attr, value] of Object.entries(state.pendingAttributeValues)) {
+      let statusCode = Status.Success;
+      try {
+        const attributeName = state.attributeNames.get(AttributeId(Number(attr)));
+        endpoint.eventsOf(cluster.id)[`${attributeName}$AtomicChanging`]?.emit(value, endpoint.stateOf(cluster.id)[attr], context);
+        endpoint.eventsOf(cluster.id)[`${attributeName}$AtomicChanged`]?.emit(value, endpoint.stateOf(cluster.id)[attr], context);
+        clusterState[attr] = value;
+        await context.transaction?.commit();
+      } catch (error) {
+        await context.transaction?.rollback();
+        logger.info(`Failed to write attribute ${attr} during atomic write commit: ${error}`);
+        statusCode = error instanceof StatusResponseError ? error.code : Status.Failure;
+        commandStatusCode = commandStatusCode === Status.Failure ? Status.Failure : commandStatusCode === Status.ConstraintError ? Status.ConstraintError : Status.Failure;
+      }
+      attributeStatus.push({
+        attributeId: AttributeId(Number(attr)),
+        statusCode
+      });
+    }
+    state.close();
+    return {
+      statusCode: commandStatusCode,
+      attributeStatus
+    };
+  }
+  /**
+   * Implements the rollback logic for an atomic write.
+   */
+  rollbackWrite(request, context, endpoint, cluster) {
+    const state = this.#initializeState(request, context, endpoint, cluster);
+    state.close();
+    return {
+      statusCode: Status.Success,
+      attributeStatus: state.attributeRequests.map((attr) => ({
+        attributeId: attr,
+        statusCode: Status.Success
+      }))
+    };
+  }
+  /**
+   * Handles fabric removal by closing all pending atomic write states for peers on the removed fabric.
+   */
+  #handleFabricRemoval(fabric) {
+    const fabricIndex = fabric.fabricIndex;
+    for (const writeState of Array.from(this.#pendingWrites)) {
+      if (writeState.peerAddress.fabricIndex === fabricIndex) {
+        logger.debug(
+          `Closing atomic write state for peer ${writeState.peerAddress.toString()} on endpoint ${writeState.endpoint.id} due to fabric removal`
+        );
+        writeState.close();
+      }
+    }
+  }
+  /**
+   * Returns the pending write state for the given attribute, if any.
+   */
+  #pendingWriteStateForAttribute(endpoint, cluster, attribute) {
+    const writeStates = this.#pendingWrites.filter(
+      (s) => s.endpoint.number == endpoint.number && s.clusterId === cluster.cluster.id
+    );
+    if (writeStates.length === 0) {
+      return void 0;
+    }
+    const attrWriteStates = writeStates.filter(({ attributeRequests }) => attributeRequests.includes(attribute));
+    if (attrWriteStates.length === 0) {
+      return void 0;
+    }
+    if (attrWriteStates.length > 1) {
+      throw new InternalError("Multiple atomic write states found for the same attribute. Should never happen");
+    }
+    return attrWriteStates[0];
+  }
+  /**
+   * Returns the pending value for the given attribute and peer, if any.
+   */
+  pendingValueForAttributeAndPeer(context, endpoint, cluster, attribute) {
+    const peerAddress = this.#derivePeerAddress(context);
+    if (peerAddress === void 0) {
+      return void 0;
+    }
+    const attrWriteState = this.#pendingWriteStateForAttribute(endpoint, cluster, attribute);
+    if (attrWriteState === void 0) {
+      return void 0;
+    }
+    if (!PeerAddress.is(attrWriteState.peerAddress, peerAddress)) {
+      return void 0;
+    }
+    logger.debug(
+      `Found pending value for attribute ${attribute} for peer ${peerAddress.nodeId}`,
+      serialize(attrWriteState.pendingAttributeValues[attribute])
+    );
+    return attrWriteState.pendingAttributeValues[attribute];
+  }
+  #assertPendingWriteForAttributeAndPeer(session, endpoint, cluster, attribute) {
+    const attrWriteState = this.#pendingWriteStateForAttribute(endpoint, cluster, attribute);
+    if (attrWriteState === void 0) {
+      throw new StatusResponse.InvalidInStateError("There is no atomic write in progress for this attribute");
+    }
+    const peerAddress = this.#derivePeerAddress(session);
+    if (peerAddress === void 0) {
+      throw new StatusResponse.InvalidInStateError("There is no atomic write in progress for this peer");
+    }
+    if (!PeerAddress.is(attrWriteState.peerAddress, peerAddress)) {
+      throw new StatusResponse.BusyError("Attribute is part of an atomic write in progress for a different peer");
+    }
+    return attrWriteState;
+  }
+  #derivePeerAddress(session) {
+    if (hasRemoteActor(session) && Subject.isNode(session.subject) && NodeId.isOperationalNodeId(session.subject.id)) {
+      return PeerAddress({ fabricIndex: session.fabric, nodeId: NodeId(session.subject.id) });
+    }
+  }
+  #assertValidPeer(context) {
+    assertRemoteActor(context);
+    const peerAddress = this.#derivePeerAddress(context);
+    if (!context.session.associatedFabric || peerAddress === void 0) {
+      throw new StatusResponse.InvalidCommandError("AtomicRequest requires an operational session");
+    }
+    return peerAddress;
+  }
+}
+export {
+  AtomicWriteHandler
+};
+//# sourceMappingURL=AtomicWriteHandler.js.map

package/dist/esm/behaviors/thermostat/AtomicWriteHandler.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/behaviors/thermostat/AtomicWriteHandler.ts"],
+  "mappings": "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",
+  "names": ["_"]
+}

package/dist/esm/behaviors/thermostat/AtomicWriteState.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Thermostat } from "#clusters/thermostat";
+import { Endpoint } from "#endpoint/Endpoint.js";
+import { Diagnostic, Observable } from "#general";
+import { PeerAddress, Val } from "#protocol";
+import { AttributeId, ClusterId } from "#types";
+/**
+ * Represents the state of an ongoing atomic write operation.
+ *
+ * TODO: Move out of thermostat behavior into a more generic behavior handler once used by other clusters too. Then we
+ *  also need to adjust how it is handled.
+ */
+export declare class AtomicWriteState {
+    #private;
+    [Diagnostic.value]: Record<string, unknown>;
+    readonly peerAddress: PeerAddress;
+    readonly endpoint: Endpoint;
+    readonly clusterId: ClusterId;
+    readonly attributeRequests: Thermostat.AtomicRequest["attributeRequests"];
+    readonly attributeNames: Map<AttributeId, string>;
+    readonly pendingAttributeValues: Val.Struct;
+    readonly timeout: number;
+    readonly initialValues: Val.Struct;
+    readonly closed: Observable<[void], void>;
+    constructor(peerAddress: PeerAddress, endpoint: Endpoint, cluster: ClusterId, attributeRequests: Thermostat.AtomicRequest["attributeRequests"], timeout: number, attributeNames: Map<AttributeId, string>, initialValues: Val.Struct);
+    start(): void;
+    close(): void;
+}
+//# sourceMappingURL=AtomicWriteState.d.ts.map

package/dist/esm/behaviors/thermostat/AtomicWriteState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AtomicWriteState.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/thermostat/AtomicWriteState.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAkB,UAAU,EAA+B,MAAM,UAAU,CAAC;AAC/F,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAOhD;;;;;GAKG;AACH,qBAAa,gBAAgB;;IAgCrB,CAAC,UAAU,CAAC,KAAK,CAAC;IA/BtB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,iBAAiB,EAAE,UAAU,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC;IAC1E,QAAQ,CAAC,cAAc,EAAE,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,CAAa;IAC9D,QAAQ,CAAC,sBAAsB,EAAE,GAAG,CAAC,MAAM,CAAM;IACjD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC;IACnC,QAAQ,CAAC,MAAM,2BAAwB;gBAInC,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,SAAS,EAClB,iBAAiB,EAAE,UAAU,CAAC,aAAa,CAAC,mBAAmB,CAAC,EAChE,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,EACxC,aAAa,EAAE,GAAG,CAAC,MAAM;IAyB7B,KAAK;IAcL,KAAK;CASR"}

package/dist/esm/behaviors/thermostat/AtomicWriteState.js

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Diagnostic, Logger, Millis, Observable, Seconds, Time, toHex } from "#general";
+const logger = Logger.get("AtomicWriteState");
+const MAXIMUM_ALLOWED_TIMEOUT = Seconds(9);
+class AtomicWriteState {
+  peerAddress;
+  endpoint;
+  clusterId;
+  attributeRequests;
+  attributeNames = /* @__PURE__ */ new Map();
+  pendingAttributeValues = {};
+  timeout;
+  initialValues;
+  closed = Observable();
+  #timer;
+  constructor(peerAddress, endpoint, cluster, attributeRequests, timeout, attributeNames, initialValues) {
+    this.peerAddress = peerAddress;
+    this.endpoint = endpoint;
+    this.clusterId = cluster;
+    this.attributeRequests = attributeRequests;
+    this.timeout = Math.min(timeout, MAXIMUM_ALLOWED_TIMEOUT);
+    this.attributeNames = attributeNames;
+    this.initialValues = initialValues;
+    this.#timer = Time.getTimer("AtomicWriteState Timeout", Millis(this.timeout), () => this.#timeoutTriggered());
+  }
+  get [Diagnostic.value]() {
+    return Diagnostic.dict({
+      peerAddress: this.peerAddress.toString(),
+      endpointId: this.endpoint.id,
+      clusterId: toHex(this.clusterId),
+      attributeRequests: this.attributeRequests,
+      timeout: this.timeout,
+      initialValues: this.initialValues,
+      pendingAttributeValues: this.pendingAttributeValues
+    });
+  }
+  start() {
+    logger.debug(
+      `Starting atomic write state for peer ${this.peerAddress.toString()} on endpoint ${this.endpoint.id}`
+    );
+    this.#timer.start();
+  }
+  #timeoutTriggered() {
+    logger.debug(
+      `Atomic write state for peer ${this.peerAddress.toString()} on endpoint ${this.endpoint.id} timed out`
+    );
+    this.close();
+  }
+  close() {
+    logger.debug(
+      `Closing atomic write state for peer ${this.peerAddress.toString()} on endpoint ${this.endpoint.id}`
+    );
+    if (this.#timer.isRunning) {
+      this.#timer.stop();
+    }
+    this.closed.emit();
+  }
+}
+export {
+  AtomicWriteState
+};
+//# sourceMappingURL=AtomicWriteState.js.map

package/dist/esm/behaviors/thermostat/AtomicWriteState.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/behaviors/thermostat/AtomicWriteState.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,SAAS,YAAY,QAAQ,QAAQ,YAAY,SAAS,MAAa,aAAa;AAIpF,MAAM,SAAS,OAAO,IAAI,kBAAkB;AAG5C,MAAM,0BAA0B,QAAQ,CAAC;AAQlC,MAAM,iBAAiB;AAAA,EACjB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,iBAA2C,oBAAI,IAAI;AAAA,EACnD,yBAAqC,CAAC;AAAA,EACtC;AAAA,EACA;AAAA,EACA,SAAS,WAAmB;AAAA,EACrC;AAAA,EAEA,YACI,aACA,UACA,SACA,mBACA,SACA,gBACA,eACF;AACE,SAAK,cAAc;AACnB,SAAK,WAAW;AAChB,SAAK,YAAY;AACjB,SAAK,oBAAoB;AACzB,SAAK,UAAU,KAAK,IAAI,SAAS,uBAAuB;AACxD,SAAK,iBAAiB;AACtB,SAAK,gBAAgB;AAErB,SAAK,SAAS,KAAK,SAAS,4BAA4B,OAAO,KAAK,OAAO,GAAG,MAAM,KAAK,kBAAkB,CAAC;AAAA,EAChH;AAAA,EAEA,KAAK,WAAW,KAAK,IAAI;AACrB,WAAO,WAAW,KAAK;AAAA,MACnB,aAAa,KAAK,YAAY,SAAS;AAAA,MACvC,YAAY,KAAK,SAAS;AAAA,MAC1B,WAAW,MAAM,KAAK,SAAS;AAAA,MAC/B,mBAAmB,KAAK;AAAA,MACxB,SAAS,KAAK;AAAA,MACd,eAAe,KAAK;AAAA,MACpB,wBAAwB,KAAK;AAAA,IACjC,CAAC;AAAA,EACL;AAAA,EAEA,QAAQ;AACJ,WAAO;AAAA,MACH,wCAAwC,KAAK,YAAY,SAAS,CAAC,gBAAgB,KAAK,SAAS,EAAE;AAAA,IACvG;AACA,SAAK,OAAO,MAAM;AAAA,EACtB;AAAA,EAEA,oBAAoB;AAChB,WAAO;AAAA,MACH,+BAA+B,KAAK,YAAY,SAAS,CAAC,gBAAgB,KAAK,SAAS,EAAE;AAAA,IAC9F;AACA,SAAK,MAAM;AAAA,EACf;AAAA,EAEA,QAAQ;AACJ,WAAO;AAAA,MACH,uCAAuC,KAAK,YAAY,SAAS,CAAC,gBAAgB,KAAK,SAAS,EAAE;AAAA,IACtG;AACA,QAAI,KAAK,OAAO,WAAW;AACvB,WAAK,OAAO,KAAK;AAAA,IACrB;AACA,SAAK,OAAO,KAAK;AAAA,EACrB;AACJ;",
+  "names": []
+}

package/dist/esm/behaviors/thermostat/ThermostatBehavior.d.ts

@@ -87,6 +87,18 @@ export declare const ThermostatBehaviorConstructor: ClusterBehavior.Type<Cluster
             mode: import("#types").FieldType<Thermostat.SetpointRaiseLowerMode>;
             amount: import("#types").FieldType<number>;
         }>, void, any>;
+        readonly atomicRequest: import("#types").Command<import("#types").TypeFromFields<{
+            requestType: import("#types").FieldType<Thermostat.RequestType>;
+            attributeRequests: import("#types").FieldType<import("#types").AttributeId[]>;
+            timeout: import("#types").OptionalFieldType<number>;
+        }>, import("#types").TypeFromFields<{
+            statusCode: import("#types").FieldType<import("#types").Status>;
+            attributeStatus: import("#types").FieldType<import("#types").TypeFromFields<{
+                attributeId: import("#types").FieldType<import("#types").AttributeId>;
+                statusCode: import("#types").FieldType<import("#types").Status>;
+            }>[]>;
+            timeout: import("#types").OptionalFieldType<number>;
+        }>, any>;
     };
     readonly extensions: readonly [{
         readonly flags: {

package/dist/esm/behaviors/thermostat/ThermostatBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ThermostatBehavior.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/thermostat/ThermostatBehavior.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sEAEJ,CAAC;AAEvC,MAAM,WAAW,6BAA8B,SAAQ,QAAQ,CAAC,OAAO,6BAA6B,CAAC;CAAG;AACxG,eAAO,MAAM,kBAAkB,EAAE,6BAA6D,CAAC;AAC/F,MAAM,WAAW,kBAAmB,SAAQ,YAAY,CAAC,6BAA6B,CAAC;CAAG;AAC1F,yBAAiB,kBAAkB,CAAC;IAAE,UAAiB,KAAM,SAAQ,YAAY,CAAC,OAAO,kBAAkB,CAAC,KAAK,CAAC;KAAG;CAAE"}
+{"version":3,"file":"ThermostatBehavior.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/thermostat/ThermostatBehavior.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sEAEJ,CAAC;AAEvC,MAAM,WAAW,6BAA8B,SAAQ,QAAQ,CAAC,OAAO,6BAA6B,CAAC;CAAG;AACxG,eAAO,MAAM,kBAAkB,EAAE,6BAA6D,CAAC;AAC/F,MAAM,WAAW,kBAAmB,SAAQ,YAAY,CAAC,6BAA6B,CAAC;CAAG;AAC1F,yBAAiB,kBAAkB,CAAC;IAAE,UAAiB,KAAM,SAAQ,YAAY,CAAC,OAAO,kBAAkB,CAAC,KAAK,CAAC;KAAG;CAAE"}

package/dist/esm/behaviors/thermostat/ThermostatInterface.d.ts

@@ -12,6 +12,7 @@ export declare namespace ThermostatInterface {
          * @see {@link MatterSpecification.v141.Cluster} § 4.3.10.1
          */
         setpointRaiseLower(request: Thermostat.SetpointRaiseLowerRequest): MaybePromise;
+        atomicRequest(request: Thermostat.AtomicRequest): MaybePromise<Thermostat.AtomicResponse>;
     }
     interface ScheduleConfiguration {
         /**

package/dist/esm/behaviors/thermostat/ThermostatInterface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ThermostatInterface.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/thermostat/ThermostatInterface.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD,yBAAiB,mBAAmB,CAAC;IACjC,UAAiB,IAAI;QACjB;;WAEG;QACH,kBAAkB,CAAC,OAAO,EAAE,UAAU,CAAC,yBAAyB,GAAG,YAAY,CAAC;KACnF;IAED,UAAiB,qBAAqB;QAClC;;;;;;;;;;WAUG;QACH,iBAAiB,CAAC,OAAO,EAAE,UAAU,CAAC,wBAAwB,GAAG,YAAY,CAAC;QAE9E;;WAEG;QACH,iBAAiB,CAAC,OAAO,EAAE,UAAU,CAAC,wBAAwB,GAAG,YAAY,CAAC,UAAU,CAAC,yBAAyB,CAAC,CAAC;QAEpH;;;;;;;WAOG;QACH,mBAAmB,IAAI,YAAY,CAAC;KACvC;IAED,UAAiB,OAAO;QACpB;;WAEG;QACH,sBAAsB,CAAC,OAAO,EAAE,UAAU,CAAC,sBAAsB,GAAG,YAAY,CAAC;KACpF;IAED,UAAiB,2BAA2B;QACxC;;WAEG;QACH,wBAAwB,CAAC,OAAO,EAAE,UAAU,CAAC,wBAAwB,GAAG,YAAY,CAAC;KACxF;CACJ;AAED,MAAM,MAAM,mBAAmB,GAAG;IAC9B,UAAU,EAAE;QACR;YAAE,KAAK,EAAE,EAAE,CAAC;YAAC,OAAO,EAAE,mBAAmB,CAAC,IAAI,CAAA;SAAE;QAChD;YAAE,KAAK,EAAE;gBAAE,qBAAqB,EAAE,IAAI,CAAA;aAAE,CAAC;YAAC,OAAO,EAAE,mBAAmB,CAAC,qBAAqB,CAAA;SAAE;QAC9F;YAAE,KAAK,EAAE;gBAAE,OAAO,EAAE,IAAI,CAAA;aAAE,CAAC;YAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,CAAA;SAAE;QAClE;YAAE,KAAK,EAAE;gBAAE,2BAA2B,EAAE,IAAI,CAAA;aAAE,CAAC;YAAC,OAAO,EAAE,mBAAmB,CAAC,2BAA2B,CAAA;SAAE;KAC7G,CAAA;CACJ,CAAC"}
+{"version":3,"file":"ThermostatInterface.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/thermostat/ThermostatInterface.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD,yBAAiB,mBAAmB,CAAC;IACjC,UAAiB,IAAI;QACjB;;WAEG;QACH,kBAAkB,CAAC,OAAO,EAAE,UAAU,CAAC,yBAAyB,GAAG,YAAY,CAAC;QAEhF,aAAa,CAAC,OAAO,EAAE,UAAU,CAAC,aAAa,GAAG,YAAY,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;KAC7F;IAED,UAAiB,qBAAqB;QAClC;;;;;;;;;;WAUG;QACH,iBAAiB,CAAC,OAAO,EAAE,UAAU,CAAC,wBAAwB,GAAG,YAAY,CAAC;QAE9E;;WAEG;QACH,iBAAiB,CAAC,OAAO,EAAE,UAAU,CAAC,wBAAwB,GAAG,YAAY,CAAC,UAAU,CAAC,yBAAyB,CAAC,CAAC;QAEpH;;;;;;;WAOG;QACH,mBAAmB,IAAI,YAAY,CAAC;KACvC;IAED,UAAiB,OAAO;QACpB;;WAEG;QACH,sBAAsB,CAAC,OAAO,EAAE,UAAU,CAAC,sBAAsB,GAAG,YAAY,CAAC;KACpF;IAED,UAAiB,2BAA2B;QACxC;;WAEG;QACH,wBAAwB,CAAC,OAAO,EAAE,UAAU,CAAC,wBAAwB,GAAG,YAAY,CAAC;KACxF;CACJ;AAED,MAAM,MAAM,mBAAmB,GAAG;IAC9B,UAAU,EAAE;QACR;YAAE,KAAK,EAAE,EAAE,CAAC;YAAC,OAAO,EAAE,mBAAmB,CAAC,IAAI,CAAA;SAAE;QAChD;YAAE,KAAK,EAAE;gBAAE,qBAAqB,EAAE,IAAI,CAAA;aAAE,CAAC;YAAC,OAAO,EAAE,mBAAmB,CAAC,qBAAqB,CAAA;SAAE;QAC9F;YAAE,KAAK,EAAE;gBAAE,OAAO,EAAE,IAAI,CAAA;aAAE,CAAC;YAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,CAAA;SAAE;QAClE;YAAE,KAAK,EAAE;gBAAE,2BAA2B,EAAE,IAAI,CAAA;aAAE,CAAC;YAAC,OAAO,EAAE,mBAAmB,CAAC,2BAA2B,CAAA;SAAE;KAC7G,CAAA;CACJ,CAAC"}