@bitpoolos/edge-bacnet 1.1.8 → 1.2.1

package/resources/node-bacstack-ts/dist/lib/services/cov-notify.js

@@ -0,0 +1,119 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const baEnum = require("../enum");
+const encode = (buffer, subscriberProcessId, initiatingDeviceId, monitoredObjectId, timeRemaining, values) => {
+    baAsn1.encodeContextUnsigned(buffer, 0, subscriberProcessId);
+    baAsn1.encodeContextObjectId(buffer, 1, baEnum.ObjectType.DEVICE, initiatingDeviceId);
+    baAsn1.encodeContextObjectId(buffer, 2, monitoredObjectId.type, monitoredObjectId.instance);
+    baAsn1.encodeContextUnsigned(buffer, 3, timeRemaining);
+    baAsn1.encodeOpeningTag(buffer, 4);
+    values.forEach((value) => {
+        baAsn1.encodeContextEnumerated(buffer, 0, value.property.id);
+        if (value.property.index === baEnum.ASN1_ARRAY_ALL) {
+            baAsn1.encodeContextUnsigned(buffer, 1, value.property.index);
+        }
+        baAsn1.encodeOpeningTag(buffer, 2);
+        value.value.forEach((v) => baAsn1.bacappEncodeApplicationData(buffer, v));
+        baAsn1.encodeClosingTag(buffer, 2);
+        if (value.priority === baEnum.ASN1_NO_PRIORITY) {
+            baAsn1.encodeContextUnsigned(buffer, 3, value.priority);
+        }
+        // TODO: Handle to too large telegrams -> APDU limit
+    });
+    baAsn1.encodeClosingTag(buffer, 4);
+};
+exports.encode = encode;
+const decode = (buffer, offset, apduLen) => {
+    let len = 0;
+    let result;
+    let decodedValue;
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 0))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    const subscriberProcessId = decodedValue.value;
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 1))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeObjectId(buffer, offset + len);
+    len += decodedValue.len;
+    const initiatingDeviceId = { type: decodedValue.objectType, instance: decodedValue.instance };
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 2))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeObjectId(buffer, offset + len);
+    len += decodedValue.len;
+    const monitoredObjectId = { type: decodedValue.objectType, instance: decodedValue.instance };
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 3))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    const timeRemaining = decodedValue.value;
+    if (!baAsn1.decodeIsOpeningTagNumber(buffer, offset + len, 4))
+        return;
+    len++;
+    const values = [];
+    while ((apduLen - len) > 1 && !baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 4)) {
+        const newEntry = {};
+        newEntry.property = {};
+        if (!baAsn1.decodeIsContextTag(buffer, offset + len, 0))
+            return;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        newEntry.property.id = decodedValue.value;
+        if (baAsn1.decodeIsContextTag(buffer, offset + len, 1)) {
+            result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+            len += result.len;
+            decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+            len += decodedValue.len;
+            newEntry.property.index = decodedValue.value;
+        }
+        else {
+            newEntry.property.index = baEnum.ASN1_ARRAY_ALL;
+        }
+        if (!baAsn1.decodeIsOpeningTagNumber(buffer, offset + len, 2))
+            return;
+        len++;
+        const properties = [];
+        while ((apduLen - len) > 1 && !baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 2)) {
+            decodedValue = baAsn1.bacappDecodeApplicationData(buffer, offset + len, apduLen + offset, monitoredObjectId.type, newEntry.property.id);
+            if (!decodedValue)
+                return;
+            len += decodedValue.len;
+            delete decodedValue.len;
+            properties.push(decodedValue);
+        }
+        newEntry.value = properties;
+        len++;
+        if (baAsn1.decodeIsContextTag(buffer, offset + len, 3)) {
+            result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+            len += result.len;
+            decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+            len += decodedValue.len;
+            newEntry.priority = decodedValue.value;
+        }
+        else {
+            newEntry.priority = baEnum.ASN1_NO_PRIORITY;
+        }
+        values.push(newEntry);
+    }
+    return {
+        len: len,
+        subscriberProcessId: subscriberProcessId,
+        initiatingDeviceId: initiatingDeviceId,
+        monitoredObjectId: monitoredObjectId,
+        timeRemaining: timeRemaining,
+        values: values
+    };
+};
+exports.decode = decode;

package/resources/node-bacstack-ts/dist/lib/services/create-object.js

@@ -0,0 +1,104 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeAcknowledge = exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const baEnum = require("../enum");
+const encode = (buffer, objectId, values) => {
+    baAsn1.encodeOpeningTag(buffer, 0);
+    baAsn1.encodeContextObjectId(buffer, 1, objectId.type, objectId.instance);
+    baAsn1.encodeClosingTag(buffer, 0);
+    baAsn1.encodeOpeningTag(buffer, 1);
+    values.forEach((propertyValue) => {
+        baAsn1.encodeContextEnumerated(buffer, 0, propertyValue.property.id);
+        if (propertyValue.property.index !== baEnum.ASN1_ARRAY_ALL) {
+            baAsn1.encodeContextUnsigned(buffer, 1, propertyValue.property.index);
+        }
+        baAsn1.encodeOpeningTag(buffer, 2);
+        propertyValue.value.forEach((value) => {
+            baAsn1.bacappEncodeApplicationData(buffer, value);
+        });
+        baAsn1.encodeClosingTag(buffer, 2);
+        if (propertyValue.priority !== baEnum.ASN1_NO_PRIORITY) {
+            baAsn1.encodeContextUnsigned(buffer, 3, propertyValue.priority);
+        }
+    });
+    baAsn1.encodeClosingTag(buffer, 1);
+};
+exports.encode = encode;
+const decode = (buffer, offset, apduLen) => {
+    let len = 0;
+    let result;
+    let decodedValue;
+    let objectId;
+    const valueList = [];
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    if ((result.tagNumber === 0) && (apduLen > len)) {
+        apduLen -= len;
+        if (apduLen < 4)
+            return;
+        decodedValue = baAsn1.decodeContextObjectId(buffer, offset + len, 1);
+        len += decodedValue.len;
+        objectId = { type: decodedValue.objectType, instance: decodedValue.instance };
+    }
+    else {
+        return;
+    }
+    if (baAsn1.decodeIsClosingTag(buffer, offset + len)) {
+        len++;
+    }
+    if (!baAsn1.decodeIsOpeningTagNumber(buffer, offset + len, 1))
+        return;
+    len++;
+    while ((apduLen - len) > 1) {
+        const newEntry = {};
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber !== 0)
+            return;
+        decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        const propertyId = decodedValue.value;
+        let arraIndex = baEnum.ASN1_ARRAY_ALL;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        if (result.tagNumber === 1) {
+            decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+            len += decodedValue.len;
+            arraIndex += decodedValue.value;
+            result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+            len += result.len;
+        }
+        newEntry.property = { id: propertyId, index: arraIndex };
+        if ((result.tagNumber === 2) && (baAsn1.decodeIsOpeningTag(buffer, offset + len - 1))) {
+            const values = [];
+            while (!baAsn1.decodeIsClosingTag(buffer, offset + len)) {
+                decodedValue = baAsn1.bacappDecodeApplicationData(buffer, offset + len, apduLen + offset, objectId.type, propertyId);
+                if (!decodedValue)
+                    return;
+                len += decodedValue.len;
+                delete decodedValue.len;
+                values.push(decodedValue);
+            }
+            len++;
+            newEntry.value = values;
+        }
+        else {
+            return;
+        }
+        valueList.push(newEntry);
+    }
+    if (!baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 1))
+        return;
+    len++;
+    return {
+        len: len,
+        objectId: objectId,
+        values: valueList
+    };
+};
+exports.decode = decode;
+const encodeAcknowledge = (buffer, objectId) => {
+    baAsn1.encodeApplicationObjectId(buffer, objectId.type, objectId.instance);
+};
+exports.encodeAcknowledge = encodeAcknowledge;

package/resources/node-bacstack-ts/dist/lib/services/delete-object.js

@@ -0,0 +1,21 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const encode = (buffer, objectId) => {
+    baAsn1.encodeApplicationObjectId(buffer, objectId.type, objectId.instance);
+};
+exports.encode = encode;
+const decode = (buffer, offset, apduLen) => {
+    const result = baAsn1.decodeTagNumberAndValue(buffer, offset);
+    if (result.tagNumber !== 12)
+        return;
+    let len = 1;
+    const value = baAsn1.decodeObjectId(buffer, offset + len);
+    len += value.len;
+    if (len !== apduLen)
+        return;
+    value.len = len;
+    return value;
+};
+exports.decode = decode;

package/resources/node-bacstack-ts/dist/lib/services/device-communication-control.js

@@ -0,0 +1,46 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const encode = (buffer, timeDuration, enableDisable, password) => {
+    if (timeDuration > 0) {
+        baAsn1.encodeContextUnsigned(buffer, 0, timeDuration);
+    }
+    baAsn1.encodeContextEnumerated(buffer, 1, enableDisable);
+    if (password && password !== '') {
+        baAsn1.encodeContextCharacterString(buffer, 2, password);
+    }
+};
+exports.encode = encode;
+const decode = (buffer, offset, apduLen) => {
+    let len = 0;
+    const value = {};
+    let decodedValue;
+    let result;
+    if (baAsn1.decodeIsContextTag(buffer, offset + len, 0)) {
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+        value.timeDuration = decodedValue.value;
+        len += decodedValue.len;
+    }
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 1))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+    value.enableDisable = decodedValue.value;
+    len += decodedValue.len;
+    if (len < apduLen) {
+        if (!baAsn1.decodeIsContextTag(buffer, offset + len, 2))
+            return;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        decodedValue = baAsn1.decodeCharacterString(buffer, offset + len, apduLen - (offset + len), result.value);
+        value.password = decodedValue.value;
+        len += decodedValue.len;
+    }
+    value.len = len;
+    return value;
+};
+exports.decode = decode;

package/resources/node-bacstack-ts/dist/lib/services/error.js

@@ -0,0 +1,27 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const encode = (buffer, errorClass, errorCode) => {
+    baAsn1.encodeApplicationEnumerated(buffer, errorClass);
+    baAsn1.encodeApplicationEnumerated(buffer, errorCode);
+};
+exports.encode = encode;
+const decode = (buffer, offset) => {
+    const orgOffset = offset;
+    let result;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset);
+    offset += result.len;
+    const errorClass = baAsn1.decodeEnumerated(buffer, offset, result.value);
+    offset += errorClass.len;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset);
+    offset += result.len;
+    const errorCode = baAsn1.decodeEnumerated(buffer, offset, result.value);
+    offset += errorClass.len;
+    return {
+        len: offset - orgOffset,
+        class: errorClass.value,
+        code: errorCode.value
+    };
+};
+exports.decode = decode;

package/resources/node-bacstack-ts/dist/lib/services/event-information.js

@@ -0,0 +1,100 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const baEnum = require("../enum");
+const encode = (buffer, events, moreEvents) => {
+    baAsn1.encodeOpeningTag(buffer, 0);
+    events.forEach((event) => {
+        baAsn1.encodeContextObjectId(buffer, 0, event.objectId.type, event.objectId.instance);
+        baAsn1.encodeContextEnumerated(buffer, 1, event.eventState);
+        baAsn1.encodeContextBitstring(buffer, 2, event.acknowledgedTransitions);
+        baAsn1.encodeOpeningTag(buffer, 3);
+        for (let i = 0; i < 3; i++) {
+            baAsn1.encodeApplicationDate(buffer, event.eventTimeStamps[i]);
+            baAsn1.encodeApplicationTime(buffer, event.eventTimeStamps[i]);
+        }
+        baAsn1.encodeClosingTag(buffer, 3);
+        baAsn1.encodeContextEnumerated(buffer, 4, event.notifyType);
+        baAsn1.encodeContextBitstring(buffer, 5, event.eventEnable);
+        baAsn1.encodeOpeningTag(buffer, 6);
+        for (let i = 0; i < 3; i++) {
+            baAsn1.encodeApplicationUnsigned(buffer, event.eventPriorities[i]);
+        }
+        baAsn1.encodeClosingTag(buffer, 6);
+    });
+    baAsn1.encodeClosingTag(buffer, 0);
+    baAsn1.encodeContextBoolean(buffer, 1, moreEvents);
+};
+exports.encode = encode;
+const decode = (buffer, offset, apduLen) => {
+    let len = 0;
+    let result;
+    let decodedValue;
+    len++;
+    const alarms = [];
+    while ((apduLen - 3 - len) > 0) {
+        const value = {};
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        decodedValue = baAsn1.decodeObjectId(buffer, offset + len);
+        len += decodedValue.len;
+        value.objectId = { type: decodedValue.objectType, instance: decodedValue.instance };
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        value.eventState = decodedValue.value;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        decodedValue = baAsn1.decodeBitstring(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        value.acknowledgedTransitions = decodedValue.value;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        value.eventTimeStamps = [];
+        for (let i = 0; i < 3; i++) {
+            if (result.tagNumber !== baEnum.ApplicationTags.NULL) {
+                decodedValue = baAsn1.decodeApplicationDate(buffer, offset + len);
+                len += decodedValue.len;
+                const date = decodedValue.value;
+                decodedValue = baAsn1.decodeApplicationTime(buffer, offset + len);
+                len += decodedValue.len;
+                const time = decodedValue.value;
+                value.eventTimeStamps[i] = new Date(date.getFullYear(), date.getMonth(), date.getDate(), time.getHours(), time.getMinutes(), time.getSeconds(), time.getMilliseconds());
+            }
+            else {
+                len += result.value;
+            }
+        }
+        len++;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        value.notifyType = decodedValue.value;
+        result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+        len += result.len;
+        decodedValue = baAsn1.decodeBitstring(buffer, offset + len, result.value);
+        len += decodedValue.len;
+        value.eventEnable = decodedValue.value;
+        len++;
+        value.eventPriorities = [];
+        for (let i = 0; i < 3; i++) {
+            result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+            len += result.len;
+            decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+            len += decodedValue.len;
+            value.eventPriorities[i] = decodedValue.value;
+        }
+        len++;
+        alarms.push(value);
+    }
+    const moreEvents = (buffer[apduLen - 1] === 1);
+    return {
+        len: len,
+        alarms: alarms,
+        moreEvents: moreEvents
+    };
+};
+exports.decode = decode;

package/resources/node-bacstack-ts/dist/lib/services/event-notify-data.js

@@ -0,0 +1,219 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = void 0;
+const baAsn1 = require("../asn1");
+const baEnum = require("../enum");
+const encode = (buffer, data) => {
+    baAsn1.encodeContextUnsigned(buffer, 0, data.processId);
+    baAsn1.encodeContextObjectId(buffer, 1, data.initiatingObjectId.type, data.initiatingObjectId.instance);
+    baAsn1.encodeContextObjectId(buffer, 2, data.eventObjectId.type, data.eventObjectId.instance);
+    baAsn1.bacappEncodeContextTimestamp(buffer, 3, data.timeStamp);
+    baAsn1.encodeContextUnsigned(buffer, 4, data.notificationClass);
+    baAsn1.encodeContextUnsigned(buffer, 5, data.priority);
+    baAsn1.encodeContextEnumerated(buffer, 6, data.eventType);
+    if (data.messageText && data.messageText !== '') {
+        baAsn1.encodeContextCharacterString(buffer, 7, data.messageText);
+    }
+    baAsn1.encodeContextEnumerated(buffer, 8, data.notifyType);
+    switch (data.notifyType) {
+        case baEnum.NotifyType.ALARM:
+        case baEnum.NotifyType.EVENT:
+            baAsn1.encodeContextBoolean(buffer, 9, data.ackRequired);
+            baAsn1.encodeContextEnumerated(buffer, 10, data.fromState);
+            break;
+        default:
+            break;
+    }
+    baAsn1.encodeContextEnumerated(buffer, 11, data.toState);
+    switch (data.notifyType) {
+        case baEnum.NotifyType.ALARM:
+        case baEnum.NotifyType.EVENT:
+            baAsn1.encodeOpeningTag(buffer, 12);
+            switch (data.eventType) {
+                case baEnum.EventType.CHANGE_OF_BITSTRING:
+                    baAsn1.encodeOpeningTag(buffer, 0);
+                    baAsn1.encodeContextBitstring(buffer, 0, data.changeOfBitstringReferencedBitString);
+                    baAsn1.encodeContextBitstring(buffer, 1, data.changeOfBitstringStatusFlags);
+                    baAsn1.encodeClosingTag(buffer, 0);
+                    break;
+                case baEnum.EventType.CHANGE_OF_STATE:
+                    baAsn1.encodeOpeningTag(buffer, 1);
+                    baAsn1.encodeOpeningTag(buffer, 0);
+                    baAsn1.bacappEncodePropertyState(buffer, data.changeOfStateNewState);
+                    baAsn1.encodeClosingTag(buffer, 0);
+                    baAsn1.encodeContextBitstring(buffer, 1, data.changeOfStateStatusFlags);
+                    baAsn1.encodeClosingTag(buffer, 1);
+                    break;
+                case baEnum.EventType.CHANGE_OF_VALUE:
+                    baAsn1.encodeOpeningTag(buffer, 2);
+                    baAsn1.encodeOpeningTag(buffer, 0);
+                    switch (data.changeOfValueTag) {
+                        case baEnum.CovTypes.REAL:
+                            baAsn1.encodeContextReal(buffer, 1, data.changeOfValueChangeValue);
+                            break;
+                        case baEnum.CovTypes.BIT_STRING:
+                            baAsn1.encodeContextBitstring(buffer, 0, data.changeOfValueChangedBits);
+                            break;
+                        default:
+                            throw new Error('NotImplemented');
+                    }
+                    baAsn1.encodeClosingTag(buffer, 0);
+                    baAsn1.encodeContextBitstring(buffer, 1, data.changeOfValueStatusFlags);
+                    baAsn1.encodeClosingTag(buffer, 2);
+                    break;
+                case baEnum.EventType.FLOATING_LIMIT:
+                    baAsn1.encodeOpeningTag(buffer, 4);
+                    baAsn1.encodeContextReal(buffer, 0, data.floatingLimitReferenceValue);
+                    baAsn1.encodeContextBitstring(buffer, 1, data.floatingLimitStatusFlags);
+                    baAsn1.encodeContextReal(buffer, 2, data.floatingLimitSetPointValue);
+                    baAsn1.encodeContextReal(buffer, 3, data.floatingLimitErrorLimit);
+                    baAsn1.encodeClosingTag(buffer, 4);
+                    break;
+                case baEnum.EventType.OUT_OF_RANGE:
+                    baAsn1.encodeOpeningTag(buffer, 5);
+                    baAsn1.encodeContextReal(buffer, 0, data.outOfRangeExceedingValue);
+                    baAsn1.encodeContextBitstring(buffer, 1, data.outOfRangeStatusFlags);
+                    baAsn1.encodeContextReal(buffer, 2, data.outOfRangeDeadband);
+                    baAsn1.encodeContextReal(buffer, 3, data.outOfRangeExceededLimit);
+                    baAsn1.encodeClosingTag(buffer, 5);
+                    break;
+                case baEnum.EventType.CHANGE_OF_LIFE_SAFETY:
+                    baAsn1.encodeOpeningTag(buffer, 8);
+                    baAsn1.encodeContextEnumerated(buffer, 0, data.changeOfLifeSafetyNewState);
+                    baAsn1.encodeContextEnumerated(buffer, 1, data.changeOfLifeSafetyNewMode);
+                    baAsn1.encodeContextBitstring(buffer, 2, data.changeOfLifeSafetyStatusFlags);
+                    baAsn1.encodeContextEnumerated(buffer, 3, data.changeOfLifeSafetyOperationExpected);
+                    baAsn1.encodeClosingTag(buffer, 8);
+                    break;
+                case baEnum.EventType.BUFFER_READY:
+                    baAsn1.encodeOpeningTag(buffer, 10);
+                    baAsn1.bacappEncodeContextDeviceObjPropertyRef(buffer, 0, data.bufferReadyBufferProperty);
+                    baAsn1.encodeContextUnsigned(buffer, 1, data.bufferReadyPreviousNotification);
+                    baAsn1.encodeContextUnsigned(buffer, 2, data.bufferReadyCurrentNotification);
+                    baAsn1.encodeClosingTag(buffer, 10);
+                    break;
+                case baEnum.EventType.UNSIGNED_RANGE:
+                    baAsn1.encodeOpeningTag(buffer, 11);
+                    baAsn1.encodeContextUnsigned(buffer, 0, data.unsignedRangeExceedingValue);
+                    baAsn1.encodeContextBitstring(buffer, 1, data.unsignedRangeStatusFlags);
+                    baAsn1.encodeContextUnsigned(buffer, 2, data.unsignedRangeExceededLimit);
+                    baAsn1.encodeClosingTag(buffer, 11);
+                    break;
+                case baEnum.EventType.EXTENDED:
+                case baEnum.EventType.COMMAND_FAILURE:
+                    throw new Error('NotImplemented');
+                default:
+                    throw new Error('NotImplemented');
+            }
+            baAsn1.encodeClosingTag(buffer, 12);
+            break;
+        case baEnum.NotifyType.ACK_NOTIFICATION:
+            throw new Error('NotImplemented');
+        default:
+            break;
+    }
+};
+exports.encode = encode;
+const decode = (buffer, offset) => {
+    let len = 0;
+    let result;
+    let decodedValue;
+    const eventData = {};
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 0))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    eventData.processId = decodedValue.value;
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 1))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeObjectId(buffer, offset + len);
+    len += decodedValue.len;
+    eventData.initiatingObjectId = { type: decodedValue.objectType, instance: decodedValue.instance };
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 2))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeObjectId(buffer, offset + len);
+    len += decodedValue.len;
+    eventData.eventObjectId = { type: decodedValue.objectType, instance: decodedValue.instance };
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 3))
+        return;
+    len += 2;
+    decodedValue = baAsn1.decodeApplicationDate(buffer, offset + len);
+    len += decodedValue.len;
+    const date = decodedValue.value;
+    decodedValue = baAsn1.decodeApplicationTime(buffer, offset + len);
+    len += decodedValue.len;
+    const time = decodedValue.value;
+    eventData.timeStamp = {};
+    eventData.timeStamp = new Date(date.getFullYear(), date.getMonth(), date.getDate(), time.getHours(), time.getMinutes(), time.getSeconds(), time.getMilliseconds());
+    len += 2;
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 4))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    eventData.notificationClass = decodedValue.value;
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 5))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    eventData.priority = decodedValue.value;
+    if (eventData.priority > 0xFF)
+        return;
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 6))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    eventData.eventType = decodedValue.value;
+    if (baAsn1.decodeIsContextTag(buffer, offset + len, 7)) {
+        decodedValue = baAsn1.decodeContextCharacterString(buffer, offset + len, 20000, 7);
+        len += decodedValue.len;
+        eventData.messageText = decodedValue.value;
+    }
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 8))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    eventData.notifyType = decodedValue.value;
+    switch (eventData.notifyType) {
+        case baEnum.NotifyType.ALARM:
+        case baEnum.NotifyType.EVENT:
+            result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+            len += result.len;
+            decodedValue = baAsn1.decodeUnsigned(buffer, offset + len, 1);
+            len += decodedValue.len;
+            eventData.ackRequired = (decodedValue.value > 0);
+            if (!baAsn1.decodeIsContextTag(buffer, offset + len, 10))
+                return;
+            result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+            len += result.len;
+            decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+            len += decodedValue.len;
+            eventData.fromState = decodedValue.value;
+            break;
+        default:
+            break;
+    }
+    if (!baAsn1.decodeIsContextTag(buffer, offset + len, 11))
+        return;
+    result = baAsn1.decodeTagNumberAndValue(buffer, offset + len);
+    len += result.len;
+    decodedValue = baAsn1.decodeEnumerated(buffer, offset + len, result.value);
+    len += decodedValue.len;
+    eventData.toState = decodedValue.value;
+    eventData.len = len;
+    return eventData;
+};
+exports.decode = decode;