node-opcua-address-space 2.169.0 → 2.172.0

package/source/loader/parsers/extension_object_parser.ts

@@ -1,20 +1,19 @@
-import assert from "assert";
-import { IAddressSpace } from "node-opcua-address-space-base";
+import assert from "node:assert";
+import type { IAddressSpace } from "node-opcua-address-space-base";
+import { coerceInt64 } from "node-opcua-basic-types";
+import { Range } from "node-opcua-data-access";
+import { coerceLocalizedText, LocalizedText, type LocalizedTextOptions } from "node-opcua-data-model";
+import { make_debugLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
-import { InternalFragmentClonerReaderState, ParserLike, ReaderStateParser, ReaderStateParserLike } from "node-opcua-xml2json";
+import { Argument, EnumValueType, EUInformation, type EUInformationOptions } from "node-opcua-types";
+import { InternalFragmentClonerReaderState, type ParserLike, type ReaderStateParserLike } from "node-opcua-xml2json";
 import { decodeXmlExtensionObject } from "../decode_xml_extension_object";
-import { coerceLocalizedText, LocalizedText, LocalizedTextOptions } from "node-opcua-data-model";
-import { Argument, EnumValueType, EUInformation, EUInformationOptions } from "node-opcua-types";
 import { localizedText_parser } from "./localized_text_parser";
-import { coerceInt64 } from "node-opcua-basic-types";
-import { make_debugLog } from "node-opcua-debug";
-import { Range } from "node-opcua-data-access";
-
 
 const debugLog = make_debugLog("ExtensionObjectParser");
 const errorLog = make_debugLog("ExtensionObjectParser");
-const doDebug = false;
+const _doDebug = false;
 export type Task = (addressSpace: IAddressSpace) => Promise<void>;
 
 interface PostExtensionObjectData {
@@ -75,7 +74,7 @@ const makeArgumentParser = (_translateNodeId: (nodeId: string) => NodeId) => ({
 
 // #region Range parser
 type RangeParser = ParserLike & { range: Range };
-type RangeParserL2 = ParserLike & { parent: RangeParser, text: string };
+type RangeParserL2 = ParserLike & { parent: RangeParser; text: string };
 
 const Range_parser = {
     Range: {
@@ -103,14 +102,14 @@ const Range_parser = {
 
 type EUInformationParser = ReaderStateParserLike & {
     euInformation: EUInformationOptions;
-    parser: any
+    parser: any;
 };
 type EUInformationParserLevel2 = { parent: EUInformationParser } & { text: string };
 type EUInformationParserLevel2L = { parent: EUInformationParser } & { localizedText: LocalizedTextOptions };
 
 const EUInformation_parser: ParserLike = {
     EUInformation: <EUInformationParser>{
-        init(this: EUInformationParser, name, attrs, parent, engine) {
+        init(this: EUInformationParser, _name, _attrs, _parent, _engine) {
             this.euInformation = new EUInformation({});
         },
         parser: {
@@ -150,17 +149,17 @@ const EUInformation_parser: ParserLike = {
 type EnumValueParser = ReaderStateParserLike & {
     enumValueType: EnumValueType;
     parser: {
-        Value: ReaderStateParserLike,
-        DisplayName: ReaderStateParserLike,
-        Description: ReaderStateParserLike
-    }
+        Value: ReaderStateParserLike;
+        DisplayName: ReaderStateParserLike;
+        Description: ReaderStateParserLike;
+    };
 };
 type EnumValueParserL2 = ReaderStateParserLike & { parent: EnumValueParser } & { text: string };
 type EnumValueParserL2L = { parent: EnumValueParser } & { localizedText: LocalizedTextOptions };
 
 const enumValueType_parser = {
     EnumValueType: {
-        init(this: EnumValueParser) {  
+        init(this: EnumValueParser) {
             this.enumValueType = new EnumValueType({
                 description: undefined,
                 displayName: undefined,
@@ -179,14 +178,14 @@ const enumValueType_parser = {
             DisplayName: {
                 ...localizedText_parser.LocalizedText,
                 finish(this: EnumValueParserL2L) {
-                    this.parent.enumValueType.displayName = new LocalizedText({...this.localizedText});
+                    this.parent.enumValueType.displayName = new LocalizedText({ ...this.localizedText });
                 }
             },
 
             Description: {
                 ...localizedText_parser.LocalizedText,
                 finish(this: EnumValueParserL2L) {
-                    this.parent.enumValueType.description = new LocalizedText({...this.localizedText});
+                    this.parent.enumValueType.description = new LocalizedText({ ...this.localizedText });
                 }
             }
         },
@@ -197,8 +196,6 @@ const enumValueType_parser = {
 };
 // #endregion
 
-
-
 export interface ExtensionObjectTypeIdParser {
     parent: ExtensionObjectParser;
 }
@@ -213,31 +210,30 @@ export interface ExtensionObjectParserInner {
 }
 type ExtensionObjectParser = ExtensionObjectParserInner & any;
 export interface ExtensionObjectBodyParser {
-
     parent: ExtensionObjectParser;
     _cloneFragment: InternalFragmentClonerReaderState;
     engine: any;
     parser: {
-        Argument: ArgumentParser,
-        EUInformation: EUInformationParser,
-        EnumValueType: EnumValueParser,
-        Range: RangeParser
+        Argument: ArgumentParser;
+        EUInformation: EUInformationParser;
+        EnumValueType: EnumValueParser;
+        Range: RangeParser;
     };
 }
 
 export function makeExtensionObjectInnerParser<T>(
     translateNodeId: (nodeId: string) => NodeId,
     setExtensionObject: (extensionObject: ExtensionObject) => void,
-    setExtensionObjectPojo: (typeDefinition: NodeId, xmlData: string, data: T) => void,
+    setExtensionObjectPojo: (typeDefinition: NodeId, xmlData: string, data: T) => void
 ): ReaderStateParserLike {
     const a = makeExtensionObjectParser(translateNodeId, setExtensionObject, setExtensionObjectPojo);
     return a.ExtensionObject;
-};
+}
 
 export function makeExtensionObjectParser<T>(
     translateNodeId: (nodeId: string) => NodeId,
     setExtensionObject: (extensionObject: ExtensionObject, data: T) => void,
-    setExtensionObjectPojo: (typeDefinition: NodeId, xmlData: string, data: T) => void,
+    setExtensionObjectPojo: (typeDefinition: NodeId, xmlData: string, data: T) => void
 ): ParserLike {
     return {
         ExtensionObject: <ExtensionObjectParser>{
@@ -266,47 +262,53 @@ export function makeExtensionObjectParser<T>(
                         Range: Range_parser.Range
                     },
                     startElement(this: ExtensionObjectBodyParser, elementName: string, attrs: any) {
-                        if (!Object.prototype.hasOwnProperty.call(this.parser, elementName)) {
+                        if (!Object.hasOwn(this.parser, elementName)) {
                             // treat it as a opaque XML bloc for the time being
                             // until we find the definition of this object, so we know how to interpret the fields
                             this._cloneFragment = new InternalFragmentClonerReaderState();
-                            this.engine!._promote(this._cloneFragment, this.engine!.currentLevel, elementName, attrs);
+                            this.engine?._promote(this._cloneFragment, this.engine?.currentLevel, elementName, attrs);
                         }
                     },
                     finish(this: ExtensionObjectBodyParser) {
-
                         const data = this.parent.parent as T;
                         const typeDefinitionId = this.parent.typeDefinitionId;
                         // typeDefinitionId is also the "Default XML" encoding nodeId !
                         switch (typeDefinitionId.toString()) {
                             case "i=7616": // EnumValueType
-                            case "ns=0;i=7616":
+                            case "ns=0;i=7616": {
                                 const extensionObject = this.parser.EnumValueType.enumValueType;
                                 assert(extensionObject !== null && typeof extensionObject === "object");
                                 assert(extensionObject instanceof ExtensionObject);
                                 setExtensionObject(extensionObject, data);
                                 break;
+                            }
                             case "i=297": // Arguments
-                            case "ns=0;i=297": {
-                                const extensionObject = this.parser.Argument.argument;
-                                assert(extensionObject !== null && typeof extensionObject === "object");
-                                assert(extensionObject instanceof ExtensionObject);
-                                setExtensionObject(extensionObject, data);
-                            } break;
-                            case "i=888":// EUInformation
-                            case "ns=0;i=888": {
-                                const extensionObject = this.parser.EUInformation.euInformation;
-                                assert(extensionObject !== null && typeof extensionObject === "object");
-                                assert(extensionObject instanceof ExtensionObject);
-                                setExtensionObject(extensionObject, data);
-                            } break;
+                            case "ns=0;i=297":
+                                {
+                                    const extensionObject = this.parser.Argument.argument;
+                                    assert(extensionObject !== null && typeof extensionObject === "object");
+                                    assert(extensionObject instanceof ExtensionObject);
+                                    setExtensionObject(extensionObject, data);
+                                }
+                                break;
+                            case "i=888": // EUInformation
+                            case "ns=0;i=888":
+                                {
+                                    const extensionObject = this.parser.EUInformation.euInformation;
+                                    assert(extensionObject !== null && typeof extensionObject === "object");
+                                    assert(extensionObject instanceof ExtensionObject);
+                                    setExtensionObject(extensionObject, data);
+                                }
+                                break;
                             case "i=885": // Range
-                            case "ns=0;i=885": {
-                                const extensionObject = this.parser.Range.range;
-                                assert(extensionObject !== null && typeof extensionObject === "object");
-                                assert(extensionObject instanceof ExtensionObject);
-                                setExtensionObject(extensionObject, data);
-                            } break;
+                            case "ns=0;i=885":
+                                {
+                                    const extensionObject = this.parser.Range.range;
+                                    assert(extensionObject !== null && typeof extensionObject === "object");
+                                    assert(extensionObject instanceof ExtensionObject);
+                                    setExtensionObject(extensionObject, data);
+                                }
+                                break;
                             default: {
                                 // c8 ignore next
                                 if (!this._cloneFragment) {
@@ -319,13 +321,13 @@ export function makeExtensionObjectParser<T>(
                                     );
                                     break;
                                 }
-                                const bodyXML = this._cloneFragment!.value;
+                                const bodyXML = this._cloneFragment?.value;
                                 this._cloneFragment!.value = null;
 
                                 // the "Default Xml" encoding  nodeId
                                 const xmlEncodingNodeId = typeDefinitionId;
                                 if (typeDefinitionId.isEmpty()) {
-                                    debugLog("xmlEncodingNodeId is empty for " + typeDefinitionId.toString());
+                                    debugLog(`xmlEncodingNodeId is empty for ${typeDefinitionId.toString()}`);
                                     break;
                                 }
                                 setExtensionObjectPojo(xmlEncodingNodeId, bodyXML, data);
@@ -339,16 +341,15 @@ export function makeExtensionObjectParser<T>(
                 /* empty */
             }
         }
-    }
-};
-
+    };
+}
 
 export function createXMLExtensionObjectDecodingTask(
-    translateNodeId: (nodeId:string) => NodeId,
-    xmlEncodingNodeId: NodeId, bodyXML: string,
-    withDecoded: (extensionObject: ExtensionObject) => void,
+    translateNodeId: (nodeId: string) => NodeId,
+    xmlEncodingNodeId: NodeId,
+    bodyXML: string,
+    withDecoded: (extensionObject: ExtensionObject) => void
 ) {
-
     const capturedXmlBody = bodyXML;
 
     const task = async (addressSpace2: IAddressSpace) => {

package/source/loader/parsers/localized_text_parser.ts

@@ -1,5 +1,5 @@
-import { coerceLocalizedText, LocalizedTextOptions, LocalizedText } from "node-opcua-data-model";
-import { ReaderStateParserLike } from "node-opcua-xml2json";
+import { coerceLocalizedText, type LocalizedText, type LocalizedTextOptions } from "node-opcua-data-model";
+import type { ReaderStateParserLike } from "node-opcua-xml2json";
 
 type LocalizedTextParserLikeL1 = ReaderStateParserLike & {
     localizedText: LocalizedTextOptions;
@@ -16,7 +16,7 @@ export const localizedText_parser = {
         parser: {
             Locale: {
                 finish(this: LocalizedTextParserLikeL2) {
-                    this.parent.localizedText = this.parent.localizedText || { text: undefined};
+                    this.parent.localizedText = this.parent.localizedText || { text: undefined };
                     this.parent.localizedText.locale = this.text.trim();
                 }
             },

package/source/loader/parsers/nodeid_parser.ts

@@ -1,5 +1,4 @@
-import { resolveNodeId, NodeId, NodeIdLike } from "node-opcua-nodeid";
-
+import { type NodeId, resolveNodeId } from "node-opcua-nodeid";
 
 export const makeNodeIdParser = (_translateNodeId: (nodeId: string) => NodeId) => ({
     NodeId: {
@@ -14,4 +13,4 @@ export const makeNodeIdParser = (_translateNodeId: (nodeId: string) => NodeId) =
             }
         }
     }
-});
+});

package/source/loader/parsers/qualified_name_parser.ts

@@ -1,10 +1,9 @@
-import { QualifiedNameOptions, QualifiedName, coerceQualifiedName } from "node-opcua-data-model";
-import { resolveNodeId, NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { ReaderStateParserLike } from "node-opcua-xml2json";
-
+import { coerceQualifiedName, type QualifiedName, type QualifiedNameOptions } from "node-opcua-data-model";
+import { type NodeId, resolveNodeId } from "node-opcua-nodeid";
+import type { ReaderStateParserLike } from "node-opcua-xml2json";
 
 interface QualifiedNameParserL1 extends ReaderStateParserLike {
-    value: QualifiedName| null;
+    value: QualifiedName | null;
     qualifiedName: QualifiedNameOptions;
 }
 
@@ -13,7 +12,7 @@ export interface QualifiedNameParserL2 {
     text: string;
 }
 
-export const makeQualifiedNameParser = (_translateNodeId: (nodeId: string)=> NodeId) => ({
+export const makeQualifiedNameParser = (_translateNodeId: (nodeId: string) => NodeId) => ({
     QualifiedName: {
         init(this: QualifiedNameParserL1) {
             this.qualifiedName = {
@@ -37,7 +36,7 @@ export const makeQualifiedNameParser = (_translateNodeId: (nodeId: string)=> Nod
             }
         },
         finish(this: QualifiedNameParserL1) {
-            this.value = coerceQualifiedName(this.qualifiedName)
+            this.value = coerceQualifiedName(this.qualifiedName);
         }
     }
 });

package/source/loader/parsers/variant_parser.ts

@@ -1,21 +1,26 @@
-import { coerceBoolean, coerceInt64, coerceUInt64, DataType, Int64, isValidGuid, UInt64 } from "node-opcua-basic-types";
-import { IAddressSpace, UAVariable, UAVariableType } from "node-opcua-address-space-base";
-import { coerceLocalizedText, coerceQualifiedName, LocalizedTextOptions, NodeClass, QualifiedNameOptions } from "node-opcua-data-model";
-import { ExtensionObject } from "node-opcua-extension-object";
-import { resolveNodeId, NodeIdLike, NodeId } from "node-opcua-nodeid";
-import { VariantArrayType, VariantOptions } from "node-opcua-variant";
+import type { IAddressSpace, UAVariable, UAVariableType } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { ParserLike, ReaderStateParserLike, XmlAttributes } from "node-opcua-xml2json";
+import { coerceBoolean, coerceInt64, coerceUInt64, DataType, type Int64, isValidGuid, type UInt64 } from "node-opcua-basic-types";
+import {
+    coerceLocalizedText,
+    coerceQualifiedName,
+    type LocalizedTextOptions,
+    NodeClass,
+    type QualifiedNameOptions
+} from "node-opcua-data-model";
 import { make_debugLog } from "node-opcua-debug";
-
-import { localizedText_parser } from "./localized_text_parser";
-import { makeQualifiedNameParser } from "./qualified_name_parser";
+import type { ExtensionObject } from "node-opcua-extension-object";
+import { type NodeId, type NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
+import { VariantArrayType, type VariantOptions } from "node-opcua-variant";
+import type { ParserLike, ReaderStateParserLike, XmlAttributes } from "node-opcua-xml2json";
 import {
     createXMLExtensionObjectDecodingTask,
     makeExtensionObjectInnerParser,
-    makeExtensionObjectParser,
+    makeExtensionObjectParser
 } from "./extension_object_parser";
+import { localizedText_parser } from "./localized_text_parser";
 import { makeNodeIdParser } from "./nodeid_parser";
+import { makeQualifiedNameParser } from "./qualified_name_parser";
 
 const debugLog = make_debugLog(__dirname);
 
@@ -28,20 +33,17 @@ type IBasicReaderStateParserLike<T> = ReaderStateParserLike & {
 function BasicType_parser<T>(dataType: string, parseFunc: (this: { value: T | undefined }, text: string) => any): ParserLike {
     const _parser: Record<string, ReaderStateParserLike> = {};
     const a = {
-        init(this: IBasicReaderStateParserLike<T>, name: string, attrs: XmlAttributes, parent: any, endElement: any) {
+        init(this: IBasicReaderStateParserLike<T>, _name: string, _attrs: XmlAttributes, _parent: any, _endElement: any) {
             this.value = undefined;
         },
         finish(this: IBasicReaderStateParserLike<T>) {
             this.value = parseFunc.call(this, this.text);
         }
-    }
+    };
     _parser[dataType] = a as ReaderStateParserLike;
     return _parser as ParserLike;
 }
 
-
-
-
 function ListOf<T>(_setValue: (data: VariantOptions) => void, dataType: string, parseFunc: any) {
     return {
         init(this: ListOfTParser<T>) {
@@ -57,32 +59,27 @@ function ListOf<T>(_setValue: (data: VariantOptions) => void, dataType: string,
                 value: this.listData
             });
         },
-        endElement(this: ListOfTParser<T>, element: string) {
+        endElement(this: ListOfTParser<T>, _element: string) {
             this.listData.push(this.parser[dataType].value);
         }
     };
 }
 
-
 interface Parser {
     parent: Parser | any;
 }
 
-
-
-function installExtensionObjectListInitializationPostTask(
+function _installExtensionObjectListInitializationPostTask(
     postTasks2_AssignedExtensionObjectToDataValue: Task[],
-    element: ListOfExtensionObjectParser) {
-
-
-
+    element: ListOfExtensionObjectParser
+) {
     let listExtensionObject = element.listExtensionObject;
     let nodeId = element.parent.parent.obj.nodeId;
     assert(nodeId, "expecting a nodeid");
     const task = async (addressSpace2: IAddressSpace) => {
         const node = addressSpace2.findNode(nodeId)!;
         if (!node) {
-            debugLog("Cannot find node with nodeId " + nodeId + ". may be the node was marked as deprecated");
+            debugLog(`Cannot find node with nodeId ${nodeId}. may be the node was marked as deprecated`);
         } else if (node.nodeClass === NodeClass.Variable) {
             const v = node as UAVariable;
             assert(v.getBasicDataType() === DataType.ExtensionObject, "expecting an extension object");
@@ -99,9 +96,6 @@ function installExtensionObjectListInitializationPostTask(
     postTasks2_AssignedExtensionObjectToDataValue.push(task);
 }
 
-
-
-
 export interface ListOfTParser<T> extends Parser {
     listData: T[];
     parent: Parser;
@@ -123,9 +117,6 @@ function parser2<T>(_setValue: (data: VariantOptions) => void, type: string, p:
 const parseUInt64 = (str: string): UInt64 => coerceUInt64(str);
 const parseInt64 = (str: string): Int64 => coerceInt64(str);
 
-
-
-
 export interface ListOfExtensionObjectParser extends ListOfTParser<ExtensionObject> {
     isDeferred: boolean;
     listExtensionObject: (ExtensionObject | null)[];
@@ -135,19 +126,16 @@ export interface ListOfExtensionObjectParser extends ListOfTParser<ExtensionObje
     };
 }
 
-
-
 export function makeVariantReader<T extends ReaderStateParserLike>(
     setValue: (self: T, data: VariantOptions) => void,
     setDeferredValue: (self: T, data: VariantOptions, deferedTask: () => ExtensionObject | ExtensionObject[] | null) => void,
     postExtensionObjectDecoding: (task: (addressSpace: IAddressSpace) => Promise<void>) => void,
-    translateNodeId: (nodeId: string) => NodeId,
+    translateNodeId: (nodeId: string) => NodeId
 ): ReaderStateParserLike {
-
     let self: T;
     const setValue2 = (data: VariantOptions) => {
         setValue(self, data);
-    }
+    };
     const reader = {
         init(this: ReaderStateParserLike) {
             /* empty */
@@ -159,7 +147,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                 finish(this: any) {
                     setValue2({
                         dataType: DataType.QualifiedName,
-                        value: coerceQualifiedName({...this.qualifiedName})
+                        value: coerceQualifiedName({ ...this.qualifiedName })
                     });
                 }
             },
@@ -168,7 +156,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                 finish(this: any) {
                     setValue2({
                         dataType: DataType.LocalizedText,
-                        value: coerceLocalizedText({...this.localizedText})
+                        value: coerceLocalizedText({ ...this.localizedText })
                     });
                 }
             },
@@ -272,8 +260,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                         value: extensionObject
                     });
                 },
-                (xmlEncodingNodeId: NodeId, bodyXML: string, data) => {
-
+                (xmlEncodingNodeId: NodeId, bodyXML: string, _data) => {
                     let _capturedExtensionObject: ExtensionObject | ExtensionObject[] | null = null;
                     // extension object creation will be postponed
                     const task0 = createXMLExtensionObjectDecodingTask(
@@ -282,13 +269,18 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                         bodyXML,
                         (extensionObject: ExtensionObject) => {
                             _capturedExtensionObject = extensionObject;
-                        });
+                        }
+                    );
                     postExtensionObjectDecoding(task0);
-                    setDeferredValue(self, {
-                        dataType: DataType.ExtensionObject,
-                        arrayType: VariantArrayType.Scalar,
-                        value: null
-                    }, () => _capturedExtensionObject);
+                    setDeferredValue(
+                        self,
+                        {
+                            dataType: DataType.ExtensionObject,
+                            arrayType: VariantArrayType.Scalar,
+                            value: null
+                        },
+                        () => _capturedExtensionObject
+                    );
                 }
             ),
 
@@ -312,14 +304,15 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                         self.listExtensionObject.push(null);
                         const index = self.listExtensionObject.length - 1;
                         assert(index >= 0);
-                        let listExtensionObject = self.listExtensionObject;
+                        const listExtensionObject = self.listExtensionObject;
                         const task0 = createXMLExtensionObjectDecodingTask(
                             translateNodeId,
                             xmlEncodingNodeId,
                             bodyXML,
                             (extensionObject: ExtensionObject) => {
                                 listExtensionObject[index] = extensionObject;
-                            });
+                            }
+                        );
                         postExtensionObjectDecoding(task0);
                     }
                 ),
@@ -333,17 +326,18 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                     } else {
                         // postpone the creation of the extension object
                         const listExtensionObject: ExtensionObject[] = this.listExtensionObject as any;
-                        setDeferredValue(self,
+                        setDeferredValue(
+                            self,
                             {
                                 arrayType: VariantArrayType.Array,
                                 dataType: DataType.ExtensionObject,
                                 value: null
                             },
-                            () => listExtensionObject,
+                            () => listExtensionObject
                         );
                         this.listExtensionObject = [];
                     }
-                },
+                }
             },
 
             ListOfLocalizedText: {
@@ -385,7 +379,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
                     this.listData = [];
                 },
                 parser: makeNodeIdParser(translateNodeId),
-                endElement(this: ListOfTParser<NodeIdLike>, elementName: string) {
+                endElement(this: ListOfTParser<NodeIdLike>, _elementName: string) {
                     this.listData.push(this.parser.NodeId.nodeId);
                 },
                 finish(this: ListOfTParser<NodeIdLike>) {
@@ -419,8 +413,7 @@ export function makeVariantReader<T extends ReaderStateParserLike>(
 
             ListOfString: ListOf<string>(setValue2, "String", (value: string) => value),
 
-            ListOfXmlElement: ListOf<string>(setValue2, "XmlElement", (value: string) => value),
-
+            ListOfXmlElement: ListOf<string>(setValue2, "XmlElement", (value: string) => value)
         }
     };
     return reader as any as ReaderStateParserLike;

package/source/loader/register_node_promoter.ts

@@ -1,6 +1,6 @@
 import { resolveNodeId } from "node-opcua-nodeid";
-import { g_promotableObject, Promoter } from "./namespace_post_step";
+import { g_promotableObject, type Promoter } from "./namespace_post_step";
 
 export function registerNodePromoter(standardNodeId: number, promoter: Promoter, onInstanceOnly = false): void {
-    g_promotableObject.set(resolveNodeId(standardNodeId).toString(),{ promoter, onInstanceOnly });
+    g_promotableObject.set(resolveNodeId(standardNodeId).toString(), { promoter, onInstanceOnly });
 }

package/source/namespace.ts

@@ -1,7 +1,7 @@
-import { INamespace } from "node-opcua-address-space-base";
+import type { INamespace } from "node-opcua-address-space-base";
 
-import { INamespaceAlarmAndCondition } from "./namespace_alarm_and_condition";
-import { INamespaceDataAccess } from "./namespace_data_access";
-import { INamespaceMachineState } from "./namespace_machine_state";
+import type { INamespaceAlarmAndCondition } from "./namespace_alarm_and_condition";
+import type { INamespaceDataAccess } from "./namespace_data_access";
+import type { INamespaceMachineState } from "./namespace_machine_state";
 
 export interface Namespace extends INamespace, INamespaceAlarmAndCondition, INamespaceDataAccess, INamespaceMachineState {}

package/source/namespace_alarm_and_condition.ts

@@ -1,30 +1,30 @@
-import { NodeId } from "node-opcua-nodeid";
-import { UAEventType } from "node-opcua-address-space-base";
-import { VariantOptions } from "node-opcua-variant";
-
-import { UAOffNormalAlarmEx } from "../src/alarms_and_conditions/ua_off_normal_alarm_impl";
-import { InstantiateAlarmConditionOptions } from "./interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
-import { InstantiateExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
-import { InstantiateLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
-import { InstantiateNonExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options";
-import { InstantiateOffNormalAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
-import { UAAcknowledgeableConditionEx } from "./interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
-import { UAAlarmConditionEx } from "./interfaces/alarms_and_conditions/ua_alarm_condition_ex";
-import { UAConditionEx } from "./interfaces/alarms_and_conditions/ua_condition_ex";
-import { UADiscreteAlarmEx } from "./interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
-import { UAExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
-import { UAExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
-import { UALimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_limit_alarm_ex";
-import { UANonExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
-import { UANonExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex";
-import { InstantiateNonExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options";
-import { InstantiateExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options";
+import type { UAEventType } from "node-opcua-address-space-base";
+import type { NodeId } from "node-opcua-nodeid";
+import type { VariantOptions } from "node-opcua-variant";
+import type { UAOffNormalAlarmEx } from "../src/alarms_and_conditions/ua_off_normal_alarm_impl";
+import type { InstantiateAlarmConditionOptions } from "./interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
+import type { InstantiateConditionOptions } from "./interfaces/alarms_and_conditions/instantiate_condition_options";
+import type { InstantiateExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options";
+import type { InstantiateExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
+import type { InstantiateLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import type { InstantiateNonExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options";
+import type { InstantiateNonExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options";
+import type { InstantiateOffNormalAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
+import type { UAAcknowledgeableConditionEx } from "./interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
+import type { UAAlarmConditionEx } from "./interfaces/alarms_and_conditions/ua_alarm_condition_ex";
+import type { UAConditionEx } from "./interfaces/alarms_and_conditions/ua_condition_ex";
+import type { UADiscreteAlarmEx } from "./interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
+import type { UAExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
+import type { UAExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
+import type { UALimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_limit_alarm_ex";
+import type { UANonExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
+import type { UANonExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex";
 
 export interface INamespaceAlarmAndCondition {
     // --- Alarms & Conditions -------------------------------------------------
     instantiateCondition(
         conditionTypeId: UAEventType | NodeId | string,
-        options: any,
+        options: InstantiateConditionOptions,
         data?: Record<string, VariantOptions>
     ): UAConditionEx;