hap-nodejs 1.1.1-beta.5 → 1.1.1-beta.7

package/dist/lib/camera/RecordingManagement.js

@@ -1,20 +1,22 @@
-import { Buffer } from 'node:buffer';
-import { createHash } from 'node:crypto';
-import { EventEmitter } from 'node:events';
-import createDebug from 'debug';
-import { Characteristic } from '../Characteristic.js';
-import { DataStreamManagement, HDSConnectionError, HDSProtocolError, HDSProtocolSpecificErrorReasonConst, HDSStatus, } from '../datastream/index.js';
-import { Service } from '../Service.js';
-import { HapStatusError } from '../util/hapStatusError.js';
-import { decode, encode } from '../util/tlv.js';
-const debug = createDebug('HAP-NodeJS:Camera:RecordingManagement');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordingManagement = exports.PacketDataType = exports.AudioRecordingSamplerate = exports.AudioRecordingCodecType = exports.MediaContainerType = exports.EventTriggerOption = void 0;
+const tslib_1 = require("tslib");
+const crypto_1 = tslib_1.__importDefault(require("crypto"));
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const events_1 = require("events");
+const Characteristic_1 = require("../Characteristic");
+const datastream_1 = require("../datastream");
+const Service_1 = require("../Service");
+const hapStatusError_1 = require("../util/hapStatusError");
+const tlv = tslib_1.__importStar(require("../util/tlv"));
+const debug = (0, debug_1.default)("HAP-NodeJS:Camera:RecordingManagement");
 /**
  * Describes the Event trigger.
  *
  * @group Camera
  */
-// eslint-disable-next-line no-restricted-syntax
-export var EventTriggerOption;
+var EventTriggerOption;
 (function (EventTriggerOption) {
     /**
      * The Motion trigger. If enabled motion should trigger the start of a recording.
@@ -29,23 +31,20 @@ export var EventTriggerOption;
      * See https://github.com/homebridge/HAP-NodeJS/issues/976#issuecomment-1280301989.
      */
     EventTriggerOption[EventTriggerOption["DOORBELL"] = 2] = "DOORBELL";
-})(EventTriggerOption || (EventTriggerOption = {}));
+})(EventTriggerOption || (exports.EventTriggerOption = EventTriggerOption = {}));
 /**
  * @group Camera
  */
-// eslint-disable-next-line no-restricted-syntax
-export var MediaContainerType;
+var MediaContainerType;
 (function (MediaContainerType) {
     MediaContainerType[MediaContainerType["FRAGMENTED_MP4"] = 0] = "FRAGMENTED_MP4";
-})(MediaContainerType || (MediaContainerType = {}));
-// eslint-disable-next-line no-restricted-syntax
+})(MediaContainerType || (exports.MediaContainerType = MediaContainerType = {}));
 var VideoCodecConfigurationTypes;
 (function (VideoCodecConfigurationTypes) {
     VideoCodecConfigurationTypes[VideoCodecConfigurationTypes["CODEC_TYPE"] = 1] = "CODEC_TYPE";
     VideoCodecConfigurationTypes[VideoCodecConfigurationTypes["CODEC_PARAMETERS"] = 2] = "CODEC_PARAMETERS";
     VideoCodecConfigurationTypes[VideoCodecConfigurationTypes["ATTRIBUTES"] = 3] = "ATTRIBUTES";
 })(VideoCodecConfigurationTypes || (VideoCodecConfigurationTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var VideoCodecParametersTypes;
 (function (VideoCodecParametersTypes) {
     VideoCodecParametersTypes[VideoCodecParametersTypes["PROFILE_ID"] = 1] = "PROFILE_ID";
@@ -53,14 +52,12 @@ var VideoCodecParametersTypes;
     VideoCodecParametersTypes[VideoCodecParametersTypes["BITRATE"] = 3] = "BITRATE";
     VideoCodecParametersTypes[VideoCodecParametersTypes["IFRAME_INTERVAL"] = 4] = "IFRAME_INTERVAL";
 })(VideoCodecParametersTypes || (VideoCodecParametersTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var VideoAttributesTypes;
 (function (VideoAttributesTypes) {
     VideoAttributesTypes[VideoAttributesTypes["IMAGE_WIDTH"] = 1] = "IMAGE_WIDTH";
     VideoAttributesTypes[VideoAttributesTypes["IMAGE_HEIGHT"] = 2] = "IMAGE_HEIGHT";
     VideoAttributesTypes[VideoAttributesTypes["FRAME_RATE"] = 3] = "FRAME_RATE";
 })(VideoAttributesTypes || (VideoAttributesTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var SelectedCameraRecordingConfigurationTypes;
 (function (SelectedCameraRecordingConfigurationTypes) {
     SelectedCameraRecordingConfigurationTypes[SelectedCameraRecordingConfigurationTypes["SELECTED_RECORDING_CONFIGURATION"] = 1] = "SELECTED_RECORDING_CONFIGURATION";
@@ -70,17 +67,15 @@ var SelectedCameraRecordingConfigurationTypes;
 /**
  * @group Camera
  */
-// eslint-disable-next-line no-restricted-syntax
-export var AudioRecordingCodecType;
+var AudioRecordingCodecType;
 (function (AudioRecordingCodecType) {
     AudioRecordingCodecType[AudioRecordingCodecType["AAC_LC"] = 0] = "AAC_LC";
     AudioRecordingCodecType[AudioRecordingCodecType["AAC_ELD"] = 1] = "AAC_ELD";
-})(AudioRecordingCodecType || (AudioRecordingCodecType = {}));
+})(AudioRecordingCodecType || (exports.AudioRecordingCodecType = AudioRecordingCodecType = {}));
 /**
  * @group Camera
  */
-// eslint-disable-next-line no-restricted-syntax
-export var AudioRecordingSamplerate;
+var AudioRecordingSamplerate;
 (function (AudioRecordingSamplerate) {
     AudioRecordingSamplerate[AudioRecordingSamplerate["KHZ_8"] = 0] = "KHZ_8";
     AudioRecordingSamplerate[AudioRecordingSamplerate["KHZ_16"] = 1] = "KHZ_16";
@@ -88,45 +83,38 @@ export var AudioRecordingSamplerate;
     AudioRecordingSamplerate[AudioRecordingSamplerate["KHZ_32"] = 3] = "KHZ_32";
     AudioRecordingSamplerate[AudioRecordingSamplerate["KHZ_44_1"] = 4] = "KHZ_44_1";
     AudioRecordingSamplerate[AudioRecordingSamplerate["KHZ_48"] = 5] = "KHZ_48";
-})(AudioRecordingSamplerate || (AudioRecordingSamplerate = {}));
-// eslint-disable-next-line no-restricted-syntax
+})(AudioRecordingSamplerate || (exports.AudioRecordingSamplerate = AudioRecordingSamplerate = {}));
 var SupportedVideoRecordingConfigurationTypes;
 (function (SupportedVideoRecordingConfigurationTypes) {
     SupportedVideoRecordingConfigurationTypes[SupportedVideoRecordingConfigurationTypes["VIDEO_CODEC_CONFIGURATION"] = 1] = "VIDEO_CODEC_CONFIGURATION";
 })(SupportedVideoRecordingConfigurationTypes || (SupportedVideoRecordingConfigurationTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var SupportedCameraRecordingConfigurationTypes;
 (function (SupportedCameraRecordingConfigurationTypes) {
     SupportedCameraRecordingConfigurationTypes[SupportedCameraRecordingConfigurationTypes["PREBUFFER_LENGTH"] = 1] = "PREBUFFER_LENGTH";
     SupportedCameraRecordingConfigurationTypes[SupportedCameraRecordingConfigurationTypes["EVENT_TRIGGER_OPTIONS"] = 2] = "EVENT_TRIGGER_OPTIONS";
     SupportedCameraRecordingConfigurationTypes[SupportedCameraRecordingConfigurationTypes["MEDIA_CONTAINER_CONFIGURATIONS"] = 3] = "MEDIA_CONTAINER_CONFIGURATIONS";
 })(SupportedCameraRecordingConfigurationTypes || (SupportedCameraRecordingConfigurationTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var MediaContainerConfigurationTypes;
 (function (MediaContainerConfigurationTypes) {
     MediaContainerConfigurationTypes[MediaContainerConfigurationTypes["MEDIA_CONTAINER_TYPE"] = 1] = "MEDIA_CONTAINER_TYPE";
     MediaContainerConfigurationTypes[MediaContainerConfigurationTypes["MEDIA_CONTAINER_PARAMETERS"] = 2] = "MEDIA_CONTAINER_PARAMETERS";
 })(MediaContainerConfigurationTypes || (MediaContainerConfigurationTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var MediaContainerParameterTypes;
 (function (MediaContainerParameterTypes) {
     MediaContainerParameterTypes[MediaContainerParameterTypes["FRAGMENT_LENGTH"] = 1] = "FRAGMENT_LENGTH";
 })(MediaContainerParameterTypes || (MediaContainerParameterTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var AudioCodecParametersTypes;
 (function (AudioCodecParametersTypes) {
     AudioCodecParametersTypes[AudioCodecParametersTypes["CHANNEL"] = 1] = "CHANNEL";
     AudioCodecParametersTypes[AudioCodecParametersTypes["BIT_RATE"] = 2] = "BIT_RATE";
     AudioCodecParametersTypes[AudioCodecParametersTypes["SAMPLE_RATE"] = 3] = "SAMPLE_RATE";
-    AudioCodecParametersTypes[AudioCodecParametersTypes["MAX_AUDIO_BITRATE"] = 4] = "MAX_AUDIO_BITRATE";
+    AudioCodecParametersTypes[AudioCodecParametersTypes["MAX_AUDIO_BITRATE"] = 4] = "MAX_AUDIO_BITRATE"; // only present in selected audio codec parameters tlv
 })(AudioCodecParametersTypes || (AudioCodecParametersTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var AudioCodecConfigurationTypes;
 (function (AudioCodecConfigurationTypes) {
     AudioCodecConfigurationTypes[AudioCodecConfigurationTypes["CODEC_TYPE"] = 1] = "CODEC_TYPE";
     AudioCodecConfigurationTypes[AudioCodecConfigurationTypes["CODEC_PARAMETERS"] = 2] = "CODEC_PARAMETERS";
 })(AudioCodecConfigurationTypes || (AudioCodecConfigurationTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var SupportedAudioRecordingConfigurationTypes;
 (function (SupportedAudioRecordingConfigurationTypes) {
     SupportedAudioRecordingConfigurationTypes[SupportedAudioRecordingConfigurationTypes["AUDIO_CODEC_CONFIGURATION"] = 1] = "AUDIO_CODEC_CONFIGURATION";
@@ -134,8 +122,7 @@ var SupportedAudioRecordingConfigurationTypes;
 /**
  * @group Camera
  */
-// eslint-disable-next-line no-restricted-syntax
-export var PacketDataType;
+var PacketDataType;
 (function (PacketDataType) {
     /**
      * mp4 moov box
@@ -145,11 +132,11 @@ export var PacketDataType;
      * mp4 moof + mdat boxes
      */
     PacketDataType["MEDIA_FRAGMENT"] = "mediaFragment";
-})(PacketDataType || (PacketDataType = {}));
+})(PacketDataType || (exports.PacketDataType = PacketDataType = {}));
 /**
  * @group Camera
  */
-export class RecordingManagement {
+class RecordingManagement {
     options;
     delegate;
     stateChangeDelegate;
@@ -197,32 +184,32 @@ export class RecordingManagement {
         this.setupServiceHandlers();
     }
     constructService() {
-        const recordingManagement = new Service.CameraRecordingManagement('', '');
-        recordingManagement.setCharacteristic(Characteristic.Active, false);
-        recordingManagement.setCharacteristic(Characteristic.RecordingAudioActive, false);
-        const operatingMode = new Service.CameraOperatingMode('', '');
-        operatingMode.setCharacteristic(Characteristic.EventSnapshotsActive, true);
-        operatingMode.setCharacteristic(Characteristic.HomeKitCameraActive, true);
-        operatingMode.setCharacteristic(Characteristic.PeriodicSnapshotsActive, true);
-        const dataStreamManagement = new DataStreamManagement();
+        const recordingManagement = new Service_1.Service.CameraRecordingManagement("", "");
+        recordingManagement.setCharacteristic(Characteristic_1.Characteristic.Active, false);
+        recordingManagement.setCharacteristic(Characteristic_1.Characteristic.RecordingAudioActive, false);
+        const operatingMode = new Service_1.Service.CameraOperatingMode("", "");
+        operatingMode.setCharacteristic(Characteristic_1.Characteristic.EventSnapshotsActive, true);
+        operatingMode.setCharacteristic(Characteristic_1.Characteristic.HomeKitCameraActive, true);
+        operatingMode.setCharacteristic(Characteristic_1.Characteristic.PeriodicSnapshotsActive, true);
+        const dataStreamManagement = new datastream_1.DataStreamManagement();
         recordingManagement.addLinkedService(dataStreamManagement.getService());
         return {
-            recordingManagement,
-            operatingMode,
-            dataStreamManagement,
+            recordingManagement: recordingManagement,
+            operatingMode: operatingMode,
+            dataStreamManagement: dataStreamManagement,
         };
     }
     setupServiceHandlers() {
         // update the current configuration values to the current state.
-        this.recordingManagementService.setCharacteristic(Characteristic.SupportedCameraRecordingConfiguration, this.supportedCameraRecordingConfiguration);
-        this.recordingManagementService.setCharacteristic(Characteristic.SupportedVideoRecordingConfiguration, this.supportedVideoRecordingConfiguration);
-        this.recordingManagementService.setCharacteristic(Characteristic.SupportedAudioRecordingConfiguration, this.supportedAudioRecordingConfiguration);
-        this.recordingManagementService.getCharacteristic(Characteristic.SelectedCameraRecordingConfiguration)
+        this.recordingManagementService.setCharacteristic(Characteristic_1.Characteristic.SupportedCameraRecordingConfiguration, this.supportedCameraRecordingConfiguration);
+        this.recordingManagementService.setCharacteristic(Characteristic_1.Characteristic.SupportedVideoRecordingConfiguration, this.supportedVideoRecordingConfiguration);
+        this.recordingManagementService.setCharacteristic(Characteristic_1.Characteristic.SupportedAudioRecordingConfiguration, this.supportedAudioRecordingConfiguration);
+        this.recordingManagementService.getCharacteristic(Characteristic_1.Characteristic.SelectedCameraRecordingConfiguration)
             .onGet(this.handleSelectedCameraRecordingConfigurationRead.bind(this))
             .onSet(this.handleSelectedCameraRecordingConfigurationWrite.bind(this))
             .setProps({ adminOnlyAccess: [1 /* Access.WRITE */] });
-        this.recordingManagementService.getCharacteristic(Characteristic.Active)
-            .onSet((value) => {
+        this.recordingManagementService.getCharacteristic(Characteristic_1.Characteristic.Active)
+            .onSet(value => {
             if (!!value === this.recordingActive) {
                 return; // skip delegate call if state didn't change!
             }
@@ -231,12 +218,12 @@ export class RecordingManagement {
         })
             .on("change" /* CharacteristicEventTypes.CHANGE */, () => this.stateChangeDelegate?.())
             .setProps({ adminOnlyAccess: [1 /* Access.WRITE */] });
-        this.recordingManagementService.getCharacteristic(Characteristic.RecordingAudioActive)
+        this.recordingManagementService.getCharacteristic(Characteristic_1.Characteristic.RecordingAudioActive)
             .on("change" /* CharacteristicEventTypes.CHANGE */, () => this.stateChangeDelegate?.());
-        this.operatingModeService.getCharacteristic(Characteristic.HomeKitCameraActive)
-            .on("change" /* CharacteristicEventTypes.CHANGE */, (change) => {
+        this.operatingModeService.getCharacteristic(Characteristic_1.Characteristic.HomeKitCameraActive)
+            .on("change" /* CharacteristicEventTypes.CHANGE */, change => {
             for (const service of this.sensorServices) {
-                service.setCharacteristic(Characteristic.StatusActive, !!change.newValue);
+                service.setCharacteristic(Characteristic_1.Characteristic.StatusActive, !!change.newValue);
             }
             if (!change.newValue && this.recordingStream) {
                 this.recordingStream.close(1 /* HDSProtocolSpecificErrorReason.NOT_ALLOWED */);
@@ -244,70 +231,71 @@ export class RecordingManagement {
             this.stateChangeDelegate?.();
         })
             .setProps({ adminOnlyAccess: [1 /* Access.WRITE */] });
-        this.operatingModeService.getCharacteristic(Characteristic.EventSnapshotsActive)
+        this.operatingModeService.getCharacteristic(Characteristic_1.Characteristic.EventSnapshotsActive)
             .on("change" /* CharacteristicEventTypes.CHANGE */, () => this.stateChangeDelegate?.())
             .setProps({ adminOnlyAccess: [1 /* Access.WRITE */] });
-        this.operatingModeService.getCharacteristic(Characteristic.PeriodicSnapshotsActive)
+        this.operatingModeService.getCharacteristic(Characteristic_1.Characteristic.PeriodicSnapshotsActive)
             .on("change" /* CharacteristicEventTypes.CHANGE */, () => this.stateChangeDelegate?.())
             .setProps({ adminOnlyAccess: [1 /* Access.WRITE */] });
         this.dataStreamManagement
             .onRequestMessage("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, this.handleDataSendOpen.bind(this));
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handleDataSendOpen(connection, id, message) {
         // for message fields see https://github.com/Supereg/secure-video-specification#41-start
         const streamId = message.streamId;
         const type = message.type;
         const target = message.target;
         const reason = message.reason;
-        if (target !== 'controller' || type !== 'ipcamera.recording') {
-            debug('[HDS %s] Received data send with unexpected target: %s or type: %d. Rejecting...', connection.remoteAddress, target, type);
-            connection.sendResponse("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, id, HDSStatus.PROTOCOL_SPECIFIC_ERROR, {
+        if (target !== "controller" || type !== "ipcamera.recording") {
+            debug("[HDS %s] Received data send with unexpected target: %s or type: %d. Rejecting...", connection.remoteAddress, target, type);
+            connection.sendResponse("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, id, datastream_1.HDSStatus.PROTOCOL_SPECIFIC_ERROR, {
                 status: 5 /* HDSProtocolSpecificErrorReason.UNEXPECTED_FAILURE */,
             });
             return;
         }
         if (!this.recordingActive) {
-            connection.sendResponse("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, id, HDSStatus.PROTOCOL_SPECIFIC_ERROR, {
+            connection.sendResponse("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, id, datastream_1.HDSStatus.PROTOCOL_SPECIFIC_ERROR, {
                 status: 1 /* HDSProtocolSpecificErrorReason.NOT_ALLOWED */,
             });
             return;
         }
-        if (!this.operatingModeService.getCharacteristic(Characteristic.HomeKitCameraActive).value) {
-            connection.sendResponse("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, id, HDSStatus.PROTOCOL_SPECIFIC_ERROR, {
+        if (!this.operatingModeService.getCharacteristic(Characteristic_1.Characteristic.HomeKitCameraActive).value) {
+            connection.sendResponse("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, id, datastream_1.HDSStatus.PROTOCOL_SPECIFIC_ERROR, {
                 status: 1 /* HDSProtocolSpecificErrorReason.NOT_ALLOWED */,
             });
             return;
         }
         if (this.recordingStream) {
-            debug('[HDS %s] Rejecting DATA_SEND OPEN as another stream (%s) is already recording with streamId %d!', connection.remoteAddress, this.recordingStream.connection.remoteAddress, this.recordingStream.streamId);
+            debug("[HDS %s] Rejecting DATA_SEND OPEN as another stream (%s) is already recording with streamId %d!", connection.remoteAddress, this.recordingStream.connection.remoteAddress, this.recordingStream.streamId);
             // there is already a recording stream running.
-            connection.sendResponse("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, id, HDSStatus.PROTOCOL_SPECIFIC_ERROR, {
+            connection.sendResponse("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, id, datastream_1.HDSStatus.PROTOCOL_SPECIFIC_ERROR, {
                 status: 2 /* HDSProtocolSpecificErrorReason.BUSY */,
             });
             return;
         }
         if (!this.selectedConfiguration) {
-            connection.sendResponse("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, id, HDSStatus.PROTOCOL_SPECIFIC_ERROR, {
+            connection.sendResponse("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, id, datastream_1.HDSStatus.PROTOCOL_SPECIFIC_ERROR, {
                 status: 9 /* HDSProtocolSpecificErrorReason.INVALID_CONFIGURATION */,
             });
             return;
         }
-        debug('[HDS %s] HDS DATA_SEND Open with reason \'%s\'.', connection.remoteAddress, reason);
-        // eslint-disable-next-line ts/no-use-before-define
+        debug("[HDS %s] HDS DATA_SEND Open with reason '%s'.", connection.remoteAddress, reason);
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
         this.recordingStream = new CameraRecordingStream(connection, this.delegate, id, streamId);
-        // eslint-disable-next-line ts/no-use-before-define
         this.recordingStream.on("closed" /* CameraRecordingStreamEvents.CLOSED */, () => {
-            debug('[HDS %s] Removing active recoding session from recording management!', connection.remoteAddress);
+            debug("[HDS %s] Removing active recoding session from recording management!", connection.remoteAddress);
             this.recordingStream = undefined;
         });
         this.recordingStream.startStreaming();
     }
     handleSelectedCameraRecordingConfigurationRead() {
         if (!this.selectedConfiguration) {
-            throw new HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+            throw new hapStatusError_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
         }
         return this.selectedConfiguration.base64;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handleSelectedCameraRecordingConfigurationWrite(value) {
         const configuration = this.parseSelectedConfiguration(value);
         const changed = this.selectedConfiguration?.base64 !== value;
@@ -322,19 +310,19 @@ export class RecordingManagement {
         }
     }
     parseSelectedConfiguration(value) {
-        const decoded = decode(Buffer.from(value, 'base64'));
-        const recording = decode(decoded[1 /* SelectedCameraRecordingConfigurationTypes.SELECTED_RECORDING_CONFIGURATION */]);
-        const video = decode(decoded[2 /* SelectedCameraRecordingConfigurationTypes.SELECTED_VIDEO_CONFIGURATION */]);
-        const audio = decode(decoded[3 /* SelectedCameraRecordingConfigurationTypes.SELECTED_AUDIO_CONFIGURATION */]);
+        const decoded = tlv.decode(Buffer.from(value, "base64"));
+        const recording = tlv.decode(decoded[1 /* SelectedCameraRecordingConfigurationTypes.SELECTED_RECORDING_CONFIGURATION */]);
+        const video = tlv.decode(decoded[2 /* SelectedCameraRecordingConfigurationTypes.SELECTED_VIDEO_CONFIGURATION */]);
+        const audio = tlv.decode(decoded[3 /* SelectedCameraRecordingConfigurationTypes.SELECTED_AUDIO_CONFIGURATION */]);
         const prebufferLength = recording[1 /* SupportedCameraRecordingConfigurationTypes.PREBUFFER_LENGTH */].readInt32LE(0);
         let eventTriggerOptions = recording[2 /* SupportedCameraRecordingConfigurationTypes.EVENT_TRIGGER_OPTIONS */].readInt32LE(0);
-        const mediaContainerConfiguration = decode(recording[3 /* SupportedCameraRecordingConfigurationTypes.MEDIA_CONTAINER_CONFIGURATIONS */]);
+        const mediaContainerConfiguration = tlv.decode(recording[3 /* SupportedCameraRecordingConfigurationTypes.MEDIA_CONTAINER_CONFIGURATIONS */]);
         const containerType = mediaContainerConfiguration[1 /* MediaContainerConfigurationTypes.MEDIA_CONTAINER_TYPE */][0];
-        const mediaContainerParameters = decode(mediaContainerConfiguration[2 /* MediaContainerConfigurationTypes.MEDIA_CONTAINER_PARAMETERS */]);
+        const mediaContainerParameters = tlv.decode(mediaContainerConfiguration[2 /* MediaContainerConfigurationTypes.MEDIA_CONTAINER_PARAMETERS */]);
         const fragmentLength = mediaContainerParameters[1 /* MediaContainerParameterTypes.FRAGMENT_LENGTH */].readInt32LE(0);
         const videoCodec = video[1 /* VideoCodecConfigurationTypes.CODEC_TYPE */][0];
-        const videoParameters = decode(video[2 /* VideoCodecConfigurationTypes.CODEC_PARAMETERS */]);
-        const videoAttributes = decode(video[3 /* VideoCodecConfigurationTypes.ATTRIBUTES */]);
+        const videoParameters = tlv.decode(video[2 /* VideoCodecConfigurationTypes.CODEC_PARAMETERS */]);
+        const videoAttributes = tlv.decode(video[3 /* VideoCodecConfigurationTypes.ATTRIBUTES */]);
         const profile = videoParameters[1 /* VideoCodecParametersTypes.PROFILE_ID */][0];
         const level = videoParameters[2 /* VideoCodecParametersTypes.LEVEL */][0];
         const videoBitrate = videoParameters[3 /* VideoCodecParametersTypes.BITRATE */].readInt32LE(0);
@@ -343,22 +331,22 @@ export class RecordingManagement {
         const height = videoAttributes[2 /* VideoAttributesTypes.IMAGE_HEIGHT */].readInt16LE(0);
         const framerate = videoAttributes[3 /* VideoAttributesTypes.FRAME_RATE */][0];
         const audioCodec = audio[1 /* AudioCodecConfigurationTypes.CODEC_TYPE */][0];
-        const audioParameters = decode(audio[2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */]);
+        const audioParameters = tlv.decode(audio[2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */]);
         const audioChannels = audioParameters[1 /* AudioCodecParametersTypes.CHANNEL */][0];
         const samplerate = audioParameters[3 /* AudioCodecParametersTypes.SAMPLE_RATE */][0];
         const audioBitrateMode = audioParameters[2 /* AudioCodecParametersTypes.BIT_RATE */][0];
         const audioBitrate = audioParameters[4 /* AudioCodecParametersTypes.MAX_AUDIO_BITRATE */].readUInt32LE(0);
         const typedEventTriggers = [];
-        let bitIndex = 0;
+        let bit_index = 0;
         while (eventTriggerOptions > 0) {
-            if (eventTriggerOptions % 2 === 1) { // check if the lowest bit is set
-                typedEventTriggers.push(1 << bitIndex);
+            if (eventTriggerOptions & 0x01) { // of the lowest bit is set add the next event trigger option
+                typedEventTriggers.push(1 << bit_index);
             }
-            eventTriggerOptions = Math.floor(eventTriggerOptions / 2); // shift right by dividing by 2
-            bitIndex += 1;
+            eventTriggerOptions = eventTriggerOptions >> 1; // shift to right till we reach zero.
+            bit_index += 1; // count our current bit index
         }
         return {
-            prebufferLength,
+            prebufferLength: prebufferLength,
             eventTriggerTypes: typedEventTriggers,
             mediaContainerConfiguration: {
                 type: containerType,
@@ -367,10 +355,10 @@ export class RecordingManagement {
             videoCodec: {
                 type: videoCodec,
                 parameters: {
-                    profile,
-                    level,
+                    profile: profile,
+                    level: level,
                     bitRate: videoBitrate,
-                    iFrameInterval,
+                    iFrameInterval: iFrameInterval,
                 },
                 resolution: [width, height, framerate],
             },
@@ -391,23 +379,23 @@ export class RecordingManagement {
         const eventTriggerOptions = Buffer.alloc(8);
         prebufferLength.writeInt32LE(options.prebufferLength, 0);
         eventTriggerOptions.writeInt32LE(this.eventTriggerOptions, 0);
-        return encode(1 /* SupportedCameraRecordingConfigurationTypes.PREBUFFER_LENGTH */, prebufferLength, 2 /* SupportedCameraRecordingConfigurationTypes.EVENT_TRIGGER_OPTIONS */, eventTriggerOptions, 3 /* SupportedCameraRecordingConfigurationTypes.MEDIA_CONTAINER_CONFIGURATIONS */, mediaContainers.map((config) => {
+        return tlv.encode(1 /* SupportedCameraRecordingConfigurationTypes.PREBUFFER_LENGTH */, prebufferLength, 2 /* SupportedCameraRecordingConfigurationTypes.EVENT_TRIGGER_OPTIONS */, eventTriggerOptions, 3 /* SupportedCameraRecordingConfigurationTypes.MEDIA_CONTAINER_CONFIGURATIONS */, mediaContainers.map(config => {
             const fragmentLength = Buffer.alloc(4);
             fragmentLength.writeInt32LE(config.fragmentLength, 0);
-            return encode(1 /* MediaContainerConfigurationTypes.MEDIA_CONTAINER_TYPE */, config.type, 2 /* MediaContainerConfigurationTypes.MEDIA_CONTAINER_PARAMETERS */, encode(1 /* MediaContainerParameterTypes.FRAGMENT_LENGTH */, fragmentLength));
-        })).toString('base64');
+            return tlv.encode(1 /* MediaContainerConfigurationTypes.MEDIA_CONTAINER_TYPE */, config.type, 2 /* MediaContainerConfigurationTypes.MEDIA_CONTAINER_PARAMETERS */, tlv.encode(1 /* MediaContainerParameterTypes.FRAGMENT_LENGTH */, fragmentLength));
+        })).toString("base64");
     }
     _supportedVideoRecordingConfiguration(videoOptions) {
         if (!videoOptions.parameters) {
-            throw new Error('Video parameters cannot be undefined');
+            throw new Error("Video parameters cannot be undefined");
         }
         if (!videoOptions.resolutions) {
-            throw new Error('Video resolutions cannot be undefined');
+            throw new Error("Video resolutions cannot be undefined");
         }
-        const codecParameters = encode(1 /* VideoCodecParametersTypes.PROFILE_ID */, videoOptions.parameters.profiles, 2 /* VideoCodecParametersTypes.LEVEL */, videoOptions.parameters.levels);
-        const videoStreamConfiguration = encode(1 /* VideoCodecConfigurationTypes.CODEC_TYPE */, videoOptions.type, 2 /* VideoCodecConfigurationTypes.CODEC_PARAMETERS */, codecParameters, 3 /* VideoCodecConfigurationTypes.ATTRIBUTES */, videoOptions.resolutions.map((resolution) => {
+        const codecParameters = tlv.encode(1 /* VideoCodecParametersTypes.PROFILE_ID */, videoOptions.parameters.profiles, 2 /* VideoCodecParametersTypes.LEVEL */, videoOptions.parameters.levels);
+        const videoStreamConfiguration = tlv.encode(1 /* VideoCodecConfigurationTypes.CODEC_TYPE */, videoOptions.type, 2 /* VideoCodecConfigurationTypes.CODEC_PARAMETERS */, codecParameters, 3 /* VideoCodecConfigurationTypes.ATTRIBUTES */, videoOptions.resolutions.map(resolution => {
             if (resolution.length !== 3) {
-                throw new Error('Unexpected video resolution');
+                throw new Error("Unexpected video resolution");
             }
             const width = Buffer.alloc(2);
             const height = Buffer.alloc(2);
@@ -415,35 +403,35 @@ export class RecordingManagement {
             width.writeUInt16LE(resolution[0], 0);
             height.writeUInt16LE(resolution[1], 0);
             frameRate.writeUInt8(resolution[2], 0);
-            return encode(1 /* VideoAttributesTypes.IMAGE_WIDTH */, width, 2 /* VideoAttributesTypes.IMAGE_HEIGHT */, height, 3 /* VideoAttributesTypes.FRAME_RATE */, frameRate);
+            return tlv.encode(1 /* VideoAttributesTypes.IMAGE_WIDTH */, width, 2 /* VideoAttributesTypes.IMAGE_HEIGHT */, height, 3 /* VideoAttributesTypes.FRAME_RATE */, frameRate);
         }));
-        return encode(1 /* SupportedVideoRecordingConfigurationTypes.VIDEO_CODEC_CONFIGURATION */, videoStreamConfiguration).toString('base64');
+        return tlv.encode(1 /* SupportedVideoRecordingConfigurationTypes.VIDEO_CODEC_CONFIGURATION */, videoStreamConfiguration).toString("base64");
     }
     _supportedAudioStreamConfiguration(audioOptions) {
         const audioCodecs = Array.isArray(audioOptions.codecs)
             ? audioOptions.codecs
             : [audioOptions.codecs];
         if (audioCodecs.length === 0) {
-            throw new Error('CameraRecordingOptions.audio: At least one audio codec configuration must be specified!');
+            throw Error("CameraRecordingOptions.audio: At least one audio codec configuration must be specified!");
         }
-        const codecConfigurations = audioCodecs.map((codec) => {
+        const codecConfigurations = audioCodecs.map(codec => {
             const providedSamplerates = Array.isArray(codec.samplerate)
                 ? codec.samplerate
                 : [codec.samplerate];
             if (providedSamplerates.length === 0) {
-                throw new Error('CameraRecordingOptions.audio.codecs: Audio samplerate cannot be empty!');
+                throw new Error("CameraRecordingOptions.audio.codecs: Audio samplerate cannot be empty!");
             }
-            const audioParameters = encode(1 /* AudioCodecParametersTypes.CHANNEL */, Math.max(1, codec.audioChannels || 1), 2 /* AudioCodecParametersTypes.BIT_RATE */, codec.bitrateMode || 0 /* AudioBitrate.VARIABLE */, 3 /* AudioCodecParametersTypes.SAMPLE_RATE */, providedSamplerates);
-            return encode(1 /* AudioCodecConfigurationTypes.CODEC_TYPE */, codec.type, 2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */, audioParameters);
+            const audioParameters = tlv.encode(1 /* AudioCodecParametersTypes.CHANNEL */, Math.max(1, codec.audioChannels || 1), 2 /* AudioCodecParametersTypes.BIT_RATE */, codec.bitrateMode || 0 /* AudioBitrate.VARIABLE */, 3 /* AudioCodecParametersTypes.SAMPLE_RATE */, providedSamplerates);
+            return tlv.encode(1 /* AudioCodecConfigurationTypes.CODEC_TYPE */, codec.type, 2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */, audioParameters);
         });
-        return encode(1 /* SupportedAudioRecordingConfigurationTypes.AUDIO_CODEC_CONFIGURATION */, codecConfigurations).toString('base64');
+        return tlv.encode(1 /* SupportedAudioRecordingConfigurationTypes.AUDIO_CODEC_CONFIGURATION */, codecConfigurations).toString("base64");
     }
-    computeConfigurationHash(algorithm = 'sha256') {
-        const configurationHash = createHash(algorithm);
+    computeConfigurationHash(algorithm = "sha256") {
+        const configurationHash = crypto_1.default.createHash(algorithm);
         configurationHash.update(this.supportedCameraRecordingConfiguration);
         configurationHash.update(this.supportedVideoRecordingConfiguration);
         configurationHash.update(this.supportedAudioRecordingConfiguration);
-        return configurationHash.digest().toString('hex');
+        return configurationHash.digest().toString("hex");
     }
     /**
      * @private
@@ -451,15 +439,15 @@ export class RecordingManagement {
     serialize() {
         return {
             configurationHash: {
-                algorithm: 'sha256',
-                hash: this.computeConfigurationHash('sha256'),
+                algorithm: "sha256",
+                hash: this.computeConfigurationHash("sha256"),
             },
             selectedConfiguration: this.selectedConfiguration?.base64,
             recordingActive: this.recordingActive,
-            recordingAudioActive: !!this.recordingManagementService.getCharacteristic(Characteristic.RecordingAudioActive).value,
-            eventSnapshotsActive: !!this.operatingModeService.getCharacteristic(Characteristic.EventSnapshotsActive).value,
-            homeKitCameraActive: !!this.operatingModeService.getCharacteristic(Characteristic.HomeKitCameraActive).value,
-            periodicSnapshotsActive: !!this.operatingModeService.getCharacteristic(Characteristic.PeriodicSnapshotsActive).value,
+            recordingAudioActive: !!this.recordingManagementService.getCharacteristic(Characteristic_1.Characteristic.RecordingAudioActive).value,
+            eventSnapshotsActive: !!this.operatingModeService.getCharacteristic(Characteristic_1.Characteristic.EventSnapshotsActive).value,
+            homeKitCameraActive: !!this.operatingModeService.getCharacteristic(Characteristic_1.Characteristic.HomeKitCameraActive).value,
+            periodicSnapshotsActive: !!this.operatingModeService.getCharacteristic(Characteristic_1.Characteristic.PeriodicSnapshotsActive).value,
         };
     }
     /**
@@ -481,13 +469,13 @@ export class RecordingManagement {
             }
         }
         this.recordingActive = serialized.recordingActive;
-        this.recordingManagementService.updateCharacteristic(Characteristic.Active, serialized.recordingActive);
-        this.recordingManagementService.updateCharacteristic(Characteristic.RecordingAudioActive, serialized.recordingAudioActive);
-        this.operatingModeService.updateCharacteristic(Characteristic.EventSnapshotsActive, serialized.eventSnapshotsActive);
-        this.operatingModeService.updateCharacteristic(Characteristic.PeriodicSnapshotsActive, serialized.periodicSnapshotsActive);
-        this.operatingModeService.updateCharacteristic(Characteristic.HomeKitCameraActive, serialized.homeKitCameraActive);
+        this.recordingManagementService.updateCharacteristic(Characteristic_1.Characteristic.Active, serialized.recordingActive);
+        this.recordingManagementService.updateCharacteristic(Characteristic_1.Characteristic.RecordingAudioActive, serialized.recordingAudioActive);
+        this.operatingModeService.updateCharacteristic(Characteristic_1.Characteristic.EventSnapshotsActive, serialized.eventSnapshotsActive);
+        this.operatingModeService.updateCharacteristic(Characteristic_1.Characteristic.PeriodicSnapshotsActive, serialized.periodicSnapshotsActive);
+        this.operatingModeService.updateCharacteristic(Characteristic_1.Characteristic.HomeKitCameraActive, serialized.homeKitCameraActive);
         for (const service of this.sensorServices) {
-            service.setCharacteristic(Characteristic.StatusActive, serialized.homeKitCameraActive);
+            service.setCharacteristic(Characteristic_1.Characteristic.StatusActive, serialized.homeKitCameraActive);
         }
         try {
             if (this.selectedConfiguration) {
@@ -498,7 +486,7 @@ export class RecordingManagement {
             }
         }
         catch (error) {
-            console.error(`Failed to properly initialize CameraRecordingDelegate from persistent storage: ${error.stack}`);
+            console.error("Failed to properly initialize CameraRecordingDelegate from persistent storage: " + error.stack);
         }
         if (changedState) {
             this.stateChangeDelegate?.();
@@ -515,13 +503,13 @@ export class RecordingManagement {
     }
     handleFactoryReset() {
         this.selectedConfiguration = undefined;
-        this.recordingManagementService.updateCharacteristic(Characteristic.Active, false);
-        this.recordingManagementService.updateCharacteristic(Characteristic.RecordingAudioActive, false);
-        this.operatingModeService.updateCharacteristic(Characteristic.EventSnapshotsActive, true);
-        this.operatingModeService.updateCharacteristic(Characteristic.PeriodicSnapshotsActive, true);
-        this.operatingModeService.updateCharacteristic(Characteristic.HomeKitCameraActive, true);
+        this.recordingManagementService.updateCharacteristic(Characteristic_1.Characteristic.Active, false);
+        this.recordingManagementService.updateCharacteristic(Characteristic_1.Characteristic.RecordingAudioActive, false);
+        this.operatingModeService.updateCharacteristic(Characteristic_1.Characteristic.EventSnapshotsActive, true);
+        this.operatingModeService.updateCharacteristic(Characteristic_1.Characteristic.PeriodicSnapshotsActive, true);
+        this.operatingModeService.updateCharacteristic(Characteristic_1.Characteristic.HomeKitCameraActive, true);
         for (const service of this.sensorServices) {
-            service.setCharacteristic(Characteristic.StatusActive, true);
+            service.setCharacteristic(Characteristic_1.Characteristic.StatusActive, true);
         }
         try {
             // notifying the delegate about the updated state
@@ -529,14 +517,14 @@ export class RecordingManagement {
             this.delegate.updateRecordingConfiguration(undefined);
         }
         catch (error) {
-            console.error(`CameraRecordingDelegate failed to update state after handleFactoryReset: ${error.stack}`);
+            console.error("CameraRecordingDelegate failed to update state after handleFactoryReset: " + error.stack);
         }
     }
 }
+exports.RecordingManagement = RecordingManagement;
 /**
  * @group Camera
  */
-// eslint-disable-next-line no-restricted-syntax
 var CameraRecordingStreamEvents;
 (function (CameraRecordingStreamEvents) {
     /**
@@ -552,8 +540,8 @@ var CameraRecordingStreamEvents;
  *
  * @group Camera
  */
-// eslint-disable-next-line ts/no-unsafe-declaration-merging
-class CameraRecordingStream extends EventEmitter {
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+class CameraRecordingStream extends events_1.EventEmitter {
     connection;
     delegate;
     hdsRequestId;
@@ -587,12 +575,13 @@ class CameraRecordingStream extends EventEmitter {
         this.connection.addProtocolHandler("dataSend" /* Protocols.DATA_SEND */, this);
     }
     startStreaming() {
+        // noinspection JSIgnoredPromiseFromCall
         this._startStreaming();
     }
     async _startStreaming() {
-        debug('[HDS %s] Sending DATA_SEND OPEN response for streamId %d', this.connection.remoteAddress, this.streamId);
-        this.connection.sendResponse("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, this.hdsRequestId, HDSStatus.SUCCESS, {
-            status: HDSStatus.SUCCESS,
+        debug("[HDS %s] Sending DATA_SEND OPEN response for streamId %d", this.connection.remoteAddress, this.streamId);
+        this.connection.sendResponse("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, this.hdsRequestId, datastream_1.HDSStatus.SUCCESS, {
+            status: datastream_1.HDSStatus.SUCCESS,
         });
         // 256 KiB (1KiB to 900 KiB)
         const maxChunk = 0x40000;
@@ -619,24 +608,24 @@ class CameraRecordingStream extends EventEmitter {
                     if (this.closed) {
                         break;
                     }
-                    const data = fragment.subarray(offset, offset + maxChunk);
+                    const data = fragment.slice(offset, offset + maxChunk);
                     offset += data.length;
                     // see https://github.com/Supereg/secure-video-specification#42-binary-data
                     const event = {
                         streamId: this.streamId,
                         packets: [{
-                                data,
+                                data: data,
                                 metadata: {
                                     dataType: initialization ? "mediaInitialization" /* PacketDataType.MEDIA_INITIALIZATION */ : "mediaFragment" /* PacketDataType.MEDIA_FRAGMENT */,
-                                    dataSequenceNumber,
-                                    dataChunkSequenceNumber,
+                                    dataSequenceNumber: dataSequenceNumber,
+                                    dataChunkSequenceNumber: dataChunkSequenceNumber,
                                     isLastDataChunk: offset >= fragment.length,
                                     dataTotalSize: dataChunkSequenceNumber === 1 ? fragment.length : undefined,
                                 },
                             }],
                         endOfStream: offset >= fragment.length ? Boolean(packet.isLast).valueOf() : undefined,
                     };
-                    debug('[HDS %s] Sending DATA_SEND DATA for stream %d with metadata: %o and length %d; EoS: %s', this.connection.remoteAddress, this.streamId, event.packets[0].metadata, data.length, event.endOfStream);
+                    debug("[HDS %s] Sending DATA_SEND DATA for stream %d with metadata: %o and length %d; EoS: %s", this.connection.remoteAddress, this.streamId, event.packets[0].metadata, data.length, event.endOfStream);
                     this.connection.sendEvent("dataSend" /* Protocols.DATA_SEND */, "data" /* Topics.DATA */, event);
                     dataChunkSequenceNumber++;
                     initialization = false;
@@ -649,8 +638,8 @@ class CameraRecordingStream extends EventEmitter {
             }
             if (!lastFragmentWasMarkedLast && !this.closed) {
                 // Delegate violates the contract. Exited normally on a non-closed stream without properly setting `isLast`.
-                console.warn(`[HDS ${this.connection.remoteAddress}] Delegate finished streaming for ${this.streamId} without setting RecordingPacket.isLast. `
-                    + 'Can\'t notify Controller about endOfStream!');
+                console.warn(`[HDS ${this.connection.remoteAddress}] Delegate finished streaming for ${this.streamId} without setting RecordingPacket.isLast. ` +
+                    "Can't notify Controller about endOfStream!");
             }
         }
         catch (error) {
@@ -659,13 +648,13 @@ class CameraRecordingStream extends EventEmitter {
             }
             else {
                 let closeReason = 5 /* HDSProtocolSpecificErrorReason.UNEXPECTED_FAILURE */;
-                if (error instanceof HDSProtocolError) {
+                if (error instanceof datastream_1.HDSProtocolError) {
                     closeReason = error.reason;
-                    debug('[HDS %s] Delegate signaled to close the recording stream %d.', this.connection.remoteAddress, this.streamId);
+                    debug("[HDS %s] Delegate signaled to close the recording stream %d.", this.connection.remoteAddress, this.streamId);
                 }
-                else if (error instanceof HDSConnectionError && error.type === 2 /* HDSConnectionErrorType.CLOSED_SOCKET */) {
+                else if (error instanceof datastream_1.HDSConnectionError && error.type === 2 /* HDSConnectionErrorType.CLOSED_SOCKET */) {
                     // we are probably on a shutdown or just late. Connection is dead. End the stream!
-                    debug('[HDS %s] Exited recording stream due to closed HDS socket: stream id %d.', this.connection.remoteAddress, this.streamId);
+                    debug("[HDS %s] Exited recording stream due to closed HDS socket: stream id %d.", this.connection.remoteAddress, this.streamId);
                     return; // execute finally and then exit (we want to skip the `sendEvent` below)
                 }
                 else {
@@ -688,17 +677,19 @@ class CameraRecordingStream extends EventEmitter {
                 this.kickOffCloseTimeout();
             }
         }
-        debug('[HDS %s] Finished DATA_SEND transmission for stream %d!', this.connection.remoteAddress, this.streamId);
+        debug("[HDS %s] Finished DATA_SEND transmission for stream %d!", this.connection.remoteAddress, this.streamId);
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handleDataSendAck(message) {
         const streamId = message.streamId;
         const endOfStream = message.endOfStream;
         // The HomeKit Controller will send a DATA_SEND ACK if we set the `endOfStream` flag in the last packet
         // of our DATA_SEND DATA packet.
         // To my testing the session is then considered complete and the HomeKit controller will close the HDS Connection after 5 seconds.
-        debug('[HDS %s] Received DATA_SEND ACK packet for streamId %s. Acknowledged %s.', this.connection.remoteAddress, streamId, endOfStream);
+        debug("[HDS %s] Received DATA_SEND ACK packet for streamId %s. Acknowledged %s.", this.connection.remoteAddress, streamId, endOfStream);
         this.handleClosed(() => this.delegate.acknowledgeStream?.(this.streamId));
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handleDataSendClose(message) {
         // see https://github.com/Supereg/secure-video-specification#43-close
         const streamId = message.streamId;
@@ -706,13 +697,13 @@ class CameraRecordingStream extends EventEmitter {
         if (streamId !== this.streamId) {
             return;
         }
-        debug('[HDS %s] Received DATA_SEND CLOSE for streamId %d with reason %s', 
-        // @ts-expect-error - using string to access enum value
-        this.connection.remoteAddress, streamId, HDSProtocolSpecificErrorReasonConst[reason]);
+        debug("[HDS %s] Received DATA_SEND CLOSE for streamId %d with reason %s", 
+        // @ts-expect-error: forceConsistentCasingInFileNames compiler option
+        this.connection.remoteAddress, streamId, datastream_1.HDSProtocolSpecificErrorReason[reason]);
         this.handleClosed(() => this.delegate.closeRecordingStream(streamId, reason));
     }
     handleDataStreamConnectionClosed() {
-        debug('[HDS %s] The HDS connection of the stream %d closed.', this.connection.remoteAddress, this.streamId);
+        debug("[HDS %s] The HDS connection of the stream %d closed.", this.connection.remoteAddress, this.streamId);
         this.handleClosed(() => this.delegate.closeRecordingStream(this.streamId, undefined));
     }
     handleClosed(closure) {
@@ -727,8 +718,8 @@ class CameraRecordingStream extends EventEmitter {
             // when this variable is defined, the generator hasn't returned yet.
             // we start a timeout to uncover potential programming mistakes where we await forever and can't free resources.
             this.generatorTimeout = setTimeout(() => {
-                console.error('[HDS %s] Recording download stream %d is still awaiting generator although stream was closed 10s ago! '
-                    + 'This is a programming mistake by the camera implementation which prevents freeing up resources.', this.connection.remoteAddress, this.streamId);
+                console.error("[HDS %s] Recording download stream %d is still awaiting generator although stream was closed 10s ago! " +
+                    "This is a programming mistake by the camera implementation which prevents freeing up resources.", this.connection.remoteAddress, this.streamId);
             }, 10000);
         }
         try {
@@ -747,14 +738,14 @@ class CameraRecordingStream extends EventEmitter {
         if (this.closed) {
             return;
         }
-        debug('[HDS %s] Recording stream %d was closed manually with reason %s.', 
-        // @ts-expect-error - forceConsistentCasingInFileNames compiler option
-        this.connection.remoteAddress, this.streamId, reason ? HDSProtocolSpecificErrorReason[reason] : 'CLOSED');
+        debug("[HDS %s] Recording stream %d was closed manually with reason %s.", 
+        // @ts-expect-error: forceConsistentCasingInFileNames compiler option
+        this.connection.remoteAddress, this.streamId, reason ? datastream_1.HDSProtocolSpecificErrorReason[reason] : "CLOSED");
         // the `isConsideredClosed` check just ensures that the won't ever throw here and that `handledClosed` is always executed.
         if (!this.connection.isConsideredClosed()) {
             this.connection.sendEvent("dataSend" /* Protocols.DATA_SEND */, "close" /* Topics.CLOSE */, {
                 streamId: this.streamId,
-                reason,
+                reason: reason,
             });
         }
         this.handleClosed(() => this.delegate.closeRecordingStream(this.streamId, reason));
@@ -767,7 +758,7 @@ class CameraRecordingStream extends EventEmitter {
             if (this.closed) {
                 return;
             }
-            debug('[HDS %s] Recording stream %d took longer than expected to fully close. Force closing now!', this.connection.remoteAddress, this.streamId);
+            debug("[HDS %s] Recording stream %d took longer than expected to fully close. Force closing now!", this.connection.remoteAddress, this.streamId);
             this.close(3 /* HDSProtocolSpecificErrorReason.CANCELLED */);
         }, 12000);
     }