node-opcua-address-space 2.135.0 → 2.137.0

package/source/loader/parsers/variant_parser.ts

@@ -0,0 +1,427 @@
+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 { assert } from "node-opcua-assert";
+import { ParserLike, ReaderStateParserLike, XmlAttributes } from "node-opcua-xml2json";
+import { make_debugLog } from "node-opcua-debug";
+
+import { localizedText_parser } from "./localized_text_parser";
+import { makeQualifiedNameParser } from "./qualified_name_parser";
+import {
+    createXMLExtensionObjectDecodingTask,
+    makeExtensionObjectInnerParser,
+    makeExtensionObjectParser,
+} from "./extension_object_parser";
+import { makeNodeIdParser } from "./nodeid_parser";
+
+const debugLog = make_debugLog(__dirname);
+
+export type Task = (addressSpace2: IAddressSpace) => Promise<void>;
+
+type IBasicReaderStateParserLike<T> = ReaderStateParserLike & {
+    value: T | undefined;
+    text: string;
+};
+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) {
+            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>) {
+            this.listData = [];
+        },
+
+        parser: BasicType_parser<T>(dataType, parseFunc),
+
+        finish(this: ListOfTParser<T>) {
+            _setValue({
+                arrayType: VariantArrayType.Array,
+                dataType: (DataType as any)[dataType],
+                value: this.listData
+            });
+        },
+        endElement(this: ListOfTParser<T>, element: string) {
+            this.listData.push(this.parser[dataType].value);
+        }
+    };
+}
+
+
+interface Parser {
+    parent: Parser | any;
+}
+
+
+
+function installExtensionObjectListInitializationPostTask(
+    postTasks2_AssignedExtensionObjectToDataValue: Task[],
+    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");
+        } else if (node.nodeClass === NodeClass.Variable) {
+            const v = node as UAVariable;
+            assert(v.getBasicDataType() === DataType.ExtensionObject, "expecting an extension object");
+            v.bindExtensionObject(listExtensionObject as ExtensionObject[], { createMissingProp: false });
+        } else if (node.nodeClass === NodeClass.VariableType) {
+            // no need to bind a variable type
+            const v = node as UAVariableType;
+            (v as any) /*fix me*/.value.value = listExtensionObject;
+        }
+        listExtensionObject.slice(0);
+        (listExtensionObject as any) = undefined;
+        (nodeId as any) = undefined;
+    };
+    postTasks2_AssignedExtensionObjectToDataValue.push(task);
+}
+
+
+
+
+export interface ListOfTParser<T> extends Parser {
+    listData: T[];
+    parent: Parser;
+    parser: {
+        [key: string]: Parser | any;
+    };
+}
+function parser2<T>(_setValue: (data: VariantOptions) => void, type: string, p: (a: any) => any): any {
+    return {
+        finish(this: T & { text: string }) {
+            _setValue({
+                arrayType: VariantArrayType.Scalar,
+                dataType: (DataType as any)[type],
+                value: p(this.text)
+            });
+        }
+    };
+}
+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)[];
+    listExtensionObjectXML: { xmlEncodingNodeId: NodeId; bodyXML: string }[];
+    parser: {
+        ExtensionObject: ParserLike;
+    };
+}
+
+
+
+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,
+): ReaderStateParserLike {
+
+    let self: T;
+    const setValue2 = (data: VariantOptions) => {
+        setValue(self, data);
+    }
+    const reader = {
+        init(this: ReaderStateParserLike) {
+            /* empty */
+            self = this as T;
+        },
+        parser: {
+            QualifiedName: {
+                ...makeQualifiedNameParser(translateNodeId).QualifiedName,
+                finish(this: any) {
+                    setValue2({
+                        dataType: DataType.QualifiedName,
+                        value: coerceQualifiedName({...this.qualifiedName})
+                    });
+                }
+            },
+            LocalizedText: {
+                ...localizedText_parser.LocalizedText,
+                finish(this: any) {
+                    setValue2({
+                        dataType: DataType.LocalizedText,
+                        value: coerceLocalizedText({...this.localizedText})
+                    });
+                }
+            },
+            XmlElement: {
+                finish(this: any) {
+                    setValue2({
+                        dataType: DataType.XmlElement,
+                        value: this.text
+                    });
+                }
+            },
+            String: {
+                finish(this: any) {
+                    setValue2({
+                        dataType: DataType.String,
+                        value: this.text
+                    });
+                }
+            },
+            Guid: {
+                parser: {
+                    String: {
+                        finish(this: any) {
+                            const guid = this.text;
+                            if (!isValidGuid(guid)) {
+                                /* ?*/
+                            }
+                            setValue2({
+                                dataType: DataType.Guid,
+                                arrayType: VariantArrayType.Scalar,
+                                value: this.text
+                            });
+                        }
+                    }
+                }
+            },
+            NodeId: {
+                parser: {
+                    Identifier: {
+                        finish(this: any) {
+                            const nodeId = this.text;
+                            setValue2({
+                                dataType: DataType.NodeId,
+                                arrayType: VariantArrayType.Scalar,
+                                value: translateNodeId(resolveNodeId(nodeId).toString())
+                            });
+                        }
+                    }
+                }
+            },
+            Boolean: parser2(setValue2, "Boolean", coerceBoolean),
+            Byte: parser2(setValue2, "Byte", parseInt),
+            Int16: parser2(setValue2, "Int16", parseInt),
+            Int32: parser2(setValue2, "Int32", parseInt),
+            Int8: parser2(setValue2, "Int8", parseInt),
+            SByte: parser2(setValue2, "SByte", parseInt),
+            UInt16: parser2(setValue2, "UInt16", parseInt),
+            UInt32: parser2(setValue2, "UInt32", parseInt),
+            UInt8: parser2(setValue2, "UInt8", parseInt),
+
+            UInt64: parser2(setValue2, "UInt64", parseUInt64),
+            Int64: parser2(setValue2, "Int64", parseInt64),
+
+            ByteString: {
+                init(this: any) {
+                    this.value = null;
+                },
+                finish(this: any) {
+                    const base64text = this.text;
+                    const byteString = Buffer.from(base64text, "base64");
+                    setValue2({
+                        arrayType: VariantArrayType.Scalar,
+                        dataType: DataType.ByteString,
+                        value: byteString
+                    });
+                }
+            },
+            Float: {
+                finish(this: any) {
+                    setValue2({
+                        dataType: DataType.Float,
+                        value: parseFloat(this.text)
+                    });
+                }
+            },
+
+            Double: {
+                finish(this: any) {
+                    setValue2({
+                        dataType: DataType.Double,
+                        value: parseFloat(this.text)
+                    });
+                }
+            },
+
+            ExtensionObject: makeExtensionObjectInnerParser<ListOfExtensionObjectParser>(
+                translateNodeId,
+                (extensionObject: ExtensionObject) => {
+                    setValue2({
+                        dataType: DataType.ExtensionObject,
+                        value: extensionObject
+                    });
+                },
+                (xmlEncodingNodeId: NodeId, bodyXML: string, data) => {
+
+                    let _capturedExtensionObject: ExtensionObject | ExtensionObject[] | null = null;
+                    // extension object creation will be postponed
+                    const task0 = createXMLExtensionObjectDecodingTask(
+                        translateNodeId,
+                        xmlEncodingNodeId,
+                        bodyXML,
+                        (extensionObject: ExtensionObject) => {
+                            _capturedExtensionObject = extensionObject;
+                        });
+                    postExtensionObjectDecoding(task0);
+                    setDeferredValue(self, {
+                        dataType: DataType.ExtensionObject,
+                        arrayType: VariantArrayType.Scalar,
+                        value: null
+                    }, () => _capturedExtensionObject);
+                }
+            ),
+
+            ListOfExtensionObject: {
+                init(this: ListOfExtensionObjectParser) {
+                    this.listExtensionObject = [];
+                    this.listExtensionObjectXML = [];
+                    this.isDeferred = false;
+                },
+                parser: makeExtensionObjectParser<ListOfExtensionObjectParser>(
+                    translateNodeId,
+                    (extensionOject: ExtensionObject, self) => {
+                        // const self = reader.parser!.ListOfExtensionObject as ListOfExtensionObjectParser;
+                        self.listExtensionObject.push(extensionOject);
+                    },
+                    (xmlEncodingNodeId: NodeId, bodyXML: string, self) => {
+                        // constœ self = reader.parser!.ListOfExtensionObject as ListOfExtensionObjectParser;
+                        self.isDeferred = true;
+                        self.listExtensionObjectXML.push({ xmlEncodingNodeId, bodyXML });
+                        // extension object creation will be postponed
+                        self.listExtensionObject.push(null);
+                        const index = self.listExtensionObject.length - 1;
+                        assert(index >= 0);
+                        let listExtensionObject = self.listExtensionObject;
+                        const task0 = createXMLExtensionObjectDecodingTask(
+                            translateNodeId,
+                            xmlEncodingNodeId,
+                            bodyXML,
+                            (extensionObject: ExtensionObject) => {
+                                listExtensionObject[index] = extensionObject;
+                            });
+                        postExtensionObjectDecoding(task0);
+                    }
+                ),
+                finish(this: ListOfExtensionObjectParser) {
+                    if (!this.isDeferred) {
+                        setValue2({
+                            arrayType: VariantArrayType.Array,
+                            dataType: DataType.ExtensionObject,
+                            value: this.listExtensionObject
+                        });
+                    } else {
+                        // postpone the creation of the extension object
+                        const listExtensionObject: ExtensionObject[] = this.listExtensionObject as any;
+                        setDeferredValue(self,
+                            {
+                                arrayType: VariantArrayType.Array,
+                                dataType: DataType.ExtensionObject,
+                                value: null
+                            },
+                            () => listExtensionObject,
+                        );
+                        this.listExtensionObject = [];
+                    }
+                },
+            },
+
+            ListOfLocalizedText: {
+                init(this: ListOfTParser<LocalizedTextOptions>) {
+                    this.listData = [];
+                },
+                parser: {
+                    ...localizedText_parser
+                },
+                endElement(this: ListOfTParser<QualifiedNameOptions> /*element*/) {
+                    this.listData.push(this.parser.LocalizedText.value);
+                },
+                finish(this: ListOfTParser<QualifiedNameOptions>) {
+                    setValue2({
+                        arrayType: VariantArrayType.Array,
+                        dataType: DataType.LocalizedText,
+                        value: this.listData
+                    });
+                }
+            },
+            ListOfQualifiedName: {
+                init(this: ListOfTParser<QualifiedNameOptions>) {
+                    this.listData = [];
+                },
+                parser: makeQualifiedNameParser(translateNodeId),
+                endElement(this: ListOfTParser<QualifiedNameOptions> /*element*/) {
+                    this.listData.push(this.parser.QualifiedName.value);
+                },
+                finish(this: ListOfTParser<QualifiedNameOptions>) {
+                    setValue2({
+                        arrayType: VariantArrayType.Array,
+                        dataType: DataType.QualifiedName,
+                        value: this.listData
+                    });
+                }
+            },
+            ListOfNodeId: {
+                init(this: ListOfTParser<NodeIdLike>) {
+                    this.listData = [];
+                },
+                parser: makeNodeIdParser(translateNodeId),
+                endElement(this: ListOfTParser<NodeIdLike>, elementName: string) {
+                    this.listData.push(this.parser.NodeId.nodeId);
+                },
+                finish(this: ListOfTParser<NodeIdLike>) {
+                    setValue2({
+                        arrayType: VariantArrayType.Array,
+                        dataType: DataType.NodeId,
+                        value: this.listData
+                    });
+                }
+            },
+
+            ListOfBoolean: ListOf<boolean>(setValue2, "Boolean", coerceBoolean),
+
+            ListOfByte: ListOf<number>(setValue2, "Byte", parseInt),
+
+            ListOfDouble: ListOf<number>(setValue2, "Double", parseFloat),
+
+            ListOfFloat: ListOf<number>(setValue2, "Float", parseFloat),
+
+            ListOfInt32: ListOf<number>(setValue2, "Int32", parseInt),
+
+            ListOfInt16: ListOf<number>(setValue2, "Int16", parseInt),
+
+            ListOfInt8: ListOf<number>(setValue2, "Int8", parseInt),
+
+            ListOfUInt32: ListOf<number>(setValue2, "UInt32", parseInt),
+
+            ListOfUInt16: ListOf<number>(setValue2, "UInt16", parseInt),
+
+            ListOfUInt8: ListOf<number>(setValue2, "UInt8", parseInt),
+
+            ListOfString: ListOf<string>(setValue2, "String", (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,9 +1,6 @@
-import { NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
-import { UAObject, UAVariable } from "node-opcua-address-space-base";
-
+import { resolveNodeId } from "node-opcua-nodeid";
 import { g_promotableObject, Promoter } from "./namespace_post_step";
 
 export function registerNodePromoter(standardNodeId: number, promoter: Promoter, onInstanceOnly = false): void {
-    
-    g_promotableObject[resolveNodeId(standardNodeId).toString()] = { promoter, onInstanceOnly };
+    g_promotableObject.set(resolveNodeId(standardNodeId).toString(),{ promoter, onInstanceOnly });
 }

package/source/session_context.ts

@@ -193,7 +193,7 @@ export class SessionContext implements ISessionContext {
 
     public object: any;
     public currentTime?: PreciseClock;
-    public continuationPoints: any = {};
+    public continuationPoints: Buffer[] = [];
     public userIdentity?: string;
     public readonly session?: ISessionBase;
     public readonly server?: IServerBase;

package/source/ua_addin.ts

@@ -0,0 +1,52 @@
+import { ModellingRuleType, UAObject, UAObjectType, UAVariableT } from "node-opcua-address-space-base";
+import { DataType } from "node-opcua-basic-types";
+import { coerceQualifiedName, QualifiedName, QualifiedNameLike } from "node-opcua-data-model";
+
+export interface InstantiateAddInOptions {
+    defaultName?: QualifiedNameLike;
+    modellingRule?: ModellingRuleType;
+    addInOf: UAObject | UAObjectType;
+    copyAlsoModellingRules?: boolean;
+}
+
+export function instantiateAddIn(objectType: UAObjectType, options: InstantiateAddInOptions): UAObject {
+
+    let defaultName = options.defaultName;
+    // check that objectType has he shape of an addInd
+    const defaultInstanceBrowseName = objectType.getPropertyByName("DefaultInstanceBrowseName");
+    if (!defaultInstanceBrowseName) {
+        throw new Error("objectType must have a DefaultInstanceBrowseName property");
+    }
+
+    const browseName = coerceQualifiedName(defaultName || defaultInstanceBrowseName.readValue().value.value as QualifiedName);
+    const addIn = objectType.instantiate({
+        namespace: objectType.namespace,
+        browseName: browseName,
+        modellingRule: options.modellingRule,
+        copyAlsoModellingRules: options.copyAlsoModellingRules,
+    });
+    options.addInOf.addReference({
+        referenceType: "HasAddIn",
+        nodeId: addIn.nodeId
+    })
+    return addIn;
+}
+
+export function addDefaultInstanceBrowseName(objectType: UAObjectType, defaultBrowseName: string)
+    : UAVariableT<QualifiedName, DataType.QualifiedName> {
+
+    const namespace1 = objectType.namespace;
+    const uaVaraible = namespace1.addVariable({
+        browseName: coerceQualifiedName({ name: "DefaultInstanceBrowseName", namespaceIndex: 0 }),
+        propertyOf: objectType,
+        typeDefinition: "PropertyType",
+        dataType: DataType.QualifiedName,
+        value: {
+            dataType: DataType.QualifiedName,
+            value: { namespaceIndex: namespace1.index, name: defaultBrowseName }
+        },
+        modellingRule: null
+    });
+    return uaVaraible as UAVariableT<QualifiedName, DataType.QualifiedName>;
+
+}

package/source/ua_interface.ts

@@ -0,0 +1,38 @@
+
+
+import { UAObject, UAObjectType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
+import { BrowseDirection } from "node-opcua-data-model";
+
+export function implementInterface(uaNode: UAObject | UAObjectType | UAVariable | UAVariableType, interfaceType: UAObjectType) {
+
+    const addressSpace = uaNode.addressSpace;
+    const tmp = interfaceType.instantiate({
+        browseName: "_tmp_",
+        copyAlsoModellingRules: true,
+        copyAlsoAllOptionals: true,
+        modellingRule: "Mandatory"
+    });
+    // 
+    uaNode.addReference({
+        nodeId: interfaceType,
+        referenceType: "HasInterface"
+    });
+    const childrenRef = tmp.findReferencesEx("HasChild", BrowseDirection.Forward);
+    // transfer children to uaNode
+    for (const childRef of childrenRef) {
+
+        tmp.removeReference({
+            nodeId: childRef.nodeId,
+            referenceType: childRef.referenceType,
+            isForward: childRef.isForward
+        });
+        uaNode.addReference({
+            nodeId: childRef.nodeId,
+            referenceType: childRef.referenceType,
+            isForward: childRef.isForward
+        });
+    }
+    addressSpace.deleteNode(tmp);
+    console.log(uaNode.toString());
+
+}

package/source/xml_writer.ts

@@ -1,10 +1,9 @@
-export interface ITranslationTable {
-    [key: number]: number;
-}
+export type TranslationTable = Map<number, number>;
+
 export interface XmlWriter {
-    translationTable: ITranslationTable;
+    translationTable: TranslationTable;
     priorityTable: number[];
-    visitedNode: any;
+    visitedNode: Set<any>;
 
     startDocument(options: { encoding: string; version: string }): void;
     startElement(elementName: string): this;

package/src/_instantiate_helpers.ts

@@ -47,6 +47,7 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
     topMostType: T,
     typeDefinitionNode: T,
     copyAlsoModellingRules: boolean,
+    copyAlsoAllOptionals: boolean,
     optionalsMap: OptionalMap,
     extraInfo: CloneHelper,
     browseNameMap: Set<string>
@@ -65,7 +66,7 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
         return; // nothing to do
     }
 
-    const filter = new MandatoryChildOrRequestedOptionalFilter(instance, optionalsMap);
+    const filter = new MandatoryChildOrRequestedOptionalFilter(instance, copyAlsoAllOptionals, optionalsMap);
 
     doTrace &&
         traceLog(
@@ -99,6 +100,7 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
         topMostType,
         baseTypeDefinition,
         copyAlsoModellingRules,
+        copyAlsoAllOptionals,
         optionalsMap,
         extraInfo,
         browseNameMap
@@ -109,7 +111,10 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
 export function initialize_properties_and_components<
     B extends UAObject | UAVariable | UAMethod,
     T extends UAVariableType | UAObjectType
->(instance: B, topMostType: T, nodeType: T, copyAlsoModellingRules: boolean, optionals?: string[]): void {
+>(instance: B, topMostType: T, nodeType: T,
+    copyAlsoModellingRules: boolean,
+    copyAlsoAllOptionals: boolean,
+    optionals?: string[]): void {
     const extraInfo = new CloneHelper();
 
     extraInfo.pushContext({
@@ -130,6 +135,7 @@ export function initialize_properties_and_components<
         topMostType,
         nodeType,
         copyAlsoModellingRules,
+        copyAlsoAllOptionals,
         optionalsMap,
         extraInfo,
         browseNameMap

package/src/_mandatory_child_or_requested_optional_filter.ts

@@ -12,14 +12,16 @@ const errorLog = make_errorLog(__filename);
 const doTrace = checkDebugFlag("INSTANTIATE");
 const traceLog = errorLog;
 
+export type OptionalMap = Record<string, string | Record<string, any>>;
 export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
     private readonly instance: BaseNode;
-    private readonly optionalsMap: any;
+    private readonly optionalsMap: OptionalMap;
     private readonly references: UAReference[];
+    private readonly copyAlsoAllOptionals: boolean = false;
 
-    constructor(instance: BaseNode, optionalsMap: any) {
+    constructor(instance: BaseNode, copyAlsoAllOptionals: boolean, optionalsMap: OptionalMap) {
+        this.copyAlsoAllOptionals = copyAlsoAllOptionals;
         // should we clone the node to be a component or propertyOf of a instance
-        assert(optionalsMap !== null && typeof optionalsMap === "object");
         assert(null !== instance);
         this.optionalsMap = optionalsMap;
         this.instance = instance;
@@ -74,7 +76,7 @@ export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
                 return true; // keep;
             case "Optional":
                 // only if in requested optionals
-                return node.browseName!.name! in this.optionalsMap;
+                return this.copyAlsoAllOptionals || (node.browseName!.name! in this.optionalsMap);
             case "OptionalPlaceholder":
                 return false; // ignored
             default:
@@ -85,14 +87,14 @@ export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
     public filterFor(childInstance: UAVariable | UAObject | UAMethod): CloneFilter {
         const browseName: string = childInstance.browseName.name!;
 
-        let map = {};
+        let map: OptionalMap = Object.create(null);
 
         if (browseName in this.optionalsMap) {
-            map = this.optionalsMap[browseName];
+            map = this.optionalsMap[browseName] as any;
         }
         // istanbul ignore next
         doTrace && traceLog("filterFor ", browseName, map);
-        const newFilter = new MandatoryChildOrRequestedOptionalFilter(childInstance, map);
+        const newFilter = new MandatoryChildOrRequestedOptionalFilter(childInstance, false, map);
         return newFilter;
     }
 }

package/src/address_space.ts

@@ -162,7 +162,7 @@ export class AddressSpace implements AddressSpacePrivate {
      */
     public suspendBackReference = false;
     public isFrugal = false;
-    public historizingNodes?: { [key: string]: UAVariable } = {};
+    public historizingNodes: Set<UAVariable> = new Set();
     public _condition_refresh_in_progress = false;
 
     public readonly isNodeIdString = isNodeIdString;