node-opcua-address-space 2.178.0 → 2.180.0

package/src/extension_object_array_node.ts

@@ -2,9 +2,9 @@
  * @module node-opcua-address-space.Private
  */
 
-import type { UADataType, UADynamicVariableArray, UAObject, UAReferenceType, UAVariable } from "node-opcua-address-space-base";
+import type { BindVariableOptionsVariation1, UADynamicVariableArray, UAObject, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { BrowseDirection, NodeClass } from "node-opcua-data-model";
+import { BrowseDirection, NodeClass, type QualifiedName, type QualifiedNameLike } from "node-opcua-data-model";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
 import type { NodeId } from "node-opcua-nodeid";
@@ -52,7 +52,11 @@ function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UA
         throw new Error(" cannot find component ");
     }
 
-    const hasComponent = uaArrayVariableNode.addressSpace.findReferenceType("HasComponent")! as UAReferenceType;
+    const hasComponent = uaArrayVariableNode.addressSpace.findReferenceType("HasComponent");
+    // c8 ignore next
+    if (!hasComponent) {
+        throw new Error("cannot find HasComponent reference type: please check your nodeset file");
+    }
 
     // remove the hasComponent reference toward node
     uaArrayVariableNode.removeReference({
@@ -68,11 +72,22 @@ function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UA
     }
 }
 
+export interface CreateExtObjArrayNodeOptions {
+    browseName: QualifiedNameLike;
+    complexVariableType: string | NodeId;
+    variableType: string | NodeId;
+    indexPropertyName: string;
+    minimumSamplingInterval?: number;
+}
+
 /**
  *
  * create a node Variable that contains a array of ExtensionObject of a given type
  */
-export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: UAObject, options: any): UADynamicVariableArray<T> {
+export function createExtObjArrayNode<T extends ExtensionObject>(
+    parentFolder: UAObject,
+    options: CreateExtObjArrayNodeOptions
+): UADynamicVariableArray<T> {
     assert(typeof options.variableType === "string");
     assert(typeof options.indexPropertyName === "string");
 
@@ -93,7 +108,10 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
     assert(!variableType.nodeId.isEmpty());
 
     const structure = addressSpace.findDataType("Structure");
-    assert(structure, "Structure Type not found: please check your nodeset file");
+    // c8 ignore next
+    if (!structure) {
+        throw new Error("Structure Type not found: please check your nodeset file");
+    }
 
     const dataType = addressSpace.findDataType(variableType.dataType);
 
@@ -103,7 +121,7 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
         throw new Error("cannot find Data Type");
     }
 
-    assert(dataType.isSubtypeOf(structure as any), "expecting a structure (= ExtensionObject) here ");
+    assert(dataType.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
 
     const inner_options = {
         componentOf: parentFolder,
@@ -117,6 +135,10 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
 
     const uaArrayVariableNode = namespace.addVariable(inner_options) as UADynamicVariableArray<T>;
 
+    if (options.minimumSamplingInterval !== undefined) {
+        uaArrayVariableNode.minimumSamplingInterval = options.minimumSamplingInterval;
+    }
+
     bindExtObjArrayNode(uaArrayVariableNode, options.variableType, options.indexPropertyName);
 
     return uaArrayVariableNode;
@@ -134,7 +156,7 @@ function _getElementBrowseName<T extends ExtensionObject>(
     }
     // assert(extObj.constructor === addressSpace.constructExtensionObject(dataType));
     assert(Object.hasOwn(extObj, indexPropertyName1));
-    const browseName = (extObj as any)[indexPropertyName1].toString();
+    const browseName = (extObj as unknown as Record<string, { toString(): string }>)[indexPropertyName1].toString();
     return browseName;
 }
 
@@ -172,18 +194,25 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
     uaArrayVariableNode.$$variableType = variableType;
 
     // verify that an object with same doesn't already exist
-    dataType = addressSpace.findDataType(variableType.dataType)! as UADataType;
-    assert(dataType?.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
+    dataType = addressSpace.findDataType(variableType.dataType);
+    // c8 ignore next
+    if (!dataType) {
+        throw new Error(`Cannot find DataType ${variableType.dataType.toString()}`);
+    }
+    assert(dataType.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
     assert(!uaArrayVariableNode.$$extensionObjectArray, "UAVariable ExtensionObject array already bounded");
     uaArrayVariableNode.$$dataType = dataType;
     uaArrayVariableNode.$$extensionObjectArray = [];
     uaArrayVariableNode.$$indexPropertyName = indexPropertyName;
-    uaArrayVariableNode.$$getElementBrowseName = _getElementBrowseName;
+    // _getElementBrowseName actually returns a plain string (used opaquely via .toString() by every
+    // caller), while the base interface declares QualifiedName — cast to preserve exact prior runtime behavior.
+    uaArrayVariableNode.$$getElementBrowseName = _getElementBrowseName as unknown as (obj: T, index: number) => QualifiedName;
     uaArrayVariableNode.$dataValue.value.value = uaArrayVariableNode.$$extensionObjectArray;
     uaArrayVariableNode.$dataValue.value.arrayType = VariantArrayType.Array;
 
-    const bindOptions: any = {
-        get: getExtObjArrayNodeValue,
+    const bindOptions: BindVariableOptionsVariation1 = {
+        // getExtObjArrayNodeValue is generic over `this: UADynamicVariableArray<T>`, narrower than GetFunc's `this: UAVariable`
+        get: getExtObjArrayNodeValue as unknown as BindVariableOptionsVariation1["get"],
         set: undefined // readonly
     };
     // bind the readonly
@@ -217,7 +246,7 @@ export function addElement<T extends ExtensionObject>(
 
     let extensionObject: T;
     let elVar = null;
-    let browseName;
+    let browseName: QualifiedName;
 
     if (options instanceof UAVariableImpl) {
         elVar = options;
@@ -286,7 +315,7 @@ export function removeElement<T extends ExtensionObject>(
     } else if (element?.nodeClass) {
         // find element by name
         const browseNameToFind = element.browseName.name?.toString();
-        elementIndex = _array.findIndex((obj: any, _i: number) => {
+        elementIndex = _array.findIndex((obj: T, _i: number) => {
             const browseName = uaArrayVariableNode.$$getElementBrowseName(obj, elementIndex).toString();
             return browseName === browseNameToFind;
         });
@@ -298,5 +327,5 @@ export function removeElement<T extends ExtensionObject>(
     if (elementIndex < 0) {
         throw new Error(`removeElement: cannot find element matching ${element.toString()}`);
     }
-    return removeElementByIndex(uaArrayVariableNode, elementIndex);
+    removeElementByIndex(uaArrayVariableNode, elementIndex);
 }

package/src/get_basic_datatype.ts

@@ -14,7 +14,10 @@ export function _getBasicDataTypeFromDataTypeNodeId(
     addressSpace: IAddressSpace,
     dataTypeNodeId: { nodeId: NodeIdLike } | NodeIdLike
 ): DataType {
-    const dataTypeNodeId_ = (dataTypeNodeId as any).nodeId ? (dataTypeNodeId as any).nodeId : dataTypeNodeId;
+    const dataTypeNodeId_ =
+        typeof dataTypeNodeId === "object" && dataTypeNodeId !== null && "nodeId" in dataTypeNodeId
+            ? dataTypeNodeId.nodeId
+            : dataTypeNodeId;
     const dataTypeNode = addressSpace.findDataType(dataTypeNodeId_);
     if (!dataTypeNode) {
         return DataType.Null;

package/src/historical_access/address_space_historical_data_node.ts

@@ -1,7 +1,6 @@
 /**
  * @module node-opcua-address-space
  */
-// tslint:disable:no-console
 
 import chalk from "chalk";
 import type {
@@ -35,7 +34,6 @@ import { UAVariableImpl } from "../ua_variable_impl";
 
 const warningLog = make_warningLog(__filename);
 
-// tslint:disable:no-var-requires
 interface DequeueItem<T> {
     data: T | null;
     next: DequeueItem<T>;
@@ -716,7 +714,7 @@ export function AddressSpace_installHistoricalDataNode(
     };
 
     assert(node.nodeClass === NodeClass.Variable);
-    options = options || Object.create(null);
+    const historianOptions: IVariableHistorianOptions = options || Object.create(null);
 
     const addressSpace = node.addressSpace;
 
@@ -729,7 +727,7 @@ export function AddressSpace_installHistoricalDataNode(
     node._historyReadRaw = _historyReadRaw;
     node._historyReadRawAsync = _historyReadRawAsync;
 
-    node.varHistorian = (options as { historian?: boolean }).historian || AddressSpace.historizerFactory.create(node, options);
+    node.varHistorian = historianOptions.historian || AddressSpace.historizerFactory.create(node, historianOptions);
 
     const historicalDataConfigurationType = addressSpace.findObjectType("HistoricalDataConfigurationType");
     if (!historicalDataConfigurationType) {
@@ -737,7 +735,6 @@ export function AddressSpace_installHistoricalDataNode(
     }
     node.historizing = true;
 
-    // tslint:disable:no-bitwise
     node.accessLevel = node.accessLevel | AccessLevelFlag.CurrentRead | AccessLevelFlag.HistoryRead;
     if (node.userAccessLevel !== undefined) {
         node.userAccessLevel = node.userAccessLevel | AccessLevelFlag.CurrentRead | AccessLevelFlag.HistoryRead;

package/src/namespace_impl.ts

@@ -1,7 +1,6 @@
 /**
  * @module node-opcua-address-space
  */
-// tslint:disable:no-console
 import chalk from "chalk";
 import type {
     AddBaseNodeOptions,
@@ -16,7 +15,7 @@ import type {
     AddViewOptions,
     AddYArrayItemOptions,
     BaseNode,
-
+    BaseNodeEvents,
     CreateDataTypeOptions,
     CreateNodeOptions,
     EnumerationItem,
@@ -102,7 +101,6 @@ import {
     UAConditionImplBase,
     UADiscreteAlarmImplBase
 } from "./alarms_and_conditions";
-import { UADiscreteAlarmImpl } from "./alarms_and_conditions/ua_discrete_alarm_impl";
 import { UAExclusiveDeviationAlarmImplBase } from "./alarms_and_conditions/ua_exclusive_deviation_alarm_impl";
 import { UAExclusiveLimitAlarmImplBase } from "./alarms_and_conditions/ua_exclusive_limit_alarm_impl";
 import { UALimitAlarmImplBase } from "./alarms_and_conditions/ua_limit_alarm_impl";
@@ -1019,7 +1017,7 @@ export class NamespaceImpl implements NamespacePrivate {
 
             instrumentRange.on("value_changed", handler);
         }
-        (variable as any).acceptValueOutOfRange = options.acceptValueOutOfRange;
+        (variable as unknown as { acceptValueOutOfRange?: boolean }).acceptValueOutOfRange = options.acceptValueOutOfRange;
 
         if (Object.hasOwn(options, "engineeringUnits")) {
             const engineeringUnits = new EUInformation(options.engineeringUnits);
@@ -1209,7 +1207,7 @@ export class NamespaceImpl implements NamespacePrivate {
             })
         );
 
-        return variable as any;
+        return variable as unknown as UAYArrayItemEx<DT>;
     }
 
     // - Methods ----------------------------------------------------------------------------------------------------
@@ -1424,7 +1422,7 @@ export class NamespaceImpl implements NamespacePrivate {
             //   or OptionSet DataType. It is derived from the DataType EnumValueType. If used for an
             //   OptionSet, the corresponding Value in the base type contains the number of the bit associated
             //   with the field. The EnumField is formally defined in Table 37.
-            (enumType as any).$fullDefinition = new EnumDefinition({
+            (enumType as unknown as { $fullDefinition?: EnumDefinition }).$fullDefinition = new EnumDefinition({
                 fields: enumeration.map(
                     (x: string, index: number) =>
                         new EnumField({
@@ -1463,7 +1461,7 @@ export class NamespaceImpl implements NamespacePrivate {
             });
             assert(enumValues.browseName.toString() === "EnumValues");
 
-            (enumType as any).$fullDefinition = new EnumDefinition({
+            (enumType as unknown as { $fullDefinition?: EnumDefinition }).$fullDefinition = new EnumDefinition({
                 fields: enumeration.map(
                     (x: EnumerationItem, _index: number) =>
                         new EnumField({
@@ -1804,7 +1802,6 @@ export class NamespaceImpl implements NamespacePrivate {
             case NodeClass.View:
                 break;
             default:
-                // tslint:disable-next-line:no-console
                 errorLog("Invalid class Name", node.nodeClass);
                 throw new Error("Invalid class name specified");
         }
@@ -1885,8 +1882,7 @@ export class NamespaceImpl implements NamespacePrivate {
 
         options.addressSpace = this.addressSpace as AddressSpacePrivate;
 
-        // biome-ignore lint/suspicious/noExplicitAny: to fix later
-        const node = new Constructor(options as any);
+        const node = new Constructor(options);
         this._register(node);
 
         // object shall now be registered
@@ -1918,7 +1914,6 @@ export class NamespaceImpl implements NamespacePrivate {
             case NodeClass.View:
                 break;
             default:
-                // tslint:disable:no-console
                 warningLog("Invalid class Name", node.nodeClass);
                 throw new Error("Invalid class name specified");
         }
@@ -1948,15 +1943,23 @@ export class NamespaceImpl implements NamespacePrivate {
         }
         const references: UAReference[] = [];
 
-        function process_subtypeOf_options(this: NamespaceImpl, options2: any, references1: AddReferenceOpts[]) {
+        function process_subtypeOf_options(this: NamespaceImpl, options2: CreateNodeOptions, references1: AddReferenceOpts[]) {
             // check common misspelling mistake
-            assert(!options2.subTypeOf, "misspell error : it should be 'subtypeOf' instead");
+            assert(
+                !(options2 as unknown as Record<string, unknown>).subTypeOf,
+                "misspell error : it should be 'subtypeOf' instead"
+            );
             if (Object.hasOwn(options2, "hasTypeDefinition")) {
                 throw new Error("hasTypeDefinition option is invalid. Do you mean typeDefinition instead ?");
             }
             assert(!options2.typeDefinition, " do you mean subtypeOf ?");
 
-            const subtypeOfNodeId = addressSpace._coerceType(options2.subtypeOf, topMostBaseType, nodeClass);
+            // subtypeOf is optional: _coerceType defaults to topMostBaseType when it's falsy.
+            const subtypeOfNodeId = addressSpace._coerceType(
+                options2.subtypeOf as unknown as string | NodeId | BaseNode,
+                topMostBaseType,
+                nodeClass
+            );
 
             assert(subtypeOfNodeId);
             references1.push({
@@ -2142,7 +2145,7 @@ export class NamespaceImpl implements NamespacePrivate {
     /**
      * @private
      */
-    private _addMethod(options: any): UAMethod {
+    private _addMethod(options: AddMethodOptions & { eventNotifier?: number }): UAMethod {
         const addressSpace = this.addressSpace;
 
         assert(isNonEmptyQualifiedName(options.browseName));
@@ -2158,7 +2161,7 @@ export class NamespaceImpl implements NamespacePrivate {
             browseName: options.browseName,
             description: options.description || "",
             displayName: options.displayName,
-            eventNotifier: +options.eventNotifier,
+            eventNotifier: +(options.eventNotifier || 0),
             isAbstract: false,
             nodeClass: NodeClass.Method,
             nodeId: options.nodeId,
@@ -2173,7 +2176,11 @@ export class NamespaceImpl implements NamespacePrivate {
     }
 }
 
-const _constructors_map: Record<keyof Omit<typeof NodeClass, "Unspecified">, new (options: any) => BaseNodeImpl<any>> = {
+// each concrete constructor below takes a different, incompatible options type (UADataTypeOptions,
+// UAVariableOptions, ...) — the map is only ever indexed by nodeClass and invoked with the matching
+// options shape by the caller, so a wider `new (options: any) => ...` signature is required here.
+// biome-ignore lint/suspicious/noExplicitAny: see comment above
+const _constructors_map: Record<keyof Omit<typeof NodeClass, "Unspecified">, new (options: any) => BaseNodeImpl<BaseNodeEvents>> = {
     DataType: UADataTypeImpl,
     Method: UAMethodImpl,
     Object: UAObjectImpl,

package/src/nodeid_manager.ts

@@ -1,13 +1,10 @@
-/* eslint-disable max-depth */
-/* eslint-disable max-statements */
-
 import type { BaseNode, UAReference, UAReferenceType } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { NodeClass, type QualifiedName, type QualifiedNameOptions } from "node-opcua-data-model";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { makeNodeId, NodeId, type NodeIdLike, NodeIdType, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
-import { BaseNodeImpl, getReferenceType } from "./base_node_impl";
-import { resolveReferenceType } from "./reference_impl";
+import { BaseNodeImpl } from "./base_node_impl";
+import { type ReferenceImpl, resolveReferenceType } from "./reference_impl";
 
 const _debugLog = make_debugLog(__filename);
 const _warningLog = make_warningLog(__filename);
@@ -16,7 +13,7 @@ export const NamespaceOptions = {
     nodeIdNameSeparator: "-"
 };
 function _isValidNodeClass(nodeClass: NodeClass) {
-    return typeof (NodeClass as any)[nodeClass] === "string";
+    return typeof NodeClass[nodeClass] === "string";
 }
 
 const regExp1 = /^(s|i|b|g)=/;
@@ -59,12 +56,13 @@ function _findParentNodeId(addressSpace: AddressSpacePartial, options: Construct
         return null;
     }
     for (const ref of options.references) {
-        (ref as any)._referenceType = addressSpace.findReferenceType(ref.referenceType);
+        const _ref = ref as ReferenceImpl;
+        _ref._referenceType = addressSpace.findReferenceType(ref.referenceType) ?? undefined;
         /* c8 ignore next */
-        if (!getReferenceType(ref)) {
+        if (!_ref._referenceType) {
             throw new Error(`Cannot find referenceType ${JSON.stringify(ref)}`);
         }
-        (ref as any).referenceType = (ref as any)._referenceType.nodeId;
+        _ref.referenceType = _ref._referenceType.nodeId;
     }
     // find HasComponent, or has Property reverse
     return _filterAggregates(addressSpace, options.references);
@@ -105,7 +103,7 @@ export class NodeIdManager {
 
     public setSymbols(symbols: NodeEntry1[]): void {
         function convertNodeClass(nodeClass: string): NodeClass {
-            return (NodeClass as any)[nodeClass as any] as NodeClass;
+            return (NodeClass as unknown as Record<string, NodeClass>)[nodeClass];
         }
         const symbols2 = symbols.map((e: [string, number, string]) => [e[0] as string, e[1] as number, convertNodeClass(e[2])]) as [
             string,
@@ -243,7 +241,6 @@ export class NodeIdManager {
     }
 
     private _constructNodeId(options: ConstructNodeIdOptions): NodeId {
-
         const resolveNodeIdEx = (nodeId: BaseNode | NodeIdLike) =>
             nodeId && typeof nodeId === "object" && nodeId instanceof BaseNodeImpl
                 ? nodeId.nodeId

package/src/nodeset_tools/construct_namespace_dependency.ts

@@ -18,7 +18,6 @@ interface RequiredModel {
     requiredNamespaceIndexes: number[];
     nbTypes: number;
 }
-// eslint-disable-next-line max-statements, complexity
 export function _recomputeRequiredModelsFromTypes(namespace: INamespace, cache?: Map<number, RequiredModel>): RequiredModel {
     if (namespace.index === 0) {
         return { requiredNamespaceIndexes: [], nbTypes: 1 };
@@ -103,12 +102,12 @@ export function _recomputeRequiredModelsFromTypes(namespace: INamespace, cache?:
         if (!uaVariable.$dataValue) return;
         const variant = uaVariable.$dataValue.value;
         if (!variant) return;
-        const value: any | any[] = variant.value;
+        const value: unknown = variant.value;
         if (!value) return;
         if (Array.isArray(value)) {
-            value.forEach(exploreExtensionObject);
+            (value as ExtensionObject[]).forEach(exploreExtensionObject);
         } else {
-            exploreExtensionObject(value);
+            exploreExtensionObject(value as ExtensionObject);
         }
     }
     for (const node of namespace_.nodeIterator()) {
@@ -132,7 +131,7 @@ export function _recomputeRequiredModelsFromTypes(namespace: INamespace, cache?:
         } else if (isInstance !== -1) {
             if (node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.VariableType) {
                 const dataTypeNodeId = (node as UAVariable | UAVariableType).dataType;
-                const dataTypeNode = addressSpace.findDataType(dataTypeNodeId)!;
+                const dataTypeNode = addressSpace.findDataType(dataTypeNodeId);
                 if (dataTypeNode) {
                     consider(dataTypeNode.nodeId.namespace);
                 } else {
@@ -236,9 +235,11 @@ export function _getCompleteRequiredModelsFromValuesAndReferences(
                         // always include the target namespace as a dependency
                         // regardless of priority, since the current node owns
                         // this relationship.
-                        if (reference.isForward
-                            && nonHierarchicalReferencesType
-                            && referenceType.isSubtypeOf(nonHierarchicalReferencesType)) {
+                        if (
+                            reference.isForward &&
+                            nonHierarchicalReferencesType &&
+                            referenceType.isSubtypeOf(nonHierarchicalReferencesType)
+                        ) {
                             consider(namespaceIndexOfTargetNode);
                         }
                         // For inverse HierarchicalReferences (e.g. Organizes),
@@ -246,9 +247,11 @@ export function _getCompleteRequiredModelsFromValuesAndReferences(
                         // regardless of priority, since the reference is
                         // stored on this node (organizedBy pattern).
                         const hierarchicalReferencesType = addressSpace.findReferenceType("HierarchicalReferences");
-                        if (!reference.isForward
-                            && hierarchicalReferencesType
-                            && referenceType.isSubtypeOf(hierarchicalReferencesType)) {
+                        if (
+                            !reference.isForward &&
+                            hierarchicalReferencesType &&
+                            referenceType.isSubtypeOf(hierarchicalReferencesType)
+                        ) {
                             consider(namespaceIndexOfTargetNode);
                         }
                     }
@@ -313,14 +316,14 @@ export function constructNamespacePriorityTable(addressSpace: IAddressSpace): {
     };
 
     for (let i = 0; i < namespaces.length; i++) {
-        const { nbTypes } = map.get(i)!;
-        if (nbTypes) {
+        const entry = map.get(i);
+        if (entry?.nbTypes) {
             h(namespaces[i]);
         }
     }
     for (let i = 0; i < namespaces.length; i++) {
-        const { nbTypes } = map.get(i)!;
-        if (!nbTypes) {
+        const entry = map.get(i);
+        if (!entry?.nbTypes) {
             h(namespaces[i]);
         }
     }

package/src/nodeset_tools/dump_to_bsd.ts

@@ -7,7 +7,6 @@ import type { AddressSpacePrivate } from "../address_space_private";
 import type { NamespacePrivate } from "../namespace_private";
 import { constructNamespaceDependency } from "./construct_namespace_dependency";
 
-// tslint:disable-next-line: no-var-requires
 const XMLWriter = require("xml-writer");
 
 function dumpEnumeratedType(xw: XmlWriter, e: EnumDefinition, name: string): void {
@@ -16,7 +15,7 @@ function dumpEnumeratedType(xw: XmlWriter, e: EnumDefinition, name: string): voi
     xw.writeAttribute("LengthInBits", "32");
     for (const f of e.fields || []) {
         xw.startElement("opc:EnumeratedValue");
-        xw.writeAttribute("Name", f.name|| "");
+        xw.writeAttribute("Name", f.name || "");
         assert(f.value[0] === 0, "unsupported 64 bit value !");
         xw.writeAttribute("Value", f.value[1].toString());
         xw.endElement();
@@ -32,7 +31,7 @@ function buildXmlName(addressSpace: AddressSpacePrivate, map: Map<number, string
     if (!node) {
         throw new Error(`Cannot find Node for${nodeId?.toString()}`);
     }
-    const typeName = node.browseName.name!;
+    const typeName = node.browseName.name || "";
 
     const n = node.nodeId as INodeId;
     const prefix =
@@ -44,7 +43,6 @@ function buildXmlName(addressSpace: AddressSpacePrivate, map: Map<number, string
     return `${prefix}:${typeName === "Structure" && prefix === "ua" ? "ExtensionObject" : typeName}`;
 }
 
-// eslint-disable-next-line max-statements
 function dumpDataTypeStructure(
     xw: XmlWriter,
     addressSpace: IAddressSpace,
@@ -110,7 +108,7 @@ function dumpDataTypeStructure(
 
         if (isArray) {
             xw.startElement("opc:Field");
-            xw.writeAttribute("Name", `NoOf${f.name!}`);
+            xw.writeAttribute("Name", `NoOf${f.name || ""}`);
             xw.writeAttribute("TypeName", "opc:Int32");
             if (f.isOptional) {
                 xw.writeAttribute("SwitchField", `${f.name}Specified`);
@@ -119,15 +117,15 @@ function dumpDataTypeStructure(
         }
 
         xw.startElement("opc:Field");
-        xw.writeAttribute("Name", f.name|| "");
+        xw.writeAttribute("Name", f.name || "");
 
         const typeName = buildXmlName(addressSpace as AddressSpacePrivate, map, f.dataType);
         xw.writeAttribute("TypeName", typeName);
         if (isArray) {
-            xw.writeAttribute("LengthField", `NoOf${f.name|| ""}`);
+            xw.writeAttribute("LengthField", `NoOf${f.name || ""}`);
         }
         if (f.isOptional) {
-            xw.writeAttribute("SwitchField", `${f.name|| ""}Specified`);
+            xw.writeAttribute("SwitchField", `${f.name || ""}Specified`);
         }
         xw.endElement();
     }