node-opcua-address-space 2.55.0 → 2.58.0

package/src/alarms_and_conditions/ua_non_exclusive_limit_alarm_impl.ts

@@ -51,19 +51,19 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
 
         options.optionals = options.optionals || [];
 
-        if (Object.prototype.hasOwnProperty.call(options,"lowLowLimit")) {
+        if (Object.prototype.hasOwnProperty.call(options, "lowLowLimit")) {
             options.optionals.push("LowLowLimit");
             options.optionals.push("LowLowState");
         }
-        if (Object.prototype.hasOwnProperty.call(options,"lowLimit")) {
+        if (Object.prototype.hasOwnProperty.call(options, "lowLimit")) {
             options.optionals.push("LowLimit");
             options.optionals.push("LowState");
         }
-        if (Object.prototype.hasOwnProperty.call(options,"highLimit")) {
+        if (Object.prototype.hasOwnProperty.call(options, "highLimit")) {
             options.optionals.push("HighLimit");
             options.optionals.push("HighState");
         }
-        if (Object.prototype.hasOwnProperty.call(options,"highHighLimit")) {
+        if (Object.prototype.hasOwnProperty.call(options, "highHighLimit")) {
             options.optionals.push("HighHighLimit");
             options.optionals.push("HighHighState");
         }
@@ -93,7 +93,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
                 trueState: "LowLow active"
             });
             alarm.lowLowState.setValue(false);
-            assert(Object.prototype.hasOwnProperty.call(alarm,"lowLowLimit"));
+            assert(Object.prototype.hasOwnProperty.call(alarm, "lowLowLimit"));
         }
         if (alarm.lowState) {
             _install_TwoStateVariable_machinery(alarm.lowState, {
@@ -101,7 +101,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
                 trueState: "Low active"
             });
             alarm.lowState.setValue(false);
-            assert(Object.prototype.hasOwnProperty.call(alarm,"lowLimit"));
+            assert(Object.prototype.hasOwnProperty.call(alarm, "lowLimit"));
         }
         if (alarm.highState) {
             _install_TwoStateVariable_machinery(alarm.highState, {
@@ -109,7 +109,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
                 trueState: "High active"
             });
             alarm.highState.setValue(false);
-            assert(Object.prototype.hasOwnProperty.call(alarm,"highLimit"));
+            assert(Object.prototype.hasOwnProperty.call(alarm, "highLimit"));
         }
         if (alarm.highHighState) {
             _install_TwoStateVariable_machinery(alarm.highHighState, {
@@ -117,7 +117,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
                 trueState: "HighHigh active"
             });
             alarm.highHighState.setValue(false);
-            assert(Object.prototype.hasOwnProperty.call(alarm,"highHighLimit"));
+            assert(Object.prototype.hasOwnProperty.call(alarm, "highHighLimit"));
         }
 
         alarm.activeState.setValue(false);

package/src/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -30,12 +30,12 @@ export declare interface UAOffNormalAlarmEx
             | "suppressedState"
         >,
         UADiscreteAlarmEx {
-            getNormalStateNode(): UAVariable;
-         
-            getNormalStateValue(): any;
-           
-            setNormalStateValue(value: any): void;
-        }
+    getNormalStateNode(): UAVariable;
+
+    getNormalStateValue(): any;
+
+    setNormalStateValue(value: any): void;
+}
 
 export declare interface UAOffNormalAlarmImpl extends UAOffNormalAlarmEx, UADiscreteAlarmImpl {
     on(eventName: string, eventHandler: any): this;
@@ -65,11 +65,11 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
             throw new Error("cannot find offNormalAlarmType");
         }
 
-        assert(Object.prototype.hasOwnProperty.call(options,"inputNode"), "must provide inputNode"); // must provide a inputNode
-        assert(Object.prototype.hasOwnProperty.call(options,"normalState"), "must provide a normalState Node"); // must provide a inputNode
+        assert(Object.prototype.hasOwnProperty.call(options, "inputNode"), "must provide inputNode"); // must provide a inputNode
+        assert(Object.prototype.hasOwnProperty.call(options, "normalState"), "must provide a normalState Node"); // must provide a inputNode
         options.optionals = options.optionals || [];
 
-        assert(Object.prototype.hasOwnProperty.call(options,"inputNode"), "must provide inputNode"); // must provide a inputNode
+        assert(Object.prototype.hasOwnProperty.call(options, "inputNode"), "must provide inputNode"); // must provide a inputNode
         const alarmNode = UADiscreteAlarmImpl.instantiate(namespace, limitAlarmTypeId, options, data) as UAOffNormalAlarmImpl;
         Object.setPrototypeOf(alarmNode, UAOffNormalAlarmImpl.prototype);
 
@@ -139,7 +139,6 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
     }
 
     public _updateAlarmState(normalStateValue?: any, inputValue?: any): void {
-
         if (utils.isNullOrUndefined(normalStateValue) || utils.isNullOrUndefined(inputValue)) {
             this.activeState.setValue(false);
             return;

package/src/alarms_and_conditions/ua_system_off_normal_alarm_impl.ts

@@ -13,15 +13,13 @@ import { UAOffNormalAlarmImpl } from "./ua_off_normal_alarm_impl";
  * Subscription.
  *
  */
-export class UASystemOffNormalAlarmImpl extends  UAOffNormalAlarmImpl {
-
+export class UASystemOffNormalAlarmImpl extends UAOffNormalAlarmImpl {
     public static instantiate(
         namespace: INamespace,
         limitAlarmTypeId: string | NodeId,
         options: any,
         data: any
     ): UASystemOffNormalAlarmImpl {
-          return UAOffNormalAlarmImpl.instantiate(
-            namespace, limitAlarmTypeId, options, data) as UASystemOffNormalAlarmImpl;
+        return UAOffNormalAlarmImpl.instantiate(namespace, limitAlarmTypeId, options, data) as UASystemOffNormalAlarmImpl;
     }
 }

package/src/apply_condition_refresh.ts

@@ -3,7 +3,7 @@ import { UAConditionImpl } from "./alarms_and_conditions/ua_condition_impl";
 import { BaseNodeImpl } from "./base_node_impl";
 import { UAObjectImpl } from "./ua_object_impl";
 
-export type ConditionRefreshCache = {[key in string]: UAObject};
+export type ConditionRefreshCache = { [key in string]: UAObject };
 export function apply_condition_refresh(this: BaseNodeImpl, _cache?: ConditionRefreshCache): void {
     // visit all notifiers recursively
     _cache = _cache || {};
@@ -27,4 +27,4 @@ export function apply_condition_refresh(this: BaseNodeImpl, _cache?: ConditionRe
             }
         }
     }
-}
+}

package/src/base_node_impl.ts

@@ -1162,14 +1162,14 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         }
     }
 
-    public installPostInstallFunc(f: ()=>void): void {
+    public installPostInstallFunc(f: () => void): void {
         if (!f) {
             // nothing to do
             return;
         }
 
         function chain(f1: any, f2: any) {
-            return function chaiFunc(this: BaseNode, ... args: any[]) {
+            return function chaiFunc(this: BaseNode, ...args: any[]) {
                 if (f1) {
                     f1.apply(this, args);
                 }

package/src/data_access/add_dataItem_stuff.ts

@@ -41,11 +41,11 @@ interface add_dataItem_stuffOptions {
     valuePrecision?: number;
     modellingRule?: ModellingRuleType;
 }
-export function add_dataItem_stuff(variable: UAVariable, options: add_dataItem_stuffOptions) :void{
+export function add_dataItem_stuff(variable: UAVariable, options: add_dataItem_stuffOptions): void {
     const addressSpace = variable.addressSpace;
     const namespace = addressSpace.getNamespace(variable.nodeId.namespace);
 
-    if (Object.prototype.hasOwnProperty.call(options,"definition")) {
+    if (Object.prototype.hasOwnProperty.call(options, "definition")) {
         namespace.addVariable({
             browseName: { name: "Definition", namespaceIndex: 0 },
             dataType: "String",
@@ -58,7 +58,7 @@ export function add_dataItem_stuff(variable: UAVariable, options: add_dataItem_s
         });
     }
 
-    if (Object.prototype.hasOwnProperty.call(options,"valuePrecision")) {
+    if (Object.prototype.hasOwnProperty.call(options, "valuePrecision")) {
         assert(typeof options.valuePrecision === "number");
 
         namespace.addVariable({
@@ -72,4 +72,4 @@ export function add_dataItem_stuff(variable: UAVariable, options: add_dataItem_s
             value: new Variant({ dataType: DataType.Double, value: options.valuePrecision })
         });
     }
-}
+}

package/src/data_access/check_variant_compatibility_ua_analog_item.ts

@@ -16,24 +16,21 @@ function validate_value_range(range: Range, variant: Variant) {
     return true;
 }
 
-
 function checkVariantCompatibilityUAAnalogItem(this: UAVariableImpl, value: Variant): StatusCode {
-
-        assert(value instanceof Variant);
-        // test dataType
-        if (!this._validate_DataType(value.dataType)) {
-            return StatusCodes.BadTypeMismatch;
-        }
-        const analogItem = this as unknown as  UAAnalogItem<any, any>;
-        // AnalogDataItem
-        if (analogItem.instrumentRange) {
-            if (!validate_value_range(analogItem.instrumentRange.readValue().value.value as Range, value)) {
-                return StatusCodes.BadOutOfRange;
-            }
+    assert(value instanceof Variant);
+    // test dataType
+    if (!this._validate_DataType(value.dataType)) {
+        return StatusCodes.BadTypeMismatch;
+    }
+    const analogItem = this as unknown as UAAnalogItem<any, any>;
+    // AnalogDataItem
+    if (analogItem.instrumentRange) {
+        if (!validate_value_range(analogItem.instrumentRange.readValue().value.value as Range, value)) {
+            return StatusCodes.BadOutOfRange;
         }
-        return StatusCodes.Good;
     }
-
+    return StatusCodes.Good;
+}
 
 /**
  * extend default checkVariantCompatibility on base class with this one

package/src/data_access/ua_multistate_discrete_impl.ts

@@ -109,10 +109,13 @@ export function promoteToMultiStateDiscrete<T, DT extends DataType>(node: UAVari
 }
 registerNodePromoter(VariableTypeIds.MultiStateDiscreteType, promoteToMultiStateDiscrete);
 
-export function _addMultiStateDiscrete<T,DT extends DataType>(namespace: INamespace, options: AddMultiStateDiscreteOptions): UAMultiStateDiscreteImpl<T,DT> {
+export function _addMultiStateDiscrete<T, DT extends DataType>(
+    namespace: INamespace,
+    options: AddMultiStateDiscreteOptions
+): UAMultiStateDiscreteImpl<T, DT> {
     const addressSpace = namespace.addressSpace;
-    assert(Object.prototype.hasOwnProperty.call(options,"enumStrings"));
-    assert(!Object.prototype.hasOwnProperty.call(options,"ValuePrecision"));
+    assert(Object.prototype.hasOwnProperty.call(options, "enumStrings"));
+    assert(!Object.prototype.hasOwnProperty.call(options, "ValuePrecision"));
 
     const multiStateDiscreteType = addressSpace.findVariableType("MultiStateDiscreteType");
     if (!multiStateDiscreteType) {

package/src/data_access/ua_multistate_value_discrete.ts

@@ -167,7 +167,7 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
      *
      * @private
      */
-    public _post_initialize():void {
+    public _post_initialize(): void {
         // MultiStateValueDiscrete Variables can have any numeric Data Type;
         // this includes signed and unsigned integers from 8 to 64 Bit length.
 

package/src/event_data.ts

@@ -10,12 +10,7 @@ import { StatusCodes } from "node-opcua-status-code";
 import { SimpleAttributeOperand } from "node-opcua-types";
 import { DataType, Variant, VariantLike } from "node-opcua-variant";
 
-import {
-    ISessionContext,
-    BaseNode,
-    IEventData,
-    UAVariable
-} from "node-opcua-address-space-base";
+import { ISessionContext, BaseNode, IEventData, UAVariable } from "node-opcua-address-space-base";
 
 /**
  * @class EventData
@@ -23,7 +18,6 @@ import {
  * @constructor
  */
 export class EventData implements IEventData {
-
     public eventId: NodeId;
     public $eventDataSource: BaseNode;
 

package/src/extension_object_array_node.ts

@@ -11,13 +11,7 @@ import { DataType } from "node-opcua-variant";
 import { VariantArrayType } from "node-opcua-variant";
 
 import { ExtensionObject } from "node-opcua-extension-object";
-import {
-    UADataType,
-    UADynamicVariableArray,
-    UAObject,
-    UAReferenceType,
-    UAVariable
-} from "node-opcua-address-space-base"
+import { UADataType, UADynamicVariableArray, UAObject, UAReferenceType, UAVariable } from "node-opcua-address-space-base";
 import { UAVariableImpl } from "./ua_variable_impl";
 
 const doDebug = checkDebugFlag(__filename);
@@ -172,14 +166,14 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
     uaArrayVariableNode.$$extensionObjectArray = [];
     uaArrayVariableNode.$$indexPropertyName = indexPropertyName;
 
-    uaArrayVariableNode.$$getElementBrowseName = function (this: any, extObj: ExtensionObject) {
+    uaArrayVariableNode.$$getElementBrowseName = function (this: UADynamicVariableArray<T>, extObj: ExtensionObject) {
         const indexPropertyName1 = this.$$indexPropertyName;
 
-        if (!Object.prototype.hasOwnProperty.call(extObj,indexPropertyName1)) {
+        if (!Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1)) {
             console.log(" extension object do not have ", indexPropertyName1, extObj);
         }
         // assert(extObj.constructor === addressSpace.constructExtensionObject(dataType));
-        assert(Object.prototype.hasOwnProperty.call(extObj,indexPropertyName1));
+        assert(Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1));
         const browseName = (extObj as any)[indexPropertyName1].toString();
         return browseName;
     };

package/src/historical_access/address_space_historical_data_node.ts

@@ -25,11 +25,10 @@ import { CallbackT } from "node-opcua-status-code";
 import { DataType } from "node-opcua-variant";
 import {
     IAddressSpace,
-    ContinuationPoint,
-    ContinuationPointData,
     IVariableHistorian,
     IVariableHistorianOptions,
-    UAVariable
+    UAVariable,
+    ContinuationData
 } from "node-opcua-address-space-base";
 import { ISessionContext } from "node-opcua-address-space-base";
 
@@ -249,18 +248,13 @@ function _historyPush(this: UAVariableImpl, newDataValue: DataValue) {
     this.varHistorian.push(newDataValue);
 }
 
-function createContinuationPoint(): ContinuationPoint {
-    // todo: improve
-    return Buffer.from("ABCDEF");
-}
-
 function _historyReadModify(
     this: UAVariable,
     context: ISessionContext,
-    historyReadRawModifiedDetails: any,
+    historyReadRawModifiedDetails: ReadRawModifiedDetails,
     indexRange: NumericRange | null,
     dataEncoding: QualifiedNameLike | null,
-    continuationPoint: ContinuationPoint | null,
+    continuationData: ContinuationData,
     callback: CallbackT<HistoryReadResult>
 ) {
     //
@@ -338,7 +332,7 @@ function _historyReadRaw(
     historyReadRawModifiedDetails: ReadRawModifiedDetails,
     indexRange: NumericRange | null,
     dataEncoding: QualifiedNameLike | null,
-    continuationPoint: ContinuationPoint | null,
+    continuationData: ContinuationData,
     callback: CallbackT<HistoryReadResult>
 ): void {
     assert(historyReadRawModifiedDetails instanceof ReadRawModifiedDetails);
@@ -423,29 +417,20 @@ function _historyReadRaw(
     // If the requested TimestampsToReturn is not supported for a Node, the operation shall return
     // the Bad_TimestampNotSupported StatusCode.
 
-    if (continuationPoint) {
-        const cnt: ContinuationPointData | null = context.continuationPoints
-            ? context.continuationPoints[continuationPoint.toString("hex")]
-            : null;
-        if (!cnt) {
-            // invalid continuation point
-            const result1 = new HistoryReadResult({
-                historyData: new HistoryData({ dataValues: [] }),
-                statusCode: StatusCodes.BadContinuationPointInvalid
-            });
-            return callback(null, result1);
-        }
-        const dataValues = cnt.dataValues.splice(0, historyReadRawModifiedDetails.numValuesPerNode);
-        if (cnt.dataValues.length > 0) {
-            //
-        } else {
-            context.continuationPoints![continuationPoint.toString("hex")] = null;
-            continuationPoint = null;
-        }
+    const session = context.session;
+    if (!session) {
+        throw new Error("Internal Error: context.session not defined");
+    }
+    if (continuationData.continuationPoint) {
+        const cnt = session.continuationPointManager.getNextHistoryReadRaw(
+            historyReadRawModifiedDetails.numValuesPerNode,
+            continuationData
+        );
+        const { statusCode, values } = cnt;
         const result2 = new HistoryReadResult({
-            continuationPoint: continuationPoint || undefined,
-            historyData: new HistoryData({ dataValues }),
-            statusCode: StatusCodes.Good
+            continuationPoint: cnt.continuationPoint,
+            historyData: new HistoryData({ dataValues: values }),
+            statusCode
         });
         return callback(null, result2);
     }
@@ -493,6 +478,13 @@ function _historyReadRaw(
         }
     }
 
+    /*
+    const maxHistoryContinuationPoints = this.engine.serverCapabilities.maxHistoryContinuationPoints;
+    if (session.continuationPointManager.hasReachedMaximum(maxHistoryContinuationPoints)) {
+        return new HistoryReadResult({ statusCode: StatusCodes.BadNoContinuationPoints });
+    }
+    */
+
     (this as UAVariableImpl)._historyReadRawAsync(
         historyReadRawModifiedDetails,
         maxNumberToExtract,
@@ -503,31 +495,15 @@ function _historyReadRaw(
                 return callback(err);
             }
 
-            // now make sure that only the requested number of value is returned
-            if (historyReadRawModifiedDetails.numValuesPerNode >= 1) {
-                if (dataValues.length === 0) {
-                    const result1 = new HistoryReadResult({
-                        historyData: new HistoryData({ dataValues: [] }),
-                        statusCode: StatusCodes.GoodNoData
-                    });
-                    return callback(null, result1);
-                } else {
-                    const remaining = dataValues;
-                    dataValues = remaining.splice(0, historyReadRawModifiedDetails.numValuesPerNode);
-
-                    if (remaining.length > 0 && !isMinDate(historyReadRawModifiedDetails.endTime)) {
-                        continuationPoint = createContinuationPoint();
-                        context.continuationPoints = context.continuationPoints || {};
-                        context.continuationPoints[continuationPoint.toString("hex")] = {
-                            dataValues: remaining
-                        };
-                    }
-                }
-            }
+            const cnt = session.continuationPointManager.registerHistoryReadRaw(
+                historyReadRawModifiedDetails.numValuesPerNode,
+                dataValues,
+                continuationData
+            );
             const result = new HistoryReadResult({
-                continuationPoint: continuationPoint || undefined,
-                historyData: new HistoryData({ dataValues }),
-                statusCode: StatusCodes.Good
+                continuationPoint: cnt.continuationPoint,
+                historyData: new HistoryData({ dataValues: cnt.values }),
+                statusCode: cnt.statusCode
             });
             callback(null, result);
         }
@@ -540,7 +516,7 @@ function _historyReadRawModify(
     historyReadRawModifiedDetails: ReadRawModifiedDetails,
     indexRange: NumericRange | null,
     dataEncoding: QualifiedNameLike | null,
-    continuationPoint: ContinuationPoint | null,
+    continuationData: ContinuationData,
     callback: CallbackT<HistoryReadResult>
 ) {
     const node = this as UAVariableImpl;
@@ -548,14 +524,14 @@ function _historyReadRawModify(
     assert(historyReadRawModifiedDetails instanceof ReadRawModifiedDetails);
 
     if (!historyReadRawModifiedDetails.isReadModified) {
-        return node._historyReadRaw(context, historyReadRawModifiedDetails, indexRange, dataEncoding, continuationPoint, callback);
+        return node._historyReadRaw(context, historyReadRawModifiedDetails, indexRange, dataEncoding, continuationData, callback);
     } else {
         return node._historyReadModify(
             context,
             historyReadRawModifiedDetails,
             indexRange,
             dataEncoding,
-            continuationPoint,
+            continuationData,
             callback
         );
     }
@@ -567,13 +543,13 @@ function _historyRead(
     historyReadDetails: ReadRawModifiedDetails | ReadEventDetails | ReadProcessedDetails | ReadAtTimeDetails,
     indexRange: NumericRange | null,
     dataEncoding: QualifiedNameLike | null,
-    continuationPoint: ContinuationPoint | null,
+    continuationData: ContinuationData,
     callback: CallbackT<HistoryReadResult>
 ) {
     assert(callback instanceof Function);
     if (historyReadDetails instanceof ReadRawModifiedDetails) {
         // note: only ReadRawModifiedDetails supported at this time
-        return this._historyReadRawModify(context, historyReadDetails, indexRange, dataEncoding, continuationPoint, callback);
+        return this._historyReadRawModify(context, historyReadDetails, indexRange, dataEncoding, continuationData, callback);
     } else if (historyReadDetails instanceof ReadEventDetails) {
         // The ReadEventDetails structure is used to read the Events from the history database for the
         // specified time domain for one or more HistoricalEventNodes. The Events are filtered based on
@@ -634,7 +610,7 @@ function _historyRead(
                 historyReadDetails,
                 indexRange,
                 dataEncoding,
-                continuationPoint,
+                continuationData,
                 callback
             );
         }

package/src/namespace_impl.ts

@@ -194,7 +194,7 @@ function detachNode(node: BaseNode) {
  * @params options.publicationDate="" {Date}
  *
  */
-export class UANamespace implements NamespacePrivate {
+export class NamespaceImpl implements NamespacePrivate {
     public static _handle_hierarchy_parent = _handle_hierarchy_parent;
     public static isNonEmptyQualifiedName = isNonEmptyQualifiedName;
 
@@ -237,8 +237,8 @@ export class UANamespace implements NamespacePrivate {
         this._nodeIdManager = new NodeIdManager(this.index, this.addressSpace);
     }
 
-    public getDefaultNamespace(): UANamespace {
-        return this.index === 0 ? this : (this.addressSpace.getDefaultNamespace() as UANamespace);
+    public getDefaultNamespace(): NamespacePrivate {
+        return this.index === 0 ? this : (this.addressSpace.getDefaultNamespace());
     }
 
     public dispose(): void {
@@ -1814,7 +1814,7 @@ export class UANamespace implements NamespacePrivate {
         }
         const references: UAReference[] = [];
 
-        function process_subtypeOf_options(this: UANamespace, options2: any, references1: AddReferenceOpts[]) {
+        function process_subtypeOf_options(this: NamespaceImpl, options2: any, references1: AddReferenceOpts[]) {
             // check common misspelling mistake
             assert(!options2.subTypeOf, "misspell error : it should be 'subtypeOf' instead");
             if (Object.prototype.hasOwnProperty.call(options2, "hasTypeDefinition")) {
@@ -2067,7 +2067,7 @@ function _handle_event_hierarchy_parent(
     }
 }
 
-export function _handle_hierarchy_parent(addressSpace: AddressSpacePrivate, references: AddReferenceOpts[], options: any) {
+export function _handle_hierarchy_parent(addressSpace: AddressSpacePrivate, references: AddReferenceOpts[], options: any): void {
     options.componentOf = _coerce_parent(addressSpace, options.componentOf, addressSpace._coerceNode);
     options.propertyOf = _coerce_parent(addressSpace, options.propertyOf, addressSpace._coerceNode);
     options.organizedBy = _coerce_parent(addressSpace, options.organizedBy, addressSpace._coerceFolder);

package/src/namespace_private.ts

@@ -31,7 +31,7 @@ export interface NamespacePrivate extends INamespace {
     _deleteNode(node: BaseNode): void;
 
     internalCreateNode(options: CreateNodeOptions): BaseNode;
-    
+
     _dataTypeIterator(): IterableIterator<UADataType>;
 }
 

package/src/nodeid_manager.ts

@@ -65,7 +65,7 @@ export class NodeIdManager {
         this.addressSpace = addressSpace;
     }
 
-    public setCache(cache: NodeEntry[]) {
+    public setCache(cache: NodeEntry[]): void {
         this._cache = {};
         this._reverseCache = {};
         for (const [key, value, nodeClass] of cache) {
@@ -114,10 +114,7 @@ export class NodeIdManager {
     public constructNodeId(options: ConstructNodeIdOptions): NodeId {
         function prepareName(browseName: QualifiedName): string {
             assert(browseName instanceof QualifiedName);
-            const m = browseName
-                .name!.toString()
-                .replace(/[ ]/g, "")
-                .replace(/(<|>)/g, "");
+            const m = browseName.name!.toString().replace(/[ ]/g, "").replace(/(<|>)/g, "");
             return m;
         }
         let nodeId = options.nodeId;

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -51,7 +51,7 @@ import { UAReferenceTypeImpl } from "../ua_reference_type_impl";
 import { UAObjectTypeImpl } from "../ua_object_type_impl";
 import { UAVariableImpl } from "../ua_variable_impl";
 import { UAObjectImpl } from "../ua_object_impl";
-import { UANamespace } from "../namespace_impl";
+import { NamespaceImpl } from "../namespace_impl";
 import { UAMethodImpl } from "../ua_method_impl";
 import { UADataTypeImpl } from "../ua_data_type_impl";
 import { UAVariableTypeImpl } from "../ua_variable_type_impl";
@@ -697,15 +697,15 @@ function dumpCommonAttributes(xw: XmlWriter, node: BaseNode) {
     xw.writeAttribute("NodeId", n(xw, node.nodeId));
     xw.writeAttribute("BrowseName", b(xw, node.browseName));
 
-    if (Object.prototype.hasOwnProperty.call(node,"symbolicName")) {
+    if (Object.prototype.hasOwnProperty.call(node, "symbolicName")) {
         xw.writeAttribute("SymbolicName", (node as any).symbolicName);
     }
-    if (Object.prototype.hasOwnProperty.call(node,"isAbstract")) {
+    if (Object.prototype.hasOwnProperty.call(node, "isAbstract")) {
         if ((node as any).isAbstract) {
             xw.writeAttribute("IsAbstract", (node as any).isAbstract ? "true" : "false");
         }
     }
-    if (Object.prototype.hasOwnProperty.call(node,"accessLevel")) {
+    if (Object.prototype.hasOwnProperty.call(node, "accessLevel")) {
         // CurrentRead is by default
         if ((node as UAVariable).accessLevel !== currentReadFlag) {
             xw.writeAttribute("AccessLevel", (node as UAVariable).accessLevel.toString());
@@ -1199,7 +1199,7 @@ UADataTypeImpl.prototype.dumpXML = function (xw: XmlWriter) {
     dumpUADataType(xw, this);
 };
 
-UANamespace.prototype.toNodeset2XML = function (this: UANamespace) {
+NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
     const dependency = constructNamespaceDependency(this);
     const translationTable = constructNamespaceTranslationTable(dependency);
 

package/src/nodeset_tools/typedictionary_to_xml.ts

@@ -18,18 +18,18 @@ function dumpEnumeratedType(xw: XmlWriter, e: EnumDefinition, name: string): voi
     for (const f of e.fields || []) {
         xw.startElement("opc:EnumeratedValue");
         xw.writeAttribute("Name", f.name!);
-        assert(f.value[0] === 0, "unsuppor 64 bit value !");
+        assert(f.value[0] === 0, "unsupported 64 bit value !");
         xw.writeAttribute("Value", f.value[1].toString());
         xw.endElement();
     }
     xw.endElement();
 }
-function buildXmlName(addressSpace: AddressSpacePrivate, map: { [key: number]: string }, nodeId: NodeId) {
+function buildXmlName(addressSpace: AddressSpacePrivate, map: { [key: number]: string }, nodeId: NodeId): string {
     if (NodeId.sameNodeId(nodeId, NodeId.nullNodeId)) {
         return "ua:ExtensionObject";
     }
     const node = addressSpace.findNode(nodeId);
-    // istanbull ignore next
+    // istanbul ignore next
     if (!node) {
         throw new Error("Cannot find Node for" + nodeId?.toString());
     }
@@ -37,6 +37,8 @@ function buildXmlName(addressSpace: AddressSpacePrivate, map: { [key: number]: s
     const prefix = node.nodeId.namespace === 0 ? (node.nodeId.value <= 15 ? "opc" : "ua") : map[node.nodeId.namespace];
     return prefix + ":" + (typeName === "Structure" && prefix === "ua" ? "ExtensionObject" : typeName);
 }
+
+// eslint-disable-next-line max-statements
 function dumpDataTypeStructure(
     xw: XmlWriter,
     addressSpace: IAddressSpace,
@@ -44,7 +46,7 @@ function dumpDataTypeStructure(
     structureDefinition: StructureDefinition,
     name: string,
     doc?: string
-) {
+): void {
     xw.startElement("opc:StructuredType");
     xw.writeAttribute("Name", name);
     xw.writeAttribute("BaseType", buildXmlName(addressSpace as AddressSpacePrivate, map, structureDefinition.baseDataType));
@@ -134,7 +136,7 @@ function dumpDataTypeToBSD(xw: XmlWriter, dataType: UADataType, map: { [key: num
 function shortcut(namespace: INamespace) {
     return "n" + namespace.index;
 }
-export function dumpToBSD(namespace: NamespacePrivate) {
+export function dumpToBSD(namespace: NamespacePrivate): void {
     const dependency: INamespace[] = constructNamespaceDependency(namespace);
 
     const addressSpace = namespace.addressSpace;