@project-chip/matter.js 0.2.0 → 0.3.0

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

@@ -0,0 +1,250 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ByteArray } from "../../util/ByteArray.js";
+import { MatterError } from "../../common/MatterError.js";
+import { MessageExchange } from "../../protocol/MessageExchange.js";
+import { ExchangeProvider } from "../../protocol/ExchangeManager.js";
+import { MatterController } from "../../MatterController.js";
+import { MatterDevice } from "../../MatterDevice.js";
+import { StatusCode, TlvDataReport, TlvInvokeRequest, TlvInvokeResponse, TlvReadRequest, TlvSubscribeRequest, TlvSubscribeResponse, TlvTimedRequest, TlvWriteRequest, TlvWriteResponse } from "./InteractionProtocol.js";
+import { TypeFromSchema } from "../../tlv/TlvSchema.js";
+import { Message } from "../../codec/MessageCodec.js";
+export declare const enum MessageType {
+    StatusResponse = 1,
+    ReadRequest = 2,
+    SubscribeRequest = 3,
+    SubscribeResponse = 4,
+    ReportData = 5,
+    WriteRequest = 6,
+    WriteResponse = 7,
+    InvokeCommandRequest = 8,
+    InvokeCommandResponse = 9,
+    TimedRequest = 10
+}
+export type ReadRequest = TypeFromSchema<typeof TlvReadRequest>;
+export type DataReport = TypeFromSchema<typeof TlvDataReport>;
+export type SubscribeRequest = TypeFromSchema<typeof TlvSubscribeRequest>;
+export type SubscribeResponse = TypeFromSchema<typeof TlvSubscribeResponse>;
+export type InvokeRequest = TypeFromSchema<typeof TlvInvokeRequest>;
+export type InvokeResponse = TypeFromSchema<typeof TlvInvokeResponse>;
+export type TimedRequest = TypeFromSchema<typeof TlvTimedRequest>;
+export type WriteRequest = TypeFromSchema<typeof TlvWriteRequest>;
+export type WriteResponse = TypeFromSchema<typeof TlvWriteResponse>;
+/** Error base Class for all errors related to the status response messages. */
+export declare class StatusResponseError extends MatterError {
+    readonly code: StatusCode;
+    constructor(message: string, code: StatusCode);
+}
+declare class InteractionMessenger<ContextT> {
+    protected exchange: MessageExchange<ContextT>;
+    constructor(exchange: MessageExchange<ContextT>);
+    send(messageType: number, payload: ByteArray): Promise<void>;
+    sendStatus(status: StatusCode): Promise<void>;
+    waitForSuccess(): Promise<void>;
+    nextMessage(expectedMessageType?: number): Promise<Message>;
+    close(): void;
+    protected throwIfErrorStatusMessage(message: Message): void;
+}
+export declare class InteractionServerMessenger extends InteractionMessenger<MatterDevice> {
+    handleRequest(handleReadRequest: (request: ReadRequest) => DataReport, handleWriteRequest: (request: WriteRequest) => WriteResponse, handleSubscribeRequest: (request: SubscribeRequest, messenger: InteractionServerMessenger) => Promise<void>, handleInvokeRequest: (request: InvokeRequest, message: Message) => Promise<InvokeResponse>, handleTimedRequest: (request: TimedRequest) => void): Promise<void>;
+    sendDataReport(dataReport: DataReport): Promise<void>;
+}
+export declare class IncomingInteractionClientMessenger extends InteractionMessenger<MatterController> {
+    readDataReport(): Promise<DataReport>;
+}
+export declare class InteractionClientMessenger extends IncomingInteractionClientMessenger {
+    private readonly exchangeProvider;
+    constructor(exchangeProvider: ExchangeProvider);
+    /** Implements a send method with an automatic reconnection mechanism */
+    send(messageType: number, payload: ByteArray, expectAckOnly?: boolean): Promise<void>;
+    sendReadRequest(readRequest: ReadRequest): Promise<{
+        interactionModelRevision: number;
+        subscriptionId?: number | undefined;
+        attributeReports?: {
+            attributeStatus?: {
+                path: {
+                    nodeId?: import("../../datatype/NodeId.js").NodeId | undefined;
+                    enableTagCompression?: boolean | undefined;
+                    endpointId?: number | undefined;
+                    clusterId?: number | undefined;
+                    attributeId?: number | undefined;
+                    listIndex?: number | null | undefined;
+                };
+                status: {
+                    status?: StatusCode | undefined;
+                    clusterStatus?: StatusCode | undefined;
+                };
+            } | undefined;
+            attributeData?: {
+                data: import("../../tlv/TlvSchema.js").TlvStream;
+                path: {
+                    nodeId?: import("../../datatype/NodeId.js").NodeId | undefined;
+                    enableTagCompression?: boolean | undefined;
+                    endpointId?: number | undefined;
+                    clusterId?: number | undefined;
+                    attributeId?: number | undefined;
+                    listIndex?: number | null | undefined;
+                };
+                dataVersion: number;
+            } | undefined;
+        }[] | undefined;
+        eventReports?: {
+            eventStatus: {
+                path: {
+                    node?: import("../../datatype/NodeId.js").NodeId | undefined;
+                    endpoint?: number | undefined;
+                    cluster?: number | undefined;
+                    event?: number | undefined;
+                    isUrgent?: boolean | undefined;
+                };
+                status: {
+                    status?: StatusCode | undefined;
+                    clusterStatus?: StatusCode | undefined;
+                };
+            };
+            eventData: {
+                path: {
+                    node?: import("../../datatype/NodeId.js").NodeId | undefined;
+                    endpoint?: number | undefined;
+                    cluster?: number | undefined;
+                    event?: number | undefined;
+                    isUrgent?: boolean | undefined;
+                };
+                eventNumber: number | bigint;
+                priority: number;
+                data?: import("../../tlv/TlvSchema.js").TlvStream | undefined;
+                epochTimestamp?: number | bigint | undefined;
+                systemTimestamp?: number | bigint | undefined;
+                deltaEpochTimestamp?: number | bigint | undefined;
+                deltaSystemTimestamp?: number | bigint | undefined;
+            };
+        }[] | undefined;
+        moreChunkedMessages?: boolean | undefined;
+        suppressResponse?: boolean | undefined;
+    }>;
+    sendSubscribeRequest(subscribeRequest: SubscribeRequest): Promise<{
+        subscribeResponse: {
+            interactionModelRevision: number;
+            subscriptionId: number;
+            maxInterval: number;
+        };
+        report: {
+            interactionModelRevision: number;
+            subscriptionId?: number | undefined;
+            attributeReports?: {
+                attributeStatus?: {
+                    path: {
+                        nodeId?: import("../../datatype/NodeId.js").NodeId | undefined;
+                        enableTagCompression?: boolean | undefined;
+                        endpointId?: number | undefined;
+                        clusterId?: number | undefined;
+                        attributeId?: number | undefined;
+                        listIndex?: number | null | undefined;
+                    };
+                    status: {
+                        status?: StatusCode | undefined;
+                        clusterStatus?: StatusCode | undefined;
+                    };
+                } | undefined;
+                attributeData?: {
+                    data: import("../../tlv/TlvSchema.js").TlvStream;
+                    path: {
+                        nodeId?: import("../../datatype/NodeId.js").NodeId | undefined;
+                        enableTagCompression?: boolean | undefined;
+                        endpointId?: number | undefined;
+                        clusterId?: number | undefined;
+                        attributeId?: number | undefined;
+                        listIndex?: number | null | undefined;
+                    };
+                    dataVersion: number;
+                } | undefined;
+            }[] | undefined;
+            eventReports?: {
+                eventStatus: {
+                    path: {
+                        node?: import("../../datatype/NodeId.js").NodeId | undefined;
+                        endpoint?: number | undefined;
+                        cluster?: number | undefined;
+                        event?: number | undefined;
+                        isUrgent?: boolean | undefined;
+                    };
+                    status: {
+                        status?: StatusCode | undefined;
+                        clusterStatus?: StatusCode | undefined;
+                    };
+                };
+                eventData: {
+                    path: {
+                        node?: import("../../datatype/NodeId.js").NodeId | undefined;
+                        endpoint?: number | undefined;
+                        cluster?: number | undefined;
+                        event?: number | undefined;
+                        isUrgent?: boolean | undefined;
+                    };
+                    eventNumber: number | bigint;
+                    priority: number;
+                    data?: import("../../tlv/TlvSchema.js").TlvStream | undefined;
+                    epochTimestamp?: number | bigint | undefined;
+                    systemTimestamp?: number | bigint | undefined;
+                    deltaEpochTimestamp?: number | bigint | undefined;
+                    deltaSystemTimestamp?: number | bigint | undefined;
+                };
+            }[] | undefined;
+            moreChunkedMessages?: boolean | undefined;
+            suppressResponse?: boolean | undefined;
+        };
+    }>;
+    sendInvokeCommand(invokeRequest: InvokeRequest): Promise<{
+        interactionModelRevision: number;
+        suppressResponse: boolean;
+        invokeResponses: {
+            status?: {
+                status: {
+                    status?: StatusCode | undefined;
+                    clusterStatus?: StatusCode | undefined;
+                };
+                commandPath: {
+                    clusterId: number;
+                    commandId: number;
+                    endpointId?: number | undefined;
+                };
+            } | undefined;
+            command?: {
+                commandPath: {
+                    clusterId: number;
+                    commandId: number;
+                    endpointId?: number | undefined;
+                };
+                commandFields?: import("../../tlv/TlvSchema.js").TlvStream | undefined;
+            } | undefined;
+        }[];
+    } | undefined>;
+    sendWriteCommand(writeRequest: WriteRequest): Promise<{
+        interactionModelRevision: number;
+        writeResponses: {
+            path: {
+                nodeId?: import("../../datatype/NodeId.js").NodeId | undefined;
+                enableTagCompression?: boolean | undefined;
+                endpointId?: number | undefined;
+                clusterId?: number | undefined;
+                attributeId?: number | undefined;
+                listIndex?: number | null | undefined;
+            };
+            status: {
+                status?: StatusCode | undefined;
+                clusterStatus?: StatusCode | undefined;
+            };
+        }[];
+    } | undefined>;
+    sendTimedRequest(timeoutSeconds: number): Promise<{
+        status: StatusCode;
+        interactionModelRevision: number;
+    }>;
+    private requestWithSuppressedResponse;
+    private request;
+}
+export {};
+//# sourceMappingURL=InteractionMessenger.d.ts.map

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

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

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

@@ -0,0 +1,297 @@
+"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.InteractionClientMessenger = exports.IncomingInteractionClientMessenger = exports.InteractionServerMessenger = exports.StatusResponseError = void 0;
+const Logger_js_1 = require("../../log/Logger.js");
+const TryCatchHandler_js_1 = require("../../common/TryCatchHandler.js");
+const MatterError_js_1 = require("../../common/MatterError.js");
+const MessageExchange_js_1 = require("../../protocol/MessageExchange.js");
+const InteractionProtocol_js_1 = require("./InteractionProtocol.js");
+/** Error base Class for all errors related to the status response messages. */
+class StatusResponseError extends MatterError_js_1.MatterError {
+    constructor(message, code) {
+        super();
+        this.code = code;
+        this.message = `(${code}) ${message}`;
+    }
+}
+exports.StatusResponseError = StatusResponseError;
+const MAX_SPDU_LENGTH = 1024;
+const logger = Logger_js_1.Logger.get("InteractionMessenger");
+class InteractionMessenger {
+    constructor(exchange) {
+        this.exchange = exchange;
+    }
+    send(messageType, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.exchange.send(messageType, payload);
+        });
+    }
+    sendStatus(status) {
+        return this.send(1 /* MessageType.StatusResponse */, InteractionProtocol_js_1.TlvStatusResponse.encode({ status, interactionModelRevision: 1 }));
+    }
+    waitForSuccess() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // If the status is not Success, this would throw an Error.
+            yield this.nextMessage(1 /* MessageType.StatusResponse */);
+        });
+    }
+    nextMessage(expectedMessageType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = yield this.exchange.nextMessage();
+            const messageType = message.payloadHeader.messageType;
+            this.throwIfErrorStatusMessage(message);
+            if (expectedMessageType !== undefined && messageType !== expectedMessageType)
+                throw new Error(`Received unexpected message type: ${messageType}, expected: ${expectedMessageType}`);
+            return message;
+        });
+    }
+    close() {
+        this.exchange.close();
+    }
+    throwIfErrorStatusMessage(message) {
+        const { payloadHeader: { messageType }, payload } = message;
+        if (messageType !== 1 /* MessageType.StatusResponse */)
+            return;
+        const { status } = InteractionProtocol_js_1.TlvStatusResponse.decode(payload);
+        if (status !== 0 /* StatusCode.Success */)
+            throw new StatusResponseError(`Received error status: ${status}`, status);
+    }
+}
+class InteractionServerMessenger extends InteractionMessenger {
+    handleRequest(handleReadRequest, handleWriteRequest, handleSubscribeRequest, handleInvokeRequest, handleTimedRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let continueExchange = true;
+            try {
+                while (continueExchange) {
+                    const message = yield this.exchange.nextMessage();
+                    continueExchange = false;
+                    switch (message.payloadHeader.messageType) {
+                        case 2 /* MessageType.ReadRequest */: {
+                            const readRequest = InteractionProtocol_js_1.TlvReadRequest.decode(message.payload);
+                            yield this.sendDataReport(handleReadRequest(readRequest));
+                            break;
+                        }
+                        case 6 /* MessageType.WriteRequest */: {
+                            const writeRequest = InteractionProtocol_js_1.TlvWriteRequest.decode(message.payload);
+                            const writeResponse = handleWriteRequest(writeRequest);
+                            yield this.send(7 /* MessageType.WriteResponse */, InteractionProtocol_js_1.TlvWriteResponse.encode(writeResponse));
+                            break;
+                        }
+                        case 3 /* MessageType.SubscribeRequest */: {
+                            const subscribeRequest = InteractionProtocol_js_1.TlvSubscribeRequest.decode(message.payload);
+                            yield handleSubscribeRequest(subscribeRequest, this);
+                            // response is sent by handler
+                            break;
+                        }
+                        case 8 /* MessageType.InvokeCommandRequest */: {
+                            const invokeRequest = InteractionProtocol_js_1.TlvInvokeRequest.decode(message.payload);
+                            const invokeResponse = yield handleInvokeRequest(invokeRequest, message);
+                            yield this.send(9 /* MessageType.InvokeCommandResponse */, InteractionProtocol_js_1.TlvInvokeResponse.encode(invokeResponse));
+                            break;
+                        }
+                        case 10 /* MessageType.TimedRequest */: {
+                            const timedRequest = InteractionProtocol_js_1.TlvTimedRequest.decode(message.payload);
+                            handleTimedRequest(timedRequest);
+                            yield this.sendStatus(0 /* StatusCode.Success */);
+                            continueExchange = true;
+                            break;
+                        }
+                        default:
+                            throw new Error(`Unsupported message type ${message.payloadHeader.messageType}`);
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof StatusResponseError) {
+                    logger.info(`Sending status response ${error.code} for interaction error: ${error}`);
+                    yield this.sendStatus(error.code);
+                }
+                else {
+                    logger.error(error);
+                    yield this.sendStatus(1 /* StatusCode.Failure */);
+                }
+            }
+            finally {
+                this.exchange.close();
+            }
+        });
+    }
+    sendDataReport(dataReport) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const messageBytes = InteractionProtocol_js_1.TlvDataReport.encode(dataReport);
+            if (!Array.isArray(dataReport.attributeReports)) {
+                throw new Error(`DataReport.values must be an array, got: ${dataReport.attributeReports}`);
+            }
+            if (messageBytes.length > MAX_SPDU_LENGTH) {
+                // DataReport is too long, it needs to be sent in chunks
+                const attributeReportsToSend = [...dataReport.attributeReports];
+                dataReport.attributeReports.length = 0;
+                dataReport.moreChunkedMessages = true;
+                const emptyDataReportBytes = InteractionProtocol_js_1.TlvDataReport.encode(dataReport);
+                let messageSize = emptyDataReportBytes.length;
+                while (true) {
+                    const attributeReport = attributeReportsToSend.pop();
+                    if (attributeReport === undefined) {
+                        // No more chunks to send
+                        dataReport.moreChunkedMessages = undefined;
+                        break;
+                    }
+                    const attributeReportBytes = InteractionProtocol_js_1.TlvAttributeReport.encode(attributeReport).length;
+                    if (messageSize + attributeReportBytes > MAX_SPDU_LENGTH) {
+                        if (messageSize === emptyDataReportBytes.length) {
+                            throw new Error(`Attribute report for is too long to fit in a single chunk, Array chunking not yet supported`);
+                        }
+                        // Report doesn't fit, sending this chunk
+                        yield this.send(5 /* MessageType.ReportData */, InteractionProtocol_js_1.TlvDataReport.encode(dataReport));
+                        yield this.waitForSuccess();
+                        dataReport.attributeReports.length = 0;
+                        messageSize = emptyDataReportBytes.length;
+                    }
+                    messageSize += attributeReportBytes;
+                    dataReport.attributeReports.push(attributeReport);
+                }
+            }
+            if (dataReport.suppressResponse) {
+                // We do not expect a response other than a Standalone Ack, so if we receive anything else, we throw an error
+                yield (0, TryCatchHandler_js_1.tryCatchAsync)(() => __awaiter(this, void 0, void 0, function* () { return yield this.exchange.send(5 /* MessageType.ReportData */, InteractionProtocol_js_1.TlvDataReport.encode(dataReport), true); }), MessageExchange_js_1.UnexpectedMessageError, error => {
+                    const { receivedMessage } = error;
+                    this.throwIfErrorStatusMessage(receivedMessage);
+                });
+            }
+            else {
+                yield this.exchange.send(5 /* MessageType.ReportData */, InteractionProtocol_js_1.TlvDataReport.encode(dataReport));
+                yield this.waitForSuccess();
+            }
+        });
+    }
+}
+exports.InteractionServerMessenger = InteractionServerMessenger;
+class IncomingInteractionClientMessenger extends InteractionMessenger {
+    readDataReport() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let subscriptionId;
+            const values = [];
+            while (true) {
+                const dataReportMessage = yield this.exchange.waitFor(5 /* MessageType.ReportData */);
+                const report = InteractionProtocol_js_1.TlvDataReport.decode(dataReportMessage.payload);
+                if (subscriptionId === undefined && report.subscriptionId !== undefined) {
+                    subscriptionId = report.subscriptionId;
+                }
+                else if ((subscriptionId !== undefined || report.subscriptionId !== undefined) && report.subscriptionId !== subscriptionId) {
+                    throw new Error(`Invalid subscription ID ${report.subscriptionId} received`);
+                }
+                if (Array.isArray(report.attributeReports) && report.attributeReports.length > 0) {
+                    values.push(...report.attributeReports);
+                }
+                if (!report.moreChunkedMessages) {
+                    report.attributeReports = values;
+                    return report;
+                }
+                yield this.sendStatus(0 /* StatusCode.Success */);
+            }
+        });
+    }
+}
+exports.IncomingInteractionClientMessenger = IncomingInteractionClientMessenger;
+class InteractionClientMessenger extends IncomingInteractionClientMessenger {
+    constructor(exchangeProvider) {
+        super(exchangeProvider.initiateExchange());
+        this.exchangeProvider = exchangeProvider;
+    }
+    /** Implements a send method with an automatic reconnection mechanism */
+    send(messageType, payload, expectAckOnly = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.exchange.send(messageType, payload, expectAckOnly);
+            }
+            catch (error) {
+                // When retransmission failed (most likely due to a lost connection or invalid session),
+                // try to reconnect if possible and resend the message once
+                if (error instanceof MessageExchange_js_1.RetransmissionLimitReachedError) {
+                    this.exchange.close();
+                    if (yield this.exchangeProvider.reconnectChannel()) {
+                        this.exchange = this.exchangeProvider.initiateExchange();
+                        return yield this.exchange.send(messageType, payload);
+                    }
+                }
+                throw error;
+            }
+        });
+    }
+    sendReadRequest(readRequest) {
+        return this.request(2 /* MessageType.ReadRequest */, InteractionProtocol_js_1.TlvReadRequest, 5 /* MessageType.ReportData */, InteractionProtocol_js_1.TlvDataReport, readRequest);
+    }
+    sendSubscribeRequest(subscribeRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.send(3 /* MessageType.SubscribeRequest */, InteractionProtocol_js_1.TlvSubscribeRequest.encode(subscribeRequest));
+            const report = yield this.readDataReport();
+            const { subscriptionId } = report;
+            if (subscriptionId === undefined) {
+                throw new Error(`Subscription ID not provided in report`);
+            }
+            yield this.sendStatus(0 /* StatusCode.Success */);
+            const subscribeResponseMessage = yield this.nextMessage(4 /* MessageType.SubscribeResponse */);
+            const subscribeResponse = InteractionProtocol_js_1.TlvSubscribeResponse.decode(subscribeResponseMessage.payload);
+            if (subscribeResponse.subscriptionId !== subscriptionId) {
+                throw new Error(`Received subscription ID ${subscribeResponse.subscriptionId} instead of ${subscriptionId}`);
+            }
+            return {
+                subscribeResponse,
+                report,
+            };
+        });
+    }
+    sendInvokeCommand(invokeRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (invokeRequest.suppressResponse) {
+                yield this.requestWithSuppressedResponse(8 /* MessageType.InvokeCommandRequest */, InteractionProtocol_js_1.TlvInvokeRequest, invokeRequest);
+            }
+            else {
+                return yield this.request(8 /* MessageType.InvokeCommandRequest */, InteractionProtocol_js_1.TlvInvokeRequest, 9 /* MessageType.InvokeCommandResponse */, InteractionProtocol_js_1.TlvInvokeResponse, invokeRequest);
+            }
+        });
+    }
+    sendWriteCommand(writeRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (writeRequest.suppressResponse) {
+                yield this.requestWithSuppressedResponse(6 /* MessageType.WriteRequest */, InteractionProtocol_js_1.TlvWriteRequest, writeRequest);
+            }
+            else {
+                return yield this.request(6 /* MessageType.WriteRequest */, InteractionProtocol_js_1.TlvWriteRequest, 7 /* MessageType.WriteResponse */, InteractionProtocol_js_1.TlvWriteResponse, writeRequest);
+            }
+        });
+    }
+    sendTimedRequest(timeoutSeconds) {
+        return this.request(10 /* MessageType.TimedRequest */, InteractionProtocol_js_1.TlvTimedRequest, 1 /* MessageType.StatusResponse */, InteractionProtocol_js_1.TlvStatusResponse, {
+            timeout: timeoutSeconds,
+            interactionModelRevision: 1
+        });
+    }
+    requestWithSuppressedResponse(requestMessageType, requestSchema, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.send(requestMessageType, requestSchema.encode(request), true);
+        });
+    }
+    request(requestMessageType, requestSchema, responseMessageType, responseSchema, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.send(requestMessageType, requestSchema.encode(request));
+            const responseMessage = yield this.nextMessage(responseMessageType);
+            return responseSchema.decode(responseMessage.payload);
+        });
+    }
+}
+exports.InteractionClientMessenger = InteractionClientMessenger;