@project-chip/matter.js 0.2.1 → 0.3.0

package/dist/cjs/protocol/index.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ChannelManager.js"), exports);
+__exportStar(require("./ExchangeManager.js"), exports);
+__exportStar(require("./MessageExchange.js"), exports);
+__exportStar(require("./ProtocolHandler.js"), exports);

package/dist/cjs/protocol/interaction/AttributeDataDecoder.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Attribute, AttributeJsType } from "../../cluster/Cluster.js";
+import { NodeId } from "../../datatype/NodeId.js";
+import { ArraySchema } from "../../tlv/TlvArray.js";
+import { TlvSchema, TypeFromSchema } from "../../tlv/TlvSchema.js";
+import { TlvAttributeData, TlvAttributeReport } from "./InteractionProtocol.js";
+export interface DecodedAttributeReportValue {
+    path: {
+        nodeId?: NodeId;
+        endpointId: number;
+        clusterId: number;
+        attributeId: number;
+        attributeName: string;
+    };
+    version: number;
+    value: any;
+}
+export interface DecodedAttributeValue {
+    path: {
+        nodeId?: NodeId;
+        endpointId: number;
+        clusterId: number;
+        attributeId: number;
+        attributeName: string;
+    };
+    version?: number;
+    value: any;
+}
+export declare function normalizeAndDecodeReadAttributeReport(data: TypeFromSchema<typeof TlvAttributeReport>[]): DecodedAttributeReportValue[];
+export declare function normalizeAttributeData(data: TypeFromSchema<typeof TlvAttributeData>[], acceptWildcardPaths?: boolean): TypeFromSchema<typeof TlvAttributeData>[][];
+export declare function normalizeAndDecodeAttributeData(data: TypeFromSchema<typeof TlvAttributeData>[]): DecodedAttributeValue[];
+export declare function decodeValueForAttribute<A extends Attribute<any>>(attribute: A, values: TypeFromSchema<typeof TlvAttributeData>[]): AttributeJsType<A> | undefined;
+export declare function decodeValueForSchema<T>(schema: TlvSchema<T>, values: TypeFromSchema<typeof TlvAttributeData>[], defaultValue?: T): T | undefined;
+export declare function decodeChunkedArray<T>(schema: ArraySchema<T>, values: TypeFromSchema<typeof TlvAttributeData>[]): T[];
+//# sourceMappingURL=AttributeDataDecoder.d.ts.map

package/dist/cjs/protocol/interaction/AttributeDataDecoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeDataDecoder.d.ts","sourceRoot":"","sources":["../../../../src/protocol/interaction/AttributeDataDecoder.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAEtE,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAEnE,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAIhF,MAAM,WAAW,2BAA2B;IACxC,IAAI,EAAE;QACF,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAA;KACxB,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,GAAG,CAAC;CACd;AAED,MAAM,WAAW,qBAAqB;IAClC,IAAI,EAAE;QACF,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAA;KACxB,CAAC;IACF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,GAAG,CAAC;CACd;AAED,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAAC,EAAE,GAAG,2BAA2B,EAAE,CAKtI;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,EAAE,mBAAmB,UAAQ,GAAG,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,EAAE,CA+BhK;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,GAAG,qBAAqB,EAAE,CA6BxH;AAED,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,SAAS,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,SAAS,CAWjK;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAgBhJ;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,GAAG,CAAC,EAAE,CAoBpH"}

package/dist/cjs/protocol/interaction/AttributeDataDecoder.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeChunkedArray = exports.decodeValueForSchema = exports.decodeValueForAttribute = exports.normalizeAndDecodeAttributeData = exports.normalizeAttributeData = exports.normalizeAndDecodeReadAttributeReport = void 0;
+const ClusterHelper_js_1 = require("../../cluster/ClusterHelper.js");
+const TlvArray_js_1 = require("../../tlv/TlvArray.js");
+const Logger_js_1 = require("../../log/Logger.js");
+const logger = Logger_js_1.Logger.get("DataReportDecoder");
+function normalizeAndDecodeReadAttributeReport(data) {
+    // TODO Decide how to handle the attribute report status field, right now we ignore it
+    const dataValues = data.flatMap(({ attributeData }) => attributeData !== undefined ? attributeData : []);
+    return normalizeAndDecodeAttributeData(dataValues); // dataVersion existing in incoming data, so must also in outgoing data
+}
+exports.normalizeAndDecodeReadAttributeReport = normalizeAndDecodeReadAttributeReport;
+function normalizeAttributeData(data, acceptWildcardPaths = false) {
+    // Fill in missing path elements when tag compression is used
+    let lastPath;
+    data.forEach((value) => {
+        if (value === undefined)
+            return;
+        const { path } = value;
+        if (path.enableTagCompression) {
+            if (lastPath === undefined)
+                throw new Error('Tag compression enabled, but no previous path');
+            if (path.nodeId === undefined && lastPath.nodeId !== undefined)
+                path.nodeId = lastPath.nodeId;
+            if (path.endpointId === undefined)
+                path.endpointId = lastPath.endpointId;
+            if (path.clusterId === undefined)
+                path.clusterId = lastPath.clusterId;
+            if (path.attributeId === undefined)
+                path.attributeId = lastPath.attributeId;
+        }
+        else if (path.endpointId !== undefined && path.clusterId !== undefined && path.attributeId !== undefined) {
+            lastPath = { nodeId: path.nodeId, endpointId: path.endpointId, clusterId: path.clusterId, attributeId: path.attributeId };
+        }
+        else if (!acceptWildcardPaths) {
+            throw new Error('Tag compression disabled, but path is incomplete: ' + Logger_js_1.Logger.toJSON(path));
+        }
+    });
+    // Put all returned values into a map to group by path
+    const responseList = new Map(); // TODO CHECK
+    data.forEach((value) => {
+        if (!value)
+            return;
+        const { path: { nodeId, endpointId, clusterId, attributeId } } = value;
+        const mapId = `${nodeId}-${endpointId}-${clusterId}-${attributeId}`;
+        const list = responseList.get(mapId) || [];
+        list.push(value);
+        responseList.set(mapId, list);
+    });
+    return Array.from(responseList.values());
+}
+exports.normalizeAttributeData = normalizeAttributeData;
+function normalizeAndDecodeAttributeData(data) {
+    const responseList = normalizeAttributeData(data);
+    const result = [];
+    responseList.forEach(values => {
+        const { path: { nodeId, endpointId, clusterId, attributeId }, dataVersion } = values[0];
+        if (endpointId === undefined || clusterId === undefined || attributeId === undefined) {
+            throw new Error(`Invalid attribute path ${endpointId}/${clusterId}/${attributeId}`);
+        }
+        try {
+            const cluster = (0, ClusterHelper_js_1.getClusterById)(clusterId);
+            if (cluster === undefined) {
+                logger.debug(`Unknown cluster ${clusterId} - ignore`);
+                return;
+            }
+            const attributeDetail = (0, ClusterHelper_js_1.getClusterAttributeById)(cluster, attributeId);
+            if (attributeDetail === undefined) {
+                logger.debug(`Unknown attribute ${clusterId}/${attributeId} - ignore`);
+                return;
+            }
+            const { attribute, name } = attributeDetail;
+            const value = decodeValueForAttribute(attribute, values);
+            result.push({ path: { nodeId, endpointId, clusterId, attributeId, attributeName: name }, version: dataVersion, value });
+        }
+        catch (error) {
+            logger.error(`Error decoding attribute ${endpointId}/${clusterId}/${attributeId}: ${error.message}`);
+        }
+    });
+    return result;
+}
+exports.normalizeAndDecodeAttributeData = normalizeAndDecodeAttributeData;
+function decodeValueForAttribute(attribute, values) {
+    const { schema, optional, default: conformanceValue } = attribute;
+    // No values, so use default value if available
+    if (!values.length) {
+        if (optional)
+            return undefined;
+        if (conformanceValue === undefined)
+            throw new Error(`Attribute not found`);
+        return conformanceValue;
+    }
+    return decodeValueForSchema(schema, values);
+}
+exports.decodeValueForAttribute = decodeValueForAttribute;
+function decodeValueForSchema(schema, values, defaultValue) {
+    // No values, so use default value if available
+    if (!values.length) {
+        return defaultValue;
+    }
+    // The value was returned as one Tlv value, so decode it normally
+    if (values.length === 1 && values[0].path.listIndex === undefined) {
+        return schema.decodeTlv(values[0].data);
+    }
+    // Return contained multiple tlv values as an array
+    if (!(schema instanceof TlvArray_js_1.ArraySchema)) {
+        throw new Error(`Attribute is not an list but multiple values were returned`);
+    }
+    return decodeChunkedArray(schema, values);
+}
+exports.decodeValueForSchema = decodeValueForSchema;
+function decodeChunkedArray(schema, values) {
+    if (!values.length)
+        throw new Error('No values');
+    if (values[0].path.listIndex !== undefined) {
+        throw new Error(`List index ${values[0].path.listIndex} on first array element not supported`);
+    }
+    let result = [];
+    values.forEach(({ data, path: { listIndex } }) => {
+        if (listIndex === undefined) {
+            result = schema.decodeTlv(data);
+        }
+        else if (listIndex === null) {
+            const element = schema.elementSchema.decodeTlv(data);
+            result.push(element);
+        }
+        else if (data[0].typeLength.type === 20 /* TlvType.Null */) {
+            result.splice(listIndex, 1);
+        }
+        else {
+            result[listIndex] = schema.elementSchema.decodeTlv(data);
+        }
+    });
+    schema.validate(result);
+    return result;
+}
+exports.decodeChunkedArray = decodeChunkedArray;

package/dist/cjs/protocol/interaction/InteractionClient.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MessageExchange } from "../../protocol/MessageExchange.js";
+import { ProtocolHandler } from "../../protocol/ProtocolHandler.js";
+import { MatterController } from "../../MatterController.js";
+import { StatusCode } from "./InteractionProtocol.js";
+import { TlvSchema } from "../../tlv/TlvSchema.js";
+import { DataReport } from "./InteractionMessenger.js";
+import { DecodedAttributeReportValue } from "./AttributeDataDecoder.js";
+import { NodeId } from "../../datatype/NodeId.js";
+import { Attribute, AttributeJsType, Attributes, Cluster, Command, Commands, RequestType, ResponseType } from "../../cluster/Cluster.js";
+import { ExchangeProvider } from "../ExchangeManager.js";
+import { ClusterClient } from "../../cluster/client/ClusterClient.js";
+export interface AttributeStatus {
+    path: {
+        nodeId?: NodeId;
+        endpointId?: number;
+        clusterId?: number;
+        attributeId?: number;
+    };
+    status: StatusCode;
+}
+export declare function ClusterClient<CommandT extends Commands, AttributeT extends Attributes>(interactionClient: InteractionClient, endpointId: number, clusterDef: Cluster<any, AttributeT, CommandT, any>): ClusterClient<CommandT, AttributeT>;
+export declare class SubscriptionClient implements ProtocolHandler<MatterController> {
+    private readonly subscriptionListeners;
+    constructor(subscriptionListeners: Map<number, (dataReport: DataReport) => void>);
+    getId(): number;
+    onNewExchange(exchange: MessageExchange<MatterController>): Promise<void>;
+}
+export declare class InteractionClient {
+    private readonly exchangeProvider;
+    private readonly subscriptionListeners;
+    private readonly subscribedLocalValues;
+    constructor(exchangeProvider: ExchangeProvider);
+    getAllAttributes(): Promise<DecodedAttributeReportValue[]>;
+    getMultipleAttributes(attributeRequests: {
+        endpointId?: number;
+        clusterId?: number;
+        attributeId?: number;
+    }[]): Promise<DecodedAttributeReportValue[]>;
+    get<A extends Attribute<any>>(endpointId: number, clusterId: number, attribute: A): Promise<AttributeJsType<A> | undefined>;
+    private processReadRequest;
+    set<T>(endpointId: number, clusterId: number, attribute: Attribute<T>, value: T, dataVersion?: number): Promise<void>;
+    setMultipleAttributes(attributes: {
+        endpointId: number;
+        clusterId: number;
+        attribute: Attribute<any>;
+        value: any;
+        dataVersion?: number;
+    }[]): Promise<AttributeStatus[]>;
+    subscribe<A extends Attribute<any>>(endpointId: number, clusterId: number, attribute: A, minIntervalFloorSeconds: number, maxIntervalCeilingSeconds: number, listener?: (value: AttributeJsType<A>, version: number) => void): Promise<void>;
+    subscribeMultipleAttributes(attributeRequests: {
+        endpointId?: number;
+        clusterId?: number;
+        attributeId?: number;
+    }[], minIntervalFloorSeconds: number, maxIntervalCeilingSeconds: number, listener?: (data: DecodedAttributeReportValue) => void): Promise<void>;
+    invoke<C extends Command<any, any>>(endpointId: number, clusterId: number, request: RequestType<C>, id: number, requestSchema: TlvSchema<RequestType<C>>, _responseId: number, responseSchema: TlvSchema<ResponseType<C>>, optional: boolean): Promise<ResponseType<C>>;
+    private withMessenger;
+}
+//# sourceMappingURL=InteractionClient.d.ts.map

package/dist/cjs/protocol/interaction/InteractionClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractionClient.d.ts","sourceRoot":"","sources":["../../../../src/protocol/interaction/InteractionClient.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionClient = exports.SubscriptionClient = exports.ClusterClient = void 0;
+const String_js_1 = require("../../util/String.js");
+const Logger_js_1 = require("../../log/Logger.js");
+const InteractionMessenger_js_1 = require("./InteractionMessenger.js");
+const InteractionServer_js_1 = require("./InteractionServer.js");
+const AttributeDataDecoder_js_1 = require("./AttributeDataDecoder.js");
+const Cluster_js_1 = require("../../cluster/Cluster.js");
+const logger = Logger_js_1.Logger.get("InteractionClient");
+function ClusterClient(interactionClient, endpointId, clusterDef) {
+    const result = {};
+    const { id: clusterId, commands, attributes } = clusterDef;
+    // Add accessors
+    for (const attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        const capitalizedAttributeName = (0, String_js_1.capitalize)(attributeName);
+        result[`get${capitalizedAttributeName}`] = () => __awaiter(this, void 0, void 0, function* () { return interactionClient.get(endpointId, clusterId, attribute); });
+        result[`set${capitalizedAttributeName}`] = (value) => __awaiter(this, void 0, void 0, function* () { return interactionClient.set(endpointId, clusterId, attribute, value); });
+        result[`subscribe${capitalizedAttributeName}`] = (listener, minIntervalS, maxIntervalS) => __awaiter(this, void 0, void 0, function* () { return interactionClient.subscribe(endpointId, clusterId, attribute, minIntervalS, maxIntervalS, listener); });
+    }
+    // Add command calls
+    for (const commandName in commands) {
+        const { requestId, requestSchema, responseId, responseSchema, optional } = commands[commandName];
+        result[commandName] = (request) => __awaiter(this, void 0, void 0, function* () { return interactionClient.invoke(endpointId, clusterId, request, requestId, requestSchema, responseId, responseSchema, optional); });
+    }
+    return result;
+}
+exports.ClusterClient = ClusterClient;
+class SubscriptionClient {
+    constructor(subscriptionListeners) {
+        this.subscriptionListeners = subscriptionListeners;
+    }
+    getId() {
+        return InteractionServer_js_1.INTERACTION_PROTOCOL_ID;
+    }
+    onNewExchange(exchange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const messenger = new InteractionMessenger_js_1.IncomingInteractionClientMessenger(exchange);
+            const dataReport = yield messenger.readDataReport();
+            const subscriptionId = dataReport.subscriptionId;
+            if (subscriptionId === undefined) {
+                yield messenger.sendStatus(125 /* StatusCode.InvalidSubscription */);
+                throw new Error("Invalid Data report without Subscription ID");
+            }
+            const listener = this.subscriptionListeners.get(subscriptionId);
+            if (listener === undefined) {
+                yield messenger.sendStatus(125 /* StatusCode.InvalidSubscription */);
+                throw new Error(`Unknown subscription ID ${subscriptionId}`);
+            }
+            yield messenger.sendStatus(0 /* StatusCode.Success */);
+            listener(dataReport);
+        });
+    }
+}
+exports.SubscriptionClient = SubscriptionClient;
+class InteractionClient {
+    constructor(exchangeProvider) {
+        this.exchangeProvider = exchangeProvider;
+        this.subscriptionListeners = new Map();
+        this.subscribedLocalValues = new Map();
+        // TODO: Right now we potentially add multiple handlers for the same protocol, We need to fix this
+        this.exchangeProvider.addProtocolHandler(new SubscriptionClient(this.subscriptionListeners));
+    }
+    getAllAttributes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getMultipleAttributes([{ /* empty means *,*,* */}]);
+        });
+    }
+    getMultipleAttributes(attributeRequests) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withMessenger((messenger) => __awaiter(this, void 0, void 0, function* () {
+                return yield this.processReadRequest(messenger, {
+                    attributeRequests,
+                    interactionModelRevision: 1,
+                    isFabricFiltered: true,
+                });
+            }));
+        });
+    }
+    get(endpointId, clusterId, attribute) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { id: attributeId } = attribute;
+            const localValue = this.subscribedLocalValues.get((0, InteractionServer_js_1.attributePathToId)({ endpointId, clusterId, attributeId }));
+            if (localValue !== undefined) {
+                return localValue.value;
+            }
+            const response = yield this.getMultipleAttributes([{ endpointId, clusterId, attributeId }]);
+            if (response.length === 0) {
+                return undefined;
+            }
+            if (response.length > 1) {
+                throw new Error("Unexpected response with more then one attribute");
+            }
+            return response[0].value;
+        });
+    }
+    processReadRequest(messenger, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Send read request and combine all (potentially chunked) responses
+            let response = yield messenger.sendReadRequest(request);
+            const result = [];
+            while (true) {
+                if (response.attributeReports !== undefined) {
+                    result.push(...response.attributeReports);
+                }
+                if (!response.suppressResponse) {
+                    yield messenger.sendStatus(0 /* StatusCode.Success */);
+                }
+                if (!response.moreChunkedMessages)
+                    break;
+                response = yield messenger.readDataReport();
+            }
+            // Normalize and decode the response
+            return (0, AttributeDataDecoder_js_1.normalizeAndDecodeReadAttributeReport)(result);
+        });
+    }
+    set(endpointId, clusterId, attribute, value, dataVersion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.setMultipleAttributes([{ endpointId, clusterId, attribute, value, dataVersion }]);
+            // Response contains Status error if there was an error on write
+            if (response.length) {
+                const { path: { endpointId, clusterId, attributeId }, status } = response[0];
+                if (status !== undefined && status !== 0 /* StatusCode.Success */) {
+                    throw new InteractionMessenger_js_1.StatusResponseError(`Error setting attribute ${endpointId}/${clusterId}/${attributeId}`, status);
+                }
+            }
+        });
+    }
+    setMultipleAttributes(attributes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withMessenger((messenger) => __awaiter(this, void 0, void 0, function* () {
+                const writeRequests = attributes.map(({ endpointId, clusterId, attribute: { id, schema }, value, dataVersion }) => ({
+                    path: { endpointId, clusterId, attributeId: id }, data: schema.encodeTlv(value), dataVersion
+                }));
+                const response = yield messenger.sendWriteCommand({
+                    suppressResponse: false,
+                    timedRequest: false,
+                    writeRequests,
+                    moreChunkedMessages: false,
+                    interactionModelRevision: 1,
+                });
+                if (response === undefined) {
+                    throw new Error(`No response received`);
+                }
+                return response.writeResponses.flatMap(({ status: { status, clusterStatus }, path: { nodeId, endpointId, clusterId, attributeId } }) => {
+                    var _a;
+                    return { path: { nodeId, endpointId, clusterId, attributeId }, status: (_a = status !== null && status !== void 0 ? status : clusterStatus) !== null && _a !== void 0 ? _a : 1 /* StatusCode.Failure */ };
+                }).filter(({ status }) => status !== 0 /* StatusCode.Success */);
+            }));
+        });
+    }
+    subscribe(endpointId, clusterId, attribute, minIntervalFloorSeconds, maxIntervalCeilingSeconds, listener) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withMessenger((messenger) => __awaiter(this, void 0, void 0, function* () {
+                const { id: attributeId } = attribute;
+                const { report, subscribeResponse: { subscriptionId } } = yield messenger.sendSubscribeRequest({
+                    attributeRequests: [{ endpointId, clusterId, attributeId }],
+                    keepSubscriptions: true,
+                    minIntervalFloorSeconds,
+                    maxIntervalCeilingSeconds,
+                    isFabricFiltered: true,
+                }); // TODO: also initialize all values
+                const subscriptionListener = (dataReport) => {
+                    if (!Array.isArray(dataReport.attributeReports) || !dataReport.attributeReports.length) {
+                        logger.debug('Subscription result empty');
+                        return;
+                    }
+                    const data = (0, AttributeDataDecoder_js_1.normalizeAndDecodeReadAttributeReport)(dataReport.attributeReports);
+                    if (data.length === 0) {
+                        throw new Error('Subscription result reporting undefined/no value not specified');
+                    }
+                    if (data.length > 1) {
+                        throw new Error("Unexpected response with more then one attribute");
+                    }
+                    const { path: { endpointId, clusterId, attributeId }, value, version } = data[0];
+                    if (value === undefined)
+                        throw new Error('Subscription result reporting undefined value not specified');
+                    this.subscribedLocalValues.set((0, InteractionServer_js_1.attributePathToId)({ endpointId, clusterId, attributeId }), { value, version });
+                    listener === null || listener === void 0 ? void 0 : listener(value, version);
+                };
+                this.subscriptionListeners.set(subscriptionId, subscriptionListener);
+                subscriptionListener(report);
+                return;
+            }));
+        });
+    }
+    subscribeMultipleAttributes(attributeRequests, minIntervalFloorSeconds, maxIntervalCeilingSeconds, listener) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withMessenger((messenger) => __awaiter(this, void 0, void 0, function* () {
+                const { report, subscribeResponse: { subscriptionId } } = yield messenger.sendSubscribeRequest({
+                    attributeRequests,
+                    keepSubscriptions: true,
+                    minIntervalFloorSeconds,
+                    maxIntervalCeilingSeconds,
+                    isFabricFiltered: true,
+                }); // TODO: also initialize all values
+                const subscriptionListener = (dataReport) => {
+                    if (!Array.isArray(dataReport.attributeReports) || !dataReport.attributeReports.length) {
+                        logger.debug('Subscription result empty');
+                        return;
+                    }
+                    const values = (0, AttributeDataDecoder_js_1.normalizeAndDecodeReadAttributeReport)(dataReport.attributeReports);
+                    values.forEach(data => {
+                        const { path: { endpointId, clusterId, attributeId }, value, version } = data;
+                        if (value === undefined)
+                            throw new Error('Subscription result reporting undefined value not specified');
+                        this.subscribedLocalValues.set((0, InteractionServer_js_1.attributePathToId)({ endpointId, clusterId, attributeId }), { value, version });
+                        listener === null || listener === void 0 ? void 0 : listener(data);
+                    });
+                };
+                this.subscriptionListeners.set(subscriptionId, subscriptionListener);
+                subscriptionListener(report);
+                return;
+            }));
+        });
+    }
+    invoke(endpointId, clusterId, request, id, requestSchema, _responseId, responseSchema, optional) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withMessenger((messenger) => __awaiter(this, void 0, void 0, function* () {
+                const commandFields = requestSchema.encodeTlv(request);
+                const invokeResponse = yield messenger.sendInvokeCommand({
+                    invokeRequests: [
+                        { commandPath: { endpointId, clusterId, commandId: id }, commandFields }
+                    ],
+                    timedRequest: false,
+                    suppressResponse: false,
+                    interactionModelRevision: 1,
+                });
+                if (invokeResponse === undefined)
+                    throw new Error("No response received");
+                const { invokeResponses } = invokeResponse;
+                if (invokeResponses.length === 0)
+                    throw new Error("No response received");
+                const { command, status } = invokeResponses[0];
+                if (status !== undefined) {
+                    const resultCode = status.status.status;
+                    if (resultCode !== 0 /* StatusCode.Success */)
+                        throw new Error(`Received non-success result: ${resultCode}`);
+                    if (responseSchema !== Cluster_js_1.TlvNoResponse)
+                        throw new Error("A response was expected for this command");
+                    return undefined; // ResponseType is void, force casting the empty result
+                }
+                if (command !== undefined) {
+                    if (command.commandFields === undefined) {
+                        if (responseSchema !== Cluster_js_1.TlvNoResponse)
+                            throw new Error("A response was expected for this command");
+                        return undefined; // ResponseType is void, force casting the empty result
+                    }
+                    return responseSchema.decodeTlv(command.commandFields);
+                }
+                if (optional) {
+                    return undefined; // ResponseType allows undefined for optional commands
+                }
+                throw new Error("Received invoke response with no result nor response");
+            }));
+        });
+    }
+    withMessenger(invoke) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const messenger = new InteractionMessenger_js_1.InteractionClientMessenger(this.exchangeProvider);
+            try {
+                return yield invoke(messenger);
+            }
+            finally {
+                messenger.close();
+            }
+        });
+    }
+}
+exports.InteractionClient = InteractionClient;