hap-nodejs 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/lib/datastream/DataStreamServer.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataStreamConnection = exports.DataStreamConnectionEvent = exports.DataStreamServer = exports.DataStreamServerEvent = exports.DataSendCloseReason = exports.HDSStatus = exports.Topics = exports.Protocols = void 0;
+exports.DataStreamConnection = exports.HDSConnectionError = exports.HDSConnectionErrorType = exports.DataStreamConnectionEvent = exports.DataStreamServer = exports.DataStreamServerEvent = exports.MessageType = exports.HDSProtocolError = exports.HDSProtocolSpecificErrorReason = exports.HDSStatus = exports.Topics = exports.Protocols = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
 var crypto_1 = tslib_1.__importDefault(require("crypto"));
@@ -9,13 +9,19 @@ var events_1 = require("events");
 var net_1 = tslib_1.__importDefault(require("net"));
 var hapCrypto = tslib_1.__importStar(require("../util/hapCrypto"));
 var DataStreamParser_1 = require("./DataStreamParser");
-var debug = debug_1.default('HAP-NodeJS:DataStream:Server');
+var debug = (0, debug_1.default)("HAP-NodeJS:DataStream:Server");
+/**
+ * @group HomeKit Data Streams (HDS)
+ */
 var Protocols;
 (function (Protocols) {
     Protocols["CONTROL"] = "control";
     Protocols["TARGET_CONTROL"] = "targetControl";
     Protocols["DATA_SEND"] = "dataSend";
 })(Protocols = exports.Protocols || (exports.Protocols = {}));
+/**
+ * @group HomeKit Data Streams (HDS)
+ */
 var Topics;
 (function (Topics) {
     // control
@@ -28,6 +34,9 @@ var Topics;
     Topics["ACK"] = "ack";
     Topics["CLOSE"] = "close";
 })(Topics = exports.Topics || (exports.Topics = {}));
+/**
+ * @group HomeKit Data Streams (HDS)
+ */
 var HDSStatus;
 (function (HDSStatus) {
     // noinspection JSUnusedGlobalSymbols
@@ -39,17 +48,44 @@ var HDSStatus;
     HDSStatus[HDSStatus["MISSING_PROTOCOL"] = 5] = "MISSING_PROTOCOL";
     HDSStatus[HDSStatus["PROTOCOL_SPECIFIC_ERROR"] = 6] = "PROTOCOL_SPECIFIC_ERROR";
 })(HDSStatus = exports.HDSStatus || (exports.HDSStatus = {}));
-var DataSendCloseReason;
-(function (DataSendCloseReason) {
+/**
+ * @group HomeKit Data Streams (HDS)
+ */
+var HDSProtocolSpecificErrorReason;
+(function (HDSProtocolSpecificErrorReason) {
     // noinspection JSUnusedGlobalSymbols
-    DataSendCloseReason[DataSendCloseReason["NORMAL"] = 0] = "NORMAL";
-    DataSendCloseReason[DataSendCloseReason["NOT_ALLOWED"] = 1] = "NOT_ALLOWED";
-    DataSendCloseReason[DataSendCloseReason["BUSY"] = 2] = "BUSY";
-    DataSendCloseReason[DataSendCloseReason["CANCELLED"] = 3] = "CANCELLED";
-    DataSendCloseReason[DataSendCloseReason["UNSUPPORTED"] = 4] = "UNSUPPORTED";
-    DataSendCloseReason[DataSendCloseReason["UNEXPECTED_FAILURE"] = 5] = "UNEXPECTED_FAILURE";
-    DataSendCloseReason[DataSendCloseReason["TIMEOUT"] = 6] = "TIMEOUT";
-})(DataSendCloseReason = exports.DataSendCloseReason || (exports.DataSendCloseReason = {}));
+    HDSProtocolSpecificErrorReason[HDSProtocolSpecificErrorReason["NORMAL"] = 0] = "NORMAL";
+    HDSProtocolSpecificErrorReason[HDSProtocolSpecificErrorReason["NOT_ALLOWED"] = 1] = "NOT_ALLOWED";
+    HDSProtocolSpecificErrorReason[HDSProtocolSpecificErrorReason["BUSY"] = 2] = "BUSY";
+    HDSProtocolSpecificErrorReason[HDSProtocolSpecificErrorReason["CANCELLED"] = 3] = "CANCELLED";
+    HDSProtocolSpecificErrorReason[HDSProtocolSpecificErrorReason["UNSUPPORTED"] = 4] = "UNSUPPORTED";
+    HDSProtocolSpecificErrorReason[HDSProtocolSpecificErrorReason["UNEXPECTED_FAILURE"] = 5] = "UNEXPECTED_FAILURE";
+    HDSProtocolSpecificErrorReason[HDSProtocolSpecificErrorReason["TIMEOUT"] = 6] = "TIMEOUT";
+    HDSProtocolSpecificErrorReason[HDSProtocolSpecificErrorReason["BAD_DATA"] = 7] = "BAD_DATA";
+    HDSProtocolSpecificErrorReason[HDSProtocolSpecificErrorReason["PROTOCOL_ERROR"] = 8] = "PROTOCOL_ERROR";
+    HDSProtocolSpecificErrorReason[HDSProtocolSpecificErrorReason["INVALID_CONFIGURATION"] = 9] = "INVALID_CONFIGURATION";
+})(HDSProtocolSpecificErrorReason = exports.HDSProtocolSpecificErrorReason || (exports.HDSProtocolSpecificErrorReason = {}));
+/**
+ * An error indicating a protocol level HDS error.
+ * E.g. it may be used to encode a {@link HDSStatus.PROTOCOL_SPECIFIC_ERROR} in the {@link Protocols.DATA_SEND} protocol.
+ * @group HomeKit Data Streams (HDS)
+ */
+var HDSProtocolError = /** @class */ (function (_super) {
+    tslib_1.__extends(HDSProtocolError, _super);
+    /**
+     * Initializes a new `HDSProtocolError`
+     * @param reason - The {@link HDSProtocolSpecificErrorReason}.
+     *  Values MUST NOT be {@link HDSProtocolSpecificErrorReason.NORMAL}.
+     */
+    function HDSProtocolError(reason) {
+        var _this = _super.call(this, "HDSProtocolError: " + reason) || this;
+        (0, assert_1.default)(reason !== 0 /* HDSProtocolSpecificErrorReason.NORMAL */, "Cannot initialize a HDSProtocolError with NORMAL!");
+        _this.reason = reason;
+        return _this;
+    }
+    return HDSProtocolError;
+}(Error));
+exports.HDSProtocolError = HDSProtocolError;
 var ServerState;
 (function (ServerState) {
     ServerState[ServerState["UNINITIALIZED"] = 0] = "UNINITIALIZED";
@@ -65,12 +101,18 @@ var ConnectionState;
     ConnectionState[ConnectionState["CLOSING"] = 3] = "CLOSING";
     ConnectionState[ConnectionState["CLOSED"] = 4] = "CLOSED";
 })(ConnectionState || (ConnectionState = {}));
+/**
+ * @group HomeKit Data Streams (HDS)
+ */
 var MessageType;
 (function (MessageType) {
     MessageType[MessageType["EVENT"] = 1] = "EVENT";
     MessageType[MessageType["REQUEST"] = 2] = "REQUEST";
     MessageType[MessageType["RESPONSE"] = 3] = "RESPONSE";
-})(MessageType || (MessageType = {}));
+})(MessageType = exports.MessageType || (exports.MessageType = {}));
+/**
+ * @group HomeKit Data Streams (HDS)
+ */
 var DataStreamServerEvent;
 (function (DataStreamServerEvent) {
     /**
@@ -85,12 +127,13 @@ var DataStreamServerEvent;
 })(DataStreamServerEvent = exports.DataStreamServerEvent || (exports.DataStreamServerEvent = {}));
 /**
  * DataStreamServer which listens for incoming tcp connections and handles identification of new connections
+ * @group HomeKit Data Streams (HDS)
  */
 var DataStreamServer = /** @class */ (function (_super) {
     tslib_1.__extends(DataStreamServer, _super);
     function DataStreamServer() {
         var _this = _super.call(this) || this;
-        _this.state = 0 /* UNINITIALIZED */;
+        _this.state = 0 /* ServerState.UNINITIALIZED */;
         _this.preparedSessions = [];
         _this.connections = [];
         _this.removeListenersOnceClosed = false;
@@ -102,20 +145,20 @@ var DataStreamServer = /** @class */ (function (_super) {
      * The handler is only called for a connection if for the give protocol no ProtocolHandler
      * was registered on the connection level.
      *
-     * @param protocol {string | Protocols} - name of the protocol to register the handler for
-     * @param event {string | Topics} - name of the event (also referred to as topic. See {Topics} for some known ones)
-     * @param handler {GlobalEventHandler} - function to be called for every occurring event
+     * @param protocol - name of the protocol to register the handler for
+     * @param event - name of the event (also referred to as topic. See {@link Topics} for some known ones)
+     * @param handler - function to be called for every occurring event
      */
     DataStreamServer.prototype.onEventMessage = function (protocol, event, handler) {
         this.internalEventEmitter.on(protocol + "-e-" + event, handler);
         return this;
     };
     /**
-     * Removes an registered event handler.
+     * Removes a registered event handler.
      *
-     * @param protocol {string | Protocols} - name of the protocol to unregister the handler for
-     * @param event {string | Topics} - name of the event (also referred to as topic. See {Topics} for some known ones)
-     * @param handler {GlobalEventHandler} - registered event handler
+     * @param protocol - name of the protocol to unregister the handler for
+     * @param event - name of the event (also referred to as topic. See {@link Topics} for some known ones)
+     * @param handler - registered event handler
      */
     DataStreamServer.prototype.removeEventHandler = function (protocol, event, handler) {
         this.internalEventEmitter.removeListener(protocol + "-e-" + event, handler);
@@ -126,20 +169,20 @@ var DataStreamServer = /** @class */ (function (_super) {
      * The handler is only called for a connection if for the give protocol no ProtocolHandler
      * was registered on the connection level.
      *
-     * @param protocol {string | Protocols} - name of the protocol to register the handler for
-     * @param request {string | Topics} - name of the request (also referred to as topic. See {Topics} for some known ones)
-     * @param handler {GlobalRequestHandler} - function to be called for every occurring request
+     * @param protocol - name of the protocol to register the handler for
+     * @param request - name of the request (also referred to as topic. See {@link Topics} for some known ones)
+     * @param handler - function to be called for every occurring request
      */
     DataStreamServer.prototype.onRequestMessage = function (protocol, request, handler) {
         this.internalEventEmitter.on(protocol + "-r-" + request, handler);
         return this;
     };
     /**
-     * Removes an registered request handler.
+     * Removes a registered request handler.
      *
-     * @param protocol {string | Protocols} - name of the protocol to unregister the handler for
-     * @param request {string | Topics} - name of the request (also referred to as topic. See {Topics} for some known ones)
-     * @param handler {GlobalRequestHandler} - registered request handler
+     * @param protocol - name of the protocol to unregister the handler for
+     * @param request - name of the request (also referred to as topic. See {@link Topics} for some known ones)
+     * @param handler - registered request handler
      */
     DataStreamServer.prototype.removeRequestHandler = function (protocol, request, handler) {
         this.internalEventEmitter.removeListener(protocol + "-r-" + request, handler);
@@ -181,32 +224,32 @@ var DataStreamServer = /** @class */ (function (_super) {
     DataStreamServer.prototype.checkTCPServerEstablished = function (preparedSession, callback) {
         var _this = this;
         switch (this.state) {
-            case 0 /* UNINITIALIZED */:
+            case 0 /* ServerState.UNINITIALIZED */:
                 debug("Starting up TCP server.");
                 this.tcpServer = net_1.default.createServer();
-                this.tcpServer.once('listening', this.listening.bind(this, preparedSession, callback));
-                this.tcpServer.on('connection', this.onConnection.bind(this));
-                this.tcpServer.on('close', this.closed.bind(this));
+                this.tcpServer.once("listening", this.listening.bind(this, preparedSession, callback));
+                this.tcpServer.on("connection", this.onConnection.bind(this));
+                this.tcpServer.on("close", this.closed.bind(this));
                 this.tcpServer.listen();
-                this.state = 1 /* BINDING */;
+                this.state = 1 /* ServerState.BINDING */;
                 break;
-            case 1 /* BINDING */:
+            case 1 /* ServerState.BINDING */:
                 debug("TCP server already running. Waiting for it to bind.");
-                this.tcpServer.once('listening', this.listening.bind(this, preparedSession, callback));
+                this.tcpServer.once("listening", this.listening.bind(this, preparedSession, callback));
                 break;
-            case 2 /* LISTENING */:
+            case 2 /* ServerState.LISTENING */:
                 debug("Instructing client to connect to already running TCP server");
                 preparedSession.port = this.tcpPort;
                 callback();
                 break;
-            case 3 /* CLOSING */:
+            case 3 /* ServerState.CLOSING */:
                 debug("TCP socket is currently closing. Trying again when server is fully closed and opening a new one then.");
-                this.tcpServer.once('close', function () { return setTimeout(function () { return _this.checkTCPServerEstablished(preparedSession, callback); }, 10); });
+                this.tcpServer.once("close", function () { return setTimeout(function () { return _this.checkTCPServerEstablished(preparedSession, callback); }, 10); });
                 break;
         }
     };
     DataStreamServer.prototype.listening = function (preparedSession, callback) {
-        this.state = 2 /* LISTENING */;
+        this.state = 2 /* ServerState.LISTENING */;
         var address = this.tcpServer.address();
         if (address && typeof address !== "string") { // address is only typeof string when listening to a pipe or unix socket
             this.tcpPort = address.port;
@@ -217,12 +260,13 @@ var DataStreamServer = /** @class */ (function (_super) {
     };
     DataStreamServer.prototype.onConnection = function (socket) {
         debug("[%s] New DataStream connection was established", socket.remoteAddress);
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
         var connection = new DataStreamConnection(socket);
-        connection.on("identification" /* IDENTIFICATION */, this.handleSessionIdentification.bind(this, connection));
-        connection.on("handle-message-globally" /* HANDLE_MESSAGE_GLOBALLY */, this.handleMessageGlobally.bind(this, connection));
-        connection.on("closed" /* CLOSED */, this.connectionClosed.bind(this, connection));
+        connection.on("identification" /* DataStreamConnectionEvent.IDENTIFICATION */, this.handleSessionIdentification.bind(this, connection));
+        connection.on("handle-message-globally" /* DataStreamConnectionEvent.HANDLE_MESSAGE_GLOBALLY */, this.handleMessageGlobally.bind(this, connection));
+        connection.on("closed" /* DataStreamConnectionEvent.CLOSED */, this.connectionClosed.bind(this, connection));
         this.connections.push(connection);
-        this.emit("connection-opened" /* CONNECTION_OPENED */, connection);
+        this.emit("connection-opened" /* DataStreamServerEvent.CONNECTION_OPENED */, connection);
     };
     DataStreamServer.prototype.handleSessionIdentification = function (connection, firstFrame, callback) {
         var identifiedSession = undefined;
@@ -254,20 +298,20 @@ var DataStreamServer = /** @class */ (function (_super) {
     };
     DataStreamServer.prototype.handleMessageGlobally = function (connection, message) {
         var _a;
-        assert_1.default.notStrictEqual(message.type, 3 /* RESPONSE */); // responses can't physically get here
+        assert_1.default.notStrictEqual(message.type, 3 /* MessageType.RESPONSE */); // responses can't physically get here
         var separator = "";
         var args = [];
-        if (message.type === 1 /* EVENT */) {
+        if (message.type === 1 /* MessageType.EVENT */) {
             separator = "-e-";
         }
-        else if (message.type === 2 /* REQUEST */) {
+        else if (message.type === 2 /* MessageType.REQUEST */) {
             separator = "-r-";
             args.push(message.id);
         }
         args.push(message.message);
         var hadListeners;
         try {
-            hadListeners = (_a = this.internalEventEmitter).emit.apply(_a, tslib_1.__spreadArray([message.protocol + separator + message.topic, connection], tslib_1.__read(args)));
+            hadListeners = (_a = this.internalEventEmitter).emit.apply(_a, tslib_1.__spreadArray([message.protocol + separator + message.topic, connection], tslib_1.__read(args), false));
         }
         catch (error) {
             hadListeners = true;
@@ -281,16 +325,16 @@ var DataStreamServer = /** @class */ (function (_super) {
     DataStreamServer.prototype.connectionClosed = function (connection) {
         debug("[%s] DataStream connection closed", connection.remoteAddress);
         this.connections.splice(this.connections.indexOf(connection), 1);
-        this.emit("connection-closed" /* CONNECTION_CLOSED */, connection);
+        this.emit("connection-closed" /* DataStreamServerEvent.CONNECTION_CLOSED */, connection);
         this.checkCloseable();
-        if (this.state === 3 /* CLOSING */ && this.removeListenersOnceClosed && this.connections.length === 0) {
+        if (this.state === 3 /* ServerState.CLOSING */ && this.removeListenersOnceClosed && this.connections.length === 0) {
             this.removeAllListeners(); // see this.destroy()
         }
     };
     DataStreamServer.prototype.checkCloseable = function () {
-        if (this.connections.length === 0 && this.preparedSessions.length === 0 && this.state < 3 /* CLOSING */) {
+        if (this.connections.length === 0 && this.preparedSessions.length === 0 && this.state < 3 /* ServerState.CLOSING */) {
             debug("Last connection disconnected. Closing the server now.");
-            this.state = 3 /* CLOSING */;
+            this.state = 3 /* ServerState.CLOSING */;
             this.tcpServer.close();
         }
     };
@@ -299,7 +343,7 @@ var DataStreamServer = /** @class */ (function (_super) {
      */
     DataStreamServer.prototype.destroy = function () {
         var e_1, _a;
-        if (this.state > 0 /* UNINITIALIZED */ && this.state < 3 /* CLOSING */) {
+        if (this.state > 0 /* ServerState.UNINITIALIZED */ && this.state < 3 /* ServerState.CLOSING */) {
             this.tcpServer.close();
             try {
                 for (var _b = tslib_1.__values(this.connections), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -315,14 +359,14 @@ var DataStreamServer = /** @class */ (function (_super) {
                 finally { if (e_1) throw e_1.error; }
             }
         }
-        this.state = 3 /* CLOSING */;
+        this.state = 3 /* ServerState.CLOSING */;
         this.removeListenersOnceClosed = true;
         this.internalEventEmitter.removeAllListeners();
     };
     DataStreamServer.prototype.closed = function () {
         this.tcpServer = undefined;
         this.tcpPort = undefined;
-        this.state = 0 /* UNINITIALIZED */;
+        this.state = 0 /* ServerState.UNINITIALIZED */;
     };
     DataStreamServer.version = "1.0";
     DataStreamServer.accessoryToControllerInfo = Buffer.from("HDS-Read-Encryption-Key");
@@ -330,6 +374,9 @@ var DataStreamServer = /** @class */ (function (_super) {
     return DataStreamServer;
 }(events_1.EventEmitter));
 exports.DataStreamServer = DataStreamServer;
+/**
+ * @group HomeKit Data Streams (HDS)
+ */
 var DataStreamConnectionEvent;
 (function (DataStreamConnectionEvent) {
     /**
@@ -340,7 +387,7 @@ var DataStreamConnectionEvent;
      */
     DataStreamConnectionEvent["IDENTIFICATION"] = "identification";
     /**
-     * This event is emitted when no handler could be found for the given protocol of a event or request message.
+     * This event is emitted when no handler could be found for the given protocol of an event or request message.
      */
     DataStreamConnectionEvent["HANDLE_MESSAGE_GLOBALLY"] = "handle-message-globally";
     /**
@@ -349,8 +396,32 @@ var DataStreamConnectionEvent;
     DataStreamConnectionEvent["CLOSED"] = "closed";
 })(DataStreamConnectionEvent = exports.DataStreamConnectionEvent || (exports.DataStreamConnectionEvent = {}));
 /**
- * DataStream connection which holds any necessary state information, encryption an decryption keys, manages
+ * @group HomeKit Data Streams (HDS)
+ */
+var HDSConnectionErrorType;
+(function (HDSConnectionErrorType) {
+    HDSConnectionErrorType[HDSConnectionErrorType["ILLEGAL_STATE"] = 1] = "ILLEGAL_STATE";
+    HDSConnectionErrorType[HDSConnectionErrorType["CLOSED_SOCKET"] = 2] = "CLOSED_SOCKET";
+    HDSConnectionErrorType[HDSConnectionErrorType["MAX_PAYLOAD_LENGTH"] = 3] = "MAX_PAYLOAD_LENGTH";
+})(HDSConnectionErrorType = exports.HDSConnectionErrorType || (exports.HDSConnectionErrorType = {}));
+/**
+ * @group HomeKit Data Streams (HDS)
+ */
+var HDSConnectionError = /** @class */ (function (_super) {
+    tslib_1.__extends(HDSConnectionError, _super);
+    function HDSConnectionError(message, type) {
+        var _this = _super.call(this, message) || this;
+        _this.type = type;
+        return _this;
+    }
+    return HDSConnectionError;
+}(Error));
+exports.HDSConnectionError = HDSConnectionError;
+/**
+ * DataStream connection which holds any necessary state information, encryption and decryption keys, manages
  * protocol handlers and also handles sending and receiving of data stream frames.
+ *
+ * @group HomeKit Data Streams (HDS)
  */
 var DataStreamConnection = /** @class */ (function (_super) {
     tslib_1.__extends(DataStreamConnection, _super);
@@ -358,12 +429,12 @@ var DataStreamConnection = /** @class */ (function (_super) {
         var _a;
         var _this = _super.call(this) || this;
         /*
-            Since our DataStream server does only listen on one port and this port is supplied to every client
-            which wants to connect, we do not really know which client is who when we receive a tcp connection.
-            Thus, we find the correct PreparedDataStreamSession object by testing the encryption keys of all available
-            prepared sessions. Then we can reference this hds connection with the correct hap connection and mark it as identified.
-         */
-        _this.state = 0 /* UNIDENTIFIED */;
+              Since our DataStream server does only listen on one port and this port is supplied to every client
+              which wants to connect, we do not really know which client is who when we receive a tcp connection.
+              Thus, we find the correct PreparedDataStreamSession object by testing the encryption keys of all available
+              prepared sessions. Then we can reference this hds connection with the correct hap connection and mark it as identified.
+           */
+        _this.state = 0 /* ConnectionState.UNIDENTIFIED */;
         _this.protocolHandlers = {}; // used to store protocolHandlers identified by their protocol name
         _this.responseHandlers = {}; // used to store responseHandlers indexed by their respective requestId
         _this.responseTimers = {}; // used to store response timeouts indexed by their respective requestId
@@ -376,34 +447,41 @@ var DataStreamConnection = /** @class */ (function (_super) {
         _this.controllerToAccessoryNonce = 0;
         _this.controllerToAccessoryNonceBuffer = Buffer.alloc(8);
         _this.hapConnectionClosedListener = _this.onHAPSessionClosed.bind(_this);
-        _this.addProtocolHandler("control" /* CONTROL */, {
+        _this.addProtocolHandler("control" /* Protocols.CONTROL */, {
             requestHandler: (_a = {},
-                _a["hello" /* HELLO */] = _this.handleHello.bind(_this),
-                _a)
+                _a["hello" /* Topics.HELLO */] = _this.handleHello.bind(_this),
+                _a),
         });
         _this.helloTimer = setTimeout(function () {
             debug("[%s] Hello message did not arrive in time. Killing the connection", _this.remoteAddress);
             _this.close();
         }, 10000);
-        _this.socket.on('data', _this.onSocketData.bind(_this));
-        _this.socket.on('error', _this.onSocketError.bind(_this));
-        _this.socket.on('close', _this.onSocketClose.bind(_this));
+        _this.socket.on("data", _this.onSocketData.bind(_this));
+        _this.socket.on("error", _this.onSocketError.bind(_this));
+        _this.socket.on("close", _this.onSocketClose.bind(_this));
+        // this is to mitigate the event emitter "memory leak warning".
+        // e.g. with HSV there might be multiple cameras subscribing to the CLOSE event. one subscription for
+        // every active recording stream on a camera. The default limit of 10 might be easily reached.
+        // Setting a high limit isn't the prefect solution, but will avoid false positives but ensures that
+        // a warning is still be printed if running long enough.
+        _this.setMaxListeners(100);
         return _this;
     }
-    DataStreamConnection.prototype.handleHello = function (id, _message) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    DataStreamConnection.prototype.handleHello = function (id, message) {
         // that hello is indeed the _first_ message received is verified in onSocketData(...)
-        debug("[%s] Received hello message from client", this.remoteAddress);
+        debug("[%s] Received hello message from client: %o", this.remoteAddress, message);
         clearTimeout(this.helloTimer);
         this.helloTimer = undefined;
-        this.state = 2 /* READY */;
-        this.sendResponse("control" /* CONTROL */, "hello" /* HELLO */, id);
+        this.state = 2 /* ConnectionState.READY */;
+        this.sendResponse("control" /* Protocols.CONTROL */, "hello" /* Topics.HELLO */, id);
     };
     /**
      * Registers a new protocol handler to handle incoming messages.
      * The same protocol cannot be registered multiple times.
      *
-     * @param protocol {string | Protocols} - name of the protocol to register the handler for
-     * @param protocolHandler {DataStreamProtocolHandler} - object to be registered as protocol handler
+     * @param protocol - name of the protocol to register the handler for
+     * @param protocolHandler - object to be registered as protocol handler
      */
     DataStreamConnection.prototype.addProtocolHandler = function (protocol, protocolHandler) {
         if (this.protocolHandlers[protocol] !== undefined) {
@@ -415,8 +493,8 @@ var DataStreamConnection = /** @class */ (function (_super) {
     /**
      * Removes a protocol handler if it is registered.
      *
-     * @param protocol {string | Protocols} - name of the protocol to unregister the handler for
-     * @param protocolHandler {DataStreamProtocolHandler} - object which will be unregistered
+     * @param protocol - name of the protocol to unregister the handler for
+     * @param protocolHandler - object which will be unregistered
      */
     DataStreamConnection.prototype.removeProtocolHandler = function (protocol, protocolHandler) {
         var current = this.protocolHandlers[protocol];
@@ -427,26 +505,29 @@ var DataStreamConnection = /** @class */ (function (_super) {
     /**
      * Sends a new event message to the connected client.
      *
-     * @param protocol {string | Protocols} - name of the protocol
-     * @param event {string | Topics} - name of the event (also referred to as topic. See {Topics} for some known ones)
-     * @param message {Record<any, any>} - message dictionary which gets sent along the event
+     * @param protocol - name of the protocol
+     * @param event - name of the event (also referred to as topic. See {@link Topics} for some known ones)
+     * @param message - message dictionary which gets sent along the event
      */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     DataStreamConnection.prototype.sendEvent = function (protocol, event, message) {
         if (message === void 0) { message = {}; }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         var header = {};
-        header["protocol"] = protocol;
-        header["event"] = event;
+        header.protocol = protocol;
+        header.event = event;
         this.sendHDSFrame(header, message);
     };
     /**
      * Sends a new request message to the connected client.
      *
-     * @param protocol {string | Protocols} - name of the protocol
-     * @param request {string | Topics} - name of the request (also referred to as topic. See {Topics} for some known ones)
-     * @param message {Record<any, any>} - message dictionary which gets sent along the request
-     * @param callback {ResponseHandler} - handler which gets supplied with an error object if the response didn't
-     *                                     arrive in time or the status and the message dictionary from the response
+     * @param protocol - name of the protocol
+     * @param request - name of the request (also referred to as topic. See {@link Topics} for some known ones)
+     * @param message - message dictionary which gets sent along the request
+     * @param callback - handler which gets supplied with an error object if the response didn't
+     *                   arrive in time or the status and the message dictionary from the response
      */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     DataStreamConnection.prototype.sendRequest = function (protocol, request, message, callback) {
         var _this = this;
         if (message === void 0) { message = {}; }
@@ -462,37 +543,41 @@ var DataStreamConnection = /** @class */ (function (_super) {
             var handler = _this.responseHandlers[requestId];
             delete _this.responseHandlers[requestId];
             delete _this.responseTimers[requestId];
-            // handler should be able to cleanup their stuff
+            // handler should be able to clean up their stuff
             handler(new Error("timeout"), undefined, {});
         }, 10000); // 10s timer
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         var header = {};
-        header["protocol"] = protocol;
-        header["request"] = request;
-        header["id"] = new DataStreamParser_1.Int64(requestId);
+        header.protocol = protocol;
+        header.request = request;
+        header.id = new DataStreamParser_1.Int64(requestId);
         this.sendHDSFrame(header, message);
     };
     /**
      * Send a new response message to a received request message to the client.
      *
-     * @param protocol {string | Protocols} - name of the protocol
-     * @param response {string | Topics} - name of the response (also referred to as topic. See {Topics} for some known ones)
-     * @param id {number} - id from the request, to associate the response to the request
-     * @param status {HDSStatus} - status indication if the request was successful. A status of zero indicates success.
-     * @param message {Record<any, any>} - message dictionary which gets sent along the response
+     * @param protocol - name of the protocol
+     * @param response - name of the response (also referred to as topic. See {@link Topics} for some known ones)
+     * @param id - id from the request, to associate the response to the request
+     * @param status - status indication if the request was successful. A status of zero indicates success.
+     * @param message - message dictionary which gets sent along the response
      */
-    DataStreamConnection.prototype.sendResponse = function (protocol, response, id, status, message) {
+    DataStreamConnection.prototype.sendResponse = function (protocol, response, id, status, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    message) {
         if (status === void 0) { status = HDSStatus.SUCCESS; }
         if (message === void 0) { message = {}; }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         var header = {};
-        header["protocol"] = protocol;
-        header["response"] = response;
-        header["id"] = new DataStreamParser_1.Int64(id);
-        header["status"] = new DataStreamParser_1.Int64(status);
+        header.protocol = protocol;
+        header.response = response;
+        header.id = new DataStreamParser_1.Int64(id);
+        header.status = new DataStreamParser_1.Int64(status);
         this.sendHDSFrame(header, message);
     };
     DataStreamConnection.prototype.onSocketData = function (data) {
         var _this = this;
-        if (this.state >= 3 /* CLOSING */) {
+        if (this.state >= 3 /* ConnectionState.CLOSING */) {
             return;
         }
         var frameIndex = 0;
@@ -500,21 +585,22 @@ var DataStreamConnection = /** @class */ (function (_super) {
         if (frames.length === 0) { // not enough data
             return;
         }
-        if (this.state === 0 /* UNIDENTIFIED */) {
+        if (this.state === 0 /* ConnectionState.UNIDENTIFIED */) {
             // at the beginning we are only interested in trying to decrypt the first frame in order to test decryption keys
             var firstFrame = frames[frameIndex++];
-            this.emit("identification" /* IDENTIFICATION */, firstFrame, function (identifiedSession) {
+            this.emit("identification" /* DataStreamConnectionEvent.IDENTIFICATION */, firstFrame, function (identifiedSession) {
                 if (identifiedSession) {
                     // horray, we found our connection
                     _this.connection = identifiedSession.connection;
                     _this.accessoryToControllerEncryptionKey = identifiedSession.accessoryToControllerEncryptionKey;
                     _this.controllerToAccessoryEncryptionKey = identifiedSession.controllerToAccessoryEncryptionKey;
-                    _this.state = 1 /* EXPECTING_HELLO */;
+                    _this.state = 1 /* ConnectionState.EXPECTING_HELLO */;
                     // below listener is removed in .close()
-                    _this.connection.on("closed" /* CLOSED */, _this.hapConnectionClosedListener); // register close listener
+                    _this.connection.on("closed" /* HAPConnectionEvent.CLOSED */, _this.hapConnectionClosedListener); // register close listener
+                    debug("[%s] Registering CLOSED handler to HAP connection. Connection currently has %d close handlers!", _this.remoteAddress, _this.connection.listeners("closed" /* HAPConnectionEvent.CLOSED */).length);
                 }
             });
-            if (this.state === 0 /* UNIDENTIFIED */) {
+            if (this.state === 0 /* ConnectionState.UNIDENTIFIED */) {
                 // did not find a prepared connection, server already closed this connection; nothing to do here
                 return;
             }
@@ -527,9 +613,9 @@ var DataStreamConnection = /** @class */ (function (_super) {
             }
         }
         var messages = this.decodePayloads(frames); // decode contents of payload
-        if (this.state === 1 /* EXPECTING_HELLO */) {
+        if (this.state === 1 /* ConnectionState.EXPECTING_HELLO */) {
             var firstMessage = messages[0];
-            if (firstMessage.protocol !== "control" /* CONTROL */ || firstMessage.type !== 2 /* REQUEST */ || firstMessage.topic !== "hello" /* HELLO */) {
+            if (firstMessage.protocol !== "control" /* Protocols.CONTROL */ || firstMessage.type !== 2 /* MessageType.REQUEST */ || firstMessage.topic !== "hello" /* Topics.HELLO */) {
                 // first message is not the expected hello request
                 debug("[%s] First message received was not the expected hello message. Instead got: %o", this.remoteAddress, firstMessage);
                 this.close();
@@ -537,8 +623,8 @@ var DataStreamConnection = /** @class */ (function (_super) {
             }
         }
         messages.forEach(function (message) {
-            if (message.type === 3 /* RESPONSE */) {
-                // protocol and topic are currently not tested here; just assumed their are correct;
+            if (message.type === 3 /* MessageType.RESPONSE */) {
+                // protocol and topic are currently not tested here; just assumed they are correct;
                 // probably they are as the requestId is unique per connection no matter what protocol is used
                 var responseHandler = _this.responseHandlers[message.id];
                 var responseTimer = _this.responseTimers[message.id];
@@ -564,10 +650,10 @@ var DataStreamConnection = /** @class */ (function (_super) {
                 var handler = _this.protocolHandlers[message.protocol];
                 if (handler === undefined) {
                     // send message to the server to check if there are some global handlers for it
-                    _this.emit("handle-message-globally" /* HANDLE_MESSAGE_GLOBALLY */, message);
+                    _this.emit("handle-message-globally" /* DataStreamConnectionEvent.HANDLE_MESSAGE_GLOBALLY */, message);
                     return;
                 }
-                if (message.type === 1 /* EVENT */) {
+                if (message.type === 1 /* MessageType.EVENT */) {
                     var eventHandler = void 0;
                     if (!handler.eventHandler || !(eventHandler = handler.eventHandler[message.topic])) {
                         debug("[%s] WARNING no event handler was found for message: %o", _this.remoteAddress, message);
@@ -581,7 +667,7 @@ var DataStreamConnection = /** @class */ (function (_super) {
                         debug(error.stack);
                     }
                 }
-                else if (message.type === 2 /* REQUEST */) {
+                else if (message.type === 2 /* MessageType.REQUEST */) {
                     var requestHandler = void 0;
                     if (!handler.requestHandler || !(requestHandler = handler.requestHandler[message.topic])) {
                         debug("[%s] WARNING no request handler was found for message: %o", _this.remoteAddress, message);
@@ -644,11 +730,14 @@ var DataStreamConnection = /** @class */ (function (_super) {
                 frames.push(hdsFrame);
             }
             else {
-                debug("[%s] Encountered unknown payload type %d for payload: %s", this.remoteAddress, plaintextPayload.toString('hex'));
+                debug("[%s] Encountered unknown payload type %d for payload: %s", this.remoteAddress, plaintextPayload.toString("hex"));
             }
         }
         return frames;
     };
+    /**
+     * @private file-private API
+     */
     DataStreamConnection.prototype.decryptHDSFrame = function (frame, keyOverwrite) {
         hapCrypto.writeUInt64LE(this.controllerToAccessoryNonce, this.controllerToAccessoryNonceBuffer, 0); // update nonce buffer
         var key = keyOverwrite || this.controllerToAccessoryEncryptionKey;
@@ -668,7 +757,7 @@ var DataStreamConnection = /** @class */ (function (_super) {
         frames.forEach(function (frame) {
             var payload = frame.plaintextPayload;
             if (!payload) {
-                throw new Error("Reached illegal state. Encountered HDSFrame with wasn't decrypted yet!");
+                throw new HDSConnectionError("Reached illegal state. Encountered HDSFrame with wasn't decrypted yet!", 1 /* HDSConnectionErrorType.ILLEGAL_STATE */);
             }
             var headerLength = payload.readUInt8(0);
             var messageLength = payload.length - headerLength - 1;
@@ -676,7 +765,9 @@ var DataStreamConnection = /** @class */ (function (_super) {
             var messageBegin = headerBegin + headerLength;
             var headerPayload = new DataStreamParser_1.DataStreamReader(payload.slice(headerBegin, headerBegin + headerLength));
             var messagePayload = new DataStreamParser_1.DataStreamReader(payload.slice(messageBegin, messageBegin + messageLength));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             var headerDictionary;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             var messageDictionary;
             try {
                 headerDictionary = DataStreamParser_1.DataStreamParser.decode(headerPayload);
@@ -695,24 +786,24 @@ var DataStreamConnection = /** @class */ (function (_super) {
                 return;
             }
             var type;
-            var protocol = headerDictionary["protocol"];
+            var protocol = headerDictionary.protocol;
             var topic;
             var id = undefined;
             var status = undefined;
-            if (headerDictionary["event"] !== undefined) {
-                type = 1 /* EVENT */;
-                topic = headerDictionary["event"];
+            if (headerDictionary.event !== undefined) {
+                type = 1 /* MessageType.EVENT */;
+                topic = headerDictionary.event;
             }
-            else if (headerDictionary["request"] !== undefined) {
-                type = 2 /* REQUEST */;
-                topic = headerDictionary["request"];
-                id = headerDictionary["id"];
+            else if (headerDictionary.request !== undefined) {
+                type = 2 /* MessageType.REQUEST */;
+                topic = headerDictionary.request;
+                id = headerDictionary.id;
             }
-            else if (headerDictionary["response"] !== undefined) {
-                type = 3 /* RESPONSE */;
-                topic = headerDictionary["response"];
-                id = headerDictionary["id"];
-                status = headerDictionary["status"];
+            else if (headerDictionary.response !== undefined) {
+                type = 3 /* MessageType.RESPONSE */;
+                topic = headerDictionary.response;
+                id = headerDictionary.id;
+                status = headerDictionary.status;
             }
             else {
                 debug("[%s] Encountered unknown payload header format: %o (message: %o)", _this.remoteAddress, headerDictionary, messageDictionary);
@@ -730,9 +821,10 @@ var DataStreamConnection = /** @class */ (function (_super) {
         });
         return messages;
     };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     DataStreamConnection.prototype.sendHDSFrame = function (header, message) {
-        if (this.state >= 3 /* CLOSING */) {
-            throw Error("Cannot send message on closing/closed socket!");
+        if (this.state >= 3 /* ConnectionState.CLOSING */) {
+            throw new HDSConnectionError("Cannot send message on closing/closed socket!", 2 /* HDSConnectionErrorType.CLOSED_SOCKET */);
         }
         var headerWriter = new DataStreamParser_1.DataStreamWriter();
         var messageWriter = new DataStreamParser_1.DataStreamWriter();
@@ -742,7 +834,7 @@ var DataStreamConnection = /** @class */ (function (_super) {
         payloadHeaderBuffer.writeUInt8(headerWriter.length(), 0);
         var payloadBuffer = Buffer.concat([payloadHeaderBuffer, headerWriter.getData(), messageWriter.getData()]);
         if (payloadBuffer.length > DataStreamConnection.MAX_PAYLOAD_LENGTH) {
-            throw new Error("Tried sending payload with length larger than the maximum allowed for data stream");
+            throw new HDSConnectionError("Tried sending payload with length larger than the maximum allowed for data stream", 3 /* HDSConnectionErrorType.MAX_PAYLOAD_LENGTH */);
         }
         var frameTypeBuffer = Buffer.alloc(1);
         frameTypeBuffer.writeUInt8(1, 0);
@@ -754,26 +846,27 @@ var DataStreamConnection = /** @class */ (function (_super) {
         var encrypted = hapCrypto.chacha20_poly1305_encryptAndSeal(this.accessoryToControllerEncryptionKey, this.accessoryToControllerNonceBuffer, frameHeader, payloadBuffer);
         this.socket.write(Buffer.concat([frameHeader, encrypted.ciphertext, encrypted.authTag]));
         /* Useful for debugging outgoing packages and detecting encoding errors
-        console.log("SENT DATA: " + payloadBuffer.toString("hex"));
-        const frame: HDSFrame = {
-            header: frameHeader,
-            plaintextPayload: payloadBuffer,
-            cipheredPayload: cipheredPayload,
-            authTag: authTag,
-        };
-        const sentMessage = this.decodePayloads([frame])[0];
-        console.log("Sent message: " + JSON.stringify(sentMessage, null, 4));
-        //*/
+            console.log("SENT DATA: " + payloadBuffer.toString("hex"));
+            const frame: HDSFrame = {
+                header: frameHeader,
+                plaintextPayload: payloadBuffer,
+                cipheredPayload: cipheredPayload,
+                authTag: authTag,
+            };
+            const sentMessage = this.decodePayloads([frame])[0];
+            console.log("Sent message: " + JSON.stringify(sentMessage, null, 4));
+            //*/
     };
     DataStreamConnection.prototype.close = function () {
-        var _a;
-        if (this.state >= 3 /* CLOSING */) {
+        if (this.state >= 3 /* ConnectionState.CLOSING */) {
             return; // connection is already closing/closed
         }
-        (_a = this.connection) === null || _a === void 0 ? void 0 : _a.removeListener("closed" /* CLOSED */, this.hapConnectionClosedListener);
-        this.state = 3 /* CLOSING */;
+        this.state = 3 /* ConnectionState.CLOSING */;
         this.socket.end();
     };
+    DataStreamConnection.prototype.isConsideredClosed = function () {
+        return this.state >= 3 /* ConnectionState.CLOSING */;
+    };
     DataStreamConnection.prototype.onHAPSessionClosed = function () {
         // If the hap connection is closed it is probably also a good idea to close the data stream connection
         debug("[%s] HAP connection disconnected. Also closing DataStream connection now.", this.remoteAddress);
@@ -784,9 +877,11 @@ var DataStreamConnection = /** @class */ (function (_super) {
         // onSocketClose will be called next
     };
     DataStreamConnection.prototype.onSocketClose = function () {
+        var _a;
         // this instance is now considered completely dead
-        this.state = 4 /* CLOSED */;
-        this.emit("closed" /* CLOSED */);
+        this.state = 4 /* ConnectionState.CLOSED */;
+        this.emit("closed" /* DataStreamConnectionEvent.CLOSED */);
+        (_a = this.connection) === null || _a === void 0 ? void 0 : _a.removeListener("closed" /* HAPConnectionEvent.CLOSED */, this.hapConnectionClosedListener);
         this.removeAllListeners();
     };
     DataStreamConnection.MAX_PAYLOAD_LENGTH = 1048575;