node-opcua-address-space 2.59.0 → 2.60.0

package/source/helpers/argument_list.ts

@@ -6,13 +6,13 @@ import * as ec from "node-opcua-basic-types";
 import { BinaryStream, BinaryStreamSizeCalculator, OutputBinaryStream } from "node-opcua-binary-stream";
 import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
 import * as factories from "node-opcua-factory";
-import { NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { coerceNodeId, NodeId, resolveNodeId } from "node-opcua-nodeid";
 import { Argument } from "node-opcua-service-call";
 import { StatusCode, StatusCodes } from "node-opcua-status-code";
 import { Variant } from "node-opcua-variant";
 import { DataType } from "node-opcua-variant";
 import { VariantArrayType } from "node-opcua-variant";
-
+import { DataTypeIds } from "node-opcua-constants";
 import { NodeClass } from "node-opcua-data-model";
 import { IAddressSpace, UAMethod, UAObject } from "node-opcua-address-space-base";
 
@@ -181,7 +181,17 @@ function isArgumentValid(addressSpace: IAddressSpace, argDefinition: Argument, a
     }
 
     // check that dataType is of the same type (derived )
-    return argDefDataType.isSupertypeOf(argDataType);
+    if (argDefDataType.isSupertypeOf(argDataType)) {
+        return true;
+    }
+    // special case for Enumeration
+    if (arg.dataType === DataType.Int32) {
+        const enumDataType = addressSpace.findDataType(coerceNodeId(DataTypeIds.Enumeration))!;
+        if (argDefDataType.isSupertypeOf(enumDataType)) {
+            return true;
+        }
+    }
+    return false;
 }
 
 /**

package/source/loader/load_nodeset2.ts

@@ -15,7 +15,7 @@ import {
     UAVariableType
 } from "node-opcua-address-space-base";
 import { assert, renderError } from "node-opcua-assert";
-import { isValidGuid, StatusCodes } from "node-opcua-basic-types";
+import { Int64, isValidGuid, StatusCodes } from "node-opcua-basic-types";
 import { ExtraDataTypeManager, populateDataTypeManager } from "node-opcua-client-dynamic-extension-object";
 import { EUInformation } from "node-opcua-data-access";
 import {
@@ -27,13 +27,21 @@ import {
     QualifiedNameOptions,
     stringToQualifiedName
 } from "node-opcua-data-model";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
 import { DataTypeFactory, findSimpleType, getStandardDataTypeFactory } from "node-opcua-factory";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
 import { Argument } from "node-opcua-service-call";
 import { CallbackT, ErrorCallback } from "node-opcua-status-code";
-import { EnumDefinition, EnumValueType, Range, StructureDefinition, StructureFieldOptions, StructureType } from "node-opcua-types";
+import {
+    EnumDefinition,
+    EnumFieldOptions,
+    EnumValueType,
+    Range,
+    StructureDefinition,
+    StructureFieldOptions,
+    StructureType
+} from "node-opcua-types";
 import { DataType, Variant, VariantArrayType, VariantOptions } from "node-opcua-variant";
 import {
     _definitionParser,
@@ -56,6 +64,7 @@ import { promoteObjectsAndVariables } from "./namespace_post_step";
 
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
+const errorLog = make_errorLog(__filename);
 
 export async function ensureDatatypeExtracted(addressSpace: IAddressSpace): Promise<ExtraDataTypeManager> {
     const addressSpacePriv: any = addressSpace as AddressSpacePrivate;
@@ -151,39 +160,6 @@ async function decodeXmlObject(
     return userDefinedExtensionObject;
 }
 
-function makeEnumDefinition(definitionFields: any[]) {
-    return new EnumDefinition({
-        fields: definitionFields.map((x) => ({
-            description: {
-                text: x.description
-            },
-            name: x.name,
-            value: x.value
-        }))
-    });
-}
-function makeStructureDefinition(name: string, definitionFields: StructureFieldOptions[], isUnion: boolean): StructureDefinition {
-    // Structure = 0,
-    // StructureWithOptionalFields = 1,
-    // Union = 2,
-    const hasOptionalFields = definitionFields.filter((field) => field.isOptional).length > 0;
-
-    const structureType = isUnion
-        ? StructureType.Union
-        : hasOptionalFields
-        ? StructureType.StructureWithOptionalFields
-        : StructureType.Structure;
-
-    const sd = new StructureDefinition({
-        baseDataType: undefined,
-        defaultEncodingId: undefined,
-        fields: definitionFields,
-        structureType
-    });
-
-    return sd;
-}
-
 function __make_back_references(namespace: INamespace) {
     const namespaceP = namespace as NamespacePrivate;
     for (const node of namespaceP.nodeIterator()) {
@@ -219,14 +195,21 @@ function makeDefaultVariant2(addressSpace: IAddressSpace, dataTypeNode: NodeId,
 function makeDefaultVariant(addressSpace: IAddressSpace, dataTypeNode: NodeId, valueRank: number): VariantOptions | undefined {
     let variant: VariantOptions = { dataType: DataType.Null };
 
-    const nodeDataType = addressSpace.findNode(dataTypeNode);
+    const nodeDataType = addressSpace.findNode(dataTypeNode) as UADataType;
     if (nodeDataType) {
-        const dataType = addressSpace.findCorrespondingBasicDataType(dataTypeNode);
-        if (dataType === DataType.ExtensionObject) {
+    
+        const basicDataType = nodeDataType.basicDataType;
+        if (basicDataType === DataType.Variant) {
+            /// we don't now what is the variant
+            return undefined
+        }
+
+        //  addressSpace.findCorrespondingBasicDataType(dataTypeNode);
+        if (basicDataType === DataType.ExtensionObject) {
             // console.log("xxxxxxxxxx ", dataTypeNode.toString(addressSpace as any));
             return { dataType: DataType.ExtensionObject, value: null };
         }
-        const dv = findSimpleType(DataType[dataType]).defaultValue;
+        const dv = findSimpleType(DataType[basicDataType]).defaultValue;
         if (dv === undefined || dv === null) {
             // return
             return { dataType: DataType.Null };
@@ -247,16 +230,16 @@ function makeDefaultVariant(addressSpace: IAddressSpace, dataTypeNode: NodeId, v
             case -2: // any
             case -1:
                 arrayType = VariantArrayType.Scalar;
-                variant = { dataType, value, arrayType };
+                variant = { dataType: basicDataType, value, arrayType };
                 break;
             case 0: // one or more dimension
             case 1: // one dimension
                 arrayType = VariantArrayType.Array;
-                variant = { dataType, value: [], arrayType };
+                variant = { dataType: basicDataType, value: [], arrayType };
                 break;
             default:
                 arrayType = VariantArrayType.Matrix;
-                variant = { dataType, value: [], arrayType, dimensions: [] };
+                variant = { dataType: basicDataType, value: [], arrayType, dimensions: [] };
                 break;
         }
         // console.log(variant, DataType[dataType], valueRank);
@@ -445,7 +428,6 @@ export function makeStuff(addressSpace: IAddressSpace): any {
 
             this.isDraft = attrs.ReleaseStatus === "Draft";
             this.obj.isDeprecated = attrs.ReleaseStatus === "Deprecated";
-
         },
         finish(this: any) {
             if (this.isDraft || this.isDeprecated) {
@@ -558,49 +540,52 @@ export function makeStuff(addressSpace: IAddressSpace): any {
                 debugLog("Ignoring Draft/Deprecated dataType =", this.obj.browseName.toString());
                 return;
             }
-            let definitionFields = this.definitionFields;
-            // replace DataType with nodeId
-            definitionFields = definitionFields.map((x: any) => {
+            /*
+            export interface StructureFieldOptions {
+                name?: UAString ; // **
+                description?: (LocalizedTextLike | null); // **
+                dataType?: (NodeIdLike | null);
+                valueRank?: Int32 ;
+                arrayDimensions?: UInt32 [] | null;
+                maxStringLength?: UInt32 ;
+                isOptional?: UABoolean ;
+            }
+            export interface EnumValueTypeOptions {
+                value?: Int64 ;
+                displayName?: (LocalizedTextLike | null);
+                description?: (LocalizedTextLike | null); // **
+            }
+            export interface EnumFieldOptions extends EnumValueTypeOptions {
+                name?: UAString ; // **
+            }
+            */
+
+            const definitionFields = this.definitionFields as StructureFieldOptions[] | EnumFieldOptions[];
+
+            // replace DataType with nodeId, and description to LocalizedText
+            definitionFields.map((x: any) => {
+                if (x.description) {
+                    x.description = { text: x.description };
+                }
+                if (x.displayName) {
+                    x.displayName = { text: x.displayName };
+                }
                 if (x.dataType) {
                     x.dataType = convertToNodeId(x.dataType);
                 }
                 return x;
             });
-
+            this.obj.partialDefinition = definitionFields;
+         
             const dataTypeNode = _internal_createNode(this.obj) as UADataType;
             assert(addressSpace1.findNode(this.obj.nodeId));
             const definitionName = dataTypeNode.browseName.name!;
 
-            let alreadyCalled = false;
             const processBasicDataType = async (addressSpace2: IAddressSpace) => {
-                assert(!alreadyCalled);
-                alreadyCalled = true;
-
-                const enumeration = addressSpace2.findDataType("Enumeration");
-                const structure = addressSpace2.findDataType("Structure");
-                const union = addressSpace2.findDataType("Union");
-
-                // we have a data type from a companion specification
-                // let's see if this data type need to be registered
-                const isEnumeration = enumeration && dataTypeNode.isSupertypeOf(enumeration);
-                const isStructure = structure && dataTypeNode.isSupertypeOf(structure);
-                const isUnion = !!(structure && union && dataTypeNode.isSupertypeOf(union!));
-
-                if (definitionFields.length) {
-                    // remove <namespace>:
-                    const nameWithoutNamespace = definitionName.split(":").slice(-1)[0];
-
-                    if (isStructure /*&& dataTypeNode.nodeId.namespace !== 0*/) {
-                        // note: at this stage, structure definition will be incomplete as we do not know
-                        //       what is the subType yet, encodings are also unknown...
-                        //       structureType may also be inaccurate
-                        debugLog("setting structure $definition for ", definitionName, nameWithoutNamespace);
-                        (dataTypeNode as any).$definition = makeStructureDefinition(definitionName, definitionFields, isUnion);
-                    } else if (isEnumeration /* && dataTypeNode.nodeId.namespace !== 0 */) {
-                        (dataTypeNode as any).$definition = makeEnumDefinition(definitionFields);
-                    }
-                }
-                if (!isEnumeration && !isStructure && this.obj.nodeId.namespace !== 0) {
+                const isStructure = dataTypeNode.isStructure();
+                const isEnumeration = dataTypeNode.isEnumeration();
+                if (!isEnumeration && !isStructure && dataTypeNode.nodeId.namespace !== 0) {
+                    // add a custom basic type that is not a structure nor a enumeration
                     pendingSimpleTypeToRegister.push({ name: definitionName, dataTypeNodeId: dataTypeNode.nodeId });
                 }
             };
@@ -1289,7 +1274,6 @@ export function makeStuff(addressSpace: IAddressSpace): any {
 
             this.isDraft = attrs.ReleaseStatus === "Draft";
             this.isDeprecated = attrs.ReleaseStatus === "Deprecated";
-            
         },
         finish(this: any) {
             if (this.isDraft || this.isDeprecated) {
@@ -1316,6 +1300,8 @@ export function makeStuff(addressSpace: IAddressSpace): any {
                 };
                 postTaskInitializeVariable.push(task);
             } else {
+                const captureName = this.obj.browseName.toString();
+                const captureNodeId = this.obj.nodeId;
                 const task = async (addressSpace2: IAddressSpace) => {
                     const dataTypeNode = variable.dataType;
                     const valueRank = variable.valueRank;
@@ -1374,7 +1360,6 @@ export function makeStuff(addressSpace: IAddressSpace): any {
 
             this.isDraft = attrs.ReleaseStatus === "Draft";
             this.isDeprecated = attrs.ReleaseStatus === "Deprecated";
-
         },
         finish(this: any) {
             if (this.isDraft || this.isDeprecated) {
@@ -1420,7 +1405,6 @@ export function makeStuff(addressSpace: IAddressSpace): any {
 
             this.isDraft = attrs.ReleaseStatus === "Draft";
             this.isDeprecated = attrs.ReleaseStatus === "Deprecated";
-
         },
         finish(this: any) {
             if (this.isDraft || this.isDeprecated) {

package/source/set_namespace_meta_data.ts

@@ -54,7 +54,7 @@ export function setNamespaceMetaData(namespace: INamespace): void {
         {
             get: () =>
                 new Variant({
-                    dataType: DataType.UInt32,
+                    dataType: DataType.UInt16,
                     value: namespace.getDefaultAccessRestrictions()
                 })
         },

package/src/address_space.ts

@@ -10,7 +10,7 @@ import { ExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object
 import { DataTypeIds, VariableTypeIds } from "node-opcua-constants";
 import { BrowseDirection, NodeClass, QualifiedName } from "node-opcua-data-model";
 import { ExtensionObject } from "node-opcua-extension-object";
-import { coerceExpandedNodeId, makeNodeId, NodeId, NodeIdLike, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import { coerceExpandedNodeId, coerceNodeId, makeNodeId, NodeId, NodeIdLike, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { ObjectRegistry } from "node-opcua-object-registry";
 import { BrowseResult } from "node-opcua-service-browse";
 import { StatusCodes } from "node-opcua-status-code";
@@ -69,7 +69,8 @@ const doDebug = false;
 const Dequeue = require("dequeue");
 
 const regexNumberColumnString = /^([0-9]+):(.*)/;
-
+const enumerationTypeNodeId = coerceNodeId(DataTypeIds.Enumeration);
+ 
 function _extract_namespace_and_browse_name_as_string(
     addressSpace: AddressSpace,
     browseName: NodeIdLike | QualifiedName,
@@ -472,10 +473,8 @@ export class AddressSpace implements AddressSpacePrivate {
                     dataTypeNode.constructor.name
             );
         }
-        dataTypeNode = dataTypeNode as UADataType;
-
-        const enumerationType = this.findDataType("Enumeration")!;
-        if (sameNodeId(enumerationType.nodeId, dataTypeNode!.nodeId)) {
+        
+        if (sameNodeId(enumerationTypeNodeId, dataTypeNode!.nodeId)) {
             return DataType.Int32;
         }
 
@@ -483,11 +482,18 @@ export class AddressSpace implements AddressSpacePrivate {
             // Number
             return DataType.Null; //which one ?
         }
-
-        if (dataTypeNode.nodeId.namespace === 0 && DataType[dataTypeNode.nodeId.value as number]) {
+ 
+        if (dataTypeNode.nodeId.namespace === 0 && dataTypeNode.nodeId.value === 0) {
+            return DataType.Null;
+        }
+ 
+        if (dataTypeNode.nodeId.namespace === 0 && dataTypeNode.nodeId.value <= 25) {
             return dataTypeNode.nodeId.value as DataType;
         }
-        return this.findCorrespondingBasicDataType(dataTypeNode.subtypeOfObj as UADataType);
+ 
+        const result =  this.findCorrespondingBasicDataType(dataTypeNode.subtypeOfObj as UADataType);
+ 
+        return result;
     }
 
     /**

package/src/alarms_and_conditions/condition_snapshot.ts

@@ -9,7 +9,7 @@ import { UInt16 } from "node-opcua-basic-types";
 import { coerceLocalizedText, LocalizedText, LocalizedTextLike, NodeClass } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
 import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
-import { NodeId } from "node-opcua-nodeid";
+import { NodeId, sameNodeId } from "node-opcua-nodeid";
 import { UAAcknowledgeableCondition } from "node-opcua-nodeset-ua";
 import { StatusCode, StatusCodes } from "node-opcua-status-code";
 import { SimpleAttributeOperand, TimeZoneDataType } from "node-opcua-types";
@@ -175,14 +175,14 @@ export class ConditionSnapshot extends EventEmitter {
         // a nodeId/Variant map
         _record_condition_state(this, condition);
 
-        if (branchId === NodeId.nullNodeId) {
+        if (sameNodeId(branchId, NodeId.nullNodeId)) {
             _installOnChangeEventHandlers(this, condition, "");
         }
         this._set_var("branchId", DataType.NodeId, branchId);
     }
 
     public _constructEventData(): IEventData {
-        if (this.branchId === NodeId.nullNodeId) {
+        if (this.branchId && sameNodeId(this.branchId, NodeId.nullNodeId)) {
             _ensure_condition_values_correctness(this, this.condition!, "", []);
         }
         const c = this.condition as UAConditionImpl;
@@ -594,7 +594,7 @@ export class ConditionSnapshot extends EventEmitter {
     }
 
     public isCurrentBranch(): boolean {
-        return this._get_var("branchId") === NodeId.nullNodeId;
+        return sameNodeId(this._get_var("branchId"), NodeId.nullNodeId);
     }
 
     // -- ACKNOWLEDGEABLE -------------------------------------------------------------------

package/src/alarms_and_conditions/ua_alarm_condition_impl.ts

@@ -6,7 +6,7 @@ import { isEqual } from "lodash";
 import { assert } from "node-opcua-assert";
 import { NodeClass } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
-import { NodeId } from "node-opcua-nodeid";
+import { NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType } from "node-opcua-variant";
 import { UAAlarmCondition_Base } from "node-opcua-nodeset-ua";
@@ -498,7 +498,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
                 if (this.currentBranch().getRetain()) {
                     // we need to create a new branch so the previous state could be acknowledged
                     const newBranch = this.createBranch();
-                    assert(newBranch.getBranchId() !== NodeId.nullNodeId);
+                    assert(!sameNodeId(newBranch.getBranchId(), NodeId.nullNodeId));
                     // also raised a new Event for the new branch as branchId has changed
                     this.raiseNewBranchState(newBranch);
                 }

package/src/alarms_and_conditions/ua_condition_impl.ts

@@ -238,7 +238,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
      */
     public post_initialize(): void {
         assert(!this._branch0);
-        this._branch0 = new ConditionSnapshot(this, NodeId.nullNodeId);
+        this._branch0 = new ConditionSnapshot(this, new NodeId());
 
         // the condition OPCUA object alway reflects the default branch states
         // so we set a mechanism that automatically keeps self in sync
@@ -284,7 +284,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
      */
     public deleteBranch(branch: ConditionSnapshot): void {
         const key = branch.getBranchId().toString();
-        assert(branch.getBranchId() !== NodeId.nullNodeId, "cannot delete branch zero");
+        assert(!sameNodeId(branch.getBranchId(), NodeId.nullNodeId), "cannot delete branch zero");
         assert(Object.prototype.hasOwnProperty.call(this._branches, key));
         delete this._branches[key];
         this.emit("branch_deleted", key);
@@ -560,7 +560,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
     public raiseNewBranchState(branch: ConditionSnapshot): void {
         this.raiseConditionEvent(branch, true);
 
-        if (branch.getBranchId() !== NodeId.nullNodeId && !branch.getRetain()) {
+        if (!sameNodeId(branch.getBranchId(), NodeId.nullNodeId) && !branch.getRetain()) {
             // xx console.log(" Deleting not longer needed branch ", branch.getBranchId().toString());
             // branch can be deleted
             this.deleteBranch(branch);
@@ -789,7 +789,7 @@ function UACondition_instantiate(
     // install initial branch ID (null NodeId);
     conditionNode.branchId.setValueFromSource({
         dataType: DataType.NodeId,
-        value: NodeId.nullNodeId
+        value: new NodeId()
     });
 
     // install 'Comment' condition variable
@@ -920,7 +920,9 @@ function UACondition_instantiate(
             conditionNode.sourceNode.setValueFromSource(conditionSourceNode.readAttribute(null, AttributeIds.NodeId).value);
 
             // set source Name (defined in UABaseEventType)
-            conditionNode.sourceName.setValueFromSource(conditionSourceNode.readAttribute(null, AttributeIds.DisplayName).value);
+            const displayName: LocalizedText = conditionSourceNode.readAttribute(null, AttributeIds.DisplayName).value
+                .value as LocalizedText;
+            conditionNode.sourceName.setValueFromSource({ dataType: DataType.String, value: displayName.text });
         }
     }
 
@@ -953,7 +955,7 @@ function UACondition_instantiate(
      */
     const baseConditionClassType = addressSpace.findObjectType("ProcessConditionClassType");
     // assert(baseConditionClassType,"Expecting BaseConditionClassType to be in addressSpace");
-    let conditionClassId = baseConditionClassType ? baseConditionClassType.nodeId : NodeId.nullNodeId;
+    let conditionClassId = baseConditionClassType ? baseConditionClassType.nodeId : new NodeId();
     let conditionClassName = baseConditionClassType ? baseConditionClassType.displayName[0] : "";
     if (options.conditionClass) {
         if (typeof options.conditionClass === "string") {
@@ -1123,7 +1125,11 @@ function _perform_condition_refresh(addressSpace: AddressSpacePrivate, inputArgu
     return StatusCodes.Good;
 }
 
-function _condition_refresh2_method(inputArguments: VariantLike[], context: ISessionContext, callback: CallbackT<CallMethodResultOptions>) {
+function _condition_refresh2_method(
+    inputArguments: VariantLike[],
+    context: ISessionContext,
+    callback: CallbackT<CallMethodResultOptions>
+) {
     // arguments : IntegerId SubscriptionId
     // arguments : IntegerId MonitoredItemId
     assert(inputArguments.length === 2);
@@ -1146,7 +1152,11 @@ function _condition_refresh2_method(inputArguments: VariantLike[], context: ISes
     });
 }
 
-function _add_comment_method(inputArguments: VariantLike[], context: ISessionContext, callback: CallbackT<CallMethodResultOptions>) {
+function _add_comment_method(
+    inputArguments: VariantLike[],
+    context: ISessionContext,
+    callback: CallbackT<CallMethodResultOptions>
+) {
     //
     // The AddComment Method is used to apply a comment to a specific state of a Condition
     // instance. Normally, the NodeId of the object instance as the ObjectId is passed to the Call

package/src/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -79,7 +79,7 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
         const normalState = addressSpace._coerceNode(options.normalState)! as UAVariable;
         //       assert(normalState, "Expecting a valid normalState node");
 
-        const normalStateNodeId = normalState ? normalState.nodeId : NodeId.nullNodeId;
+        const normalStateNodeId = normalState ? normalState.nodeId : new NodeId();
         alarmNode.normalState.setValueFromSource({ dataType: DataType.NodeId, value: normalStateNodeId });
 
         if (inputNode) {

package/src/base_node_private.ts

@@ -343,6 +343,10 @@ function AccessLevelFlags_toString(this: UAVariable, options: ToStringOption) {
         );
     }
 }
+
+interface WithDataValue {
+    $dataValue?: DataValue;
+}
 export function VariableOrVariableType_toString(this: UAVariableType | UAVariable, options: ToStringOption): void {
     assert(options);
     if (this.dataType) {
@@ -352,7 +356,7 @@ export function VariableOrVariableType_toString(this: UAVariableType | UAVariabl
         options.add(options.padding + chalk.yellow("          dataType            : ") + this.dataType + "  " + n);
     }
     if (this.nodeClass === NodeClass.Variable) {
-        const _dataValue = (<any>this)._dataValue as DataValue | undefined;
+        const _dataValue = (<WithDataValue>this).$dataValue as DataValue | undefined;
         if (_dataValue) {
             options.add(
                 options.padding +
@@ -622,7 +626,7 @@ function _makeReferenceDescription(addressSpace: IAddressSpace, reference: UARef
         };
     }
     if (data.typeDefinition === null) {
-        data.typeDefinition = NodeId.nullNodeId;
+        data.typeDefinition = new NodeId();
     }
     const referenceDescription = new ReferenceDescription(data);
     return referenceDescription;

package/src/event_data.ts

@@ -25,7 +25,7 @@ export class EventData implements IEventData {
 
     constructor(eventTypeNode: BaseNode) {
         this.__nodes = {};
-        this.eventId = NodeId.nullNodeId;
+        this.eventId = new NodeId();
         this.$eventDataSource = eventTypeNode;
     }
 

package/src/namespace_impl.ts

@@ -28,7 +28,7 @@ import {
     RolePermissionTypeOptions
 } from "node-opcua-types";
 import * as utils from "node-opcua-utils";
-import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+import { DataType, Variant, VariantArrayType, verifyRankAndDimensions } from "node-opcua-variant";
 import {
     AddBaseNodeOptions,
     AddEnumerationTypeOptions,
@@ -100,7 +100,7 @@ import { _install_TwoStateVariable_machinery, _addTwoStateVariable } from "./sta
 //
 import { NamespacePrivate, UANamespace_process_modelling_rule } from "./namespace_private";
 import { BaseNodeImpl } from "./base_node_impl";
-import { UAVariableImpl, verifyRankAndDimensions } from "./ua_variable_impl";
+import { UAVariableImpl } from "./ua_variable_impl";
 
 import { ConstructNodeIdOptions, NodeIdManager } from "./nodeid_manager";
 import { _addTwoStateDiscrete } from "./data_access/ua_two_state_discrete";
@@ -238,7 +238,7 @@ export class NamespaceImpl implements NamespacePrivate {
     }
 
     public getDefaultNamespace(): NamespacePrivate {
-        return this.index === 0 ? this : (this.addressSpace.getDefaultNamespace());
+        return this.index === 0 ? this : this.addressSpace.getDefaultNamespace();
     }
 
     public dispose(): void {
@@ -656,7 +656,7 @@ export class NamespaceImpl implements NamespacePrivate {
      */
     public deleteNode(nodeOrNodeId: NodeId | BaseNode): void {
         let node: BaseNode | null = null;
-        let nodeId: NodeId = NodeId.nullNodeId;
+        let nodeId: NodeId = new NodeId();
         if (nodeOrNodeId instanceof NodeId) {
             nodeId = nodeOrNodeId;
             node = this.findNode(nodeId);
@@ -1337,7 +1337,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).$definition = new EnumDefinition({
+            (enumType as any).$fullDefinition = new EnumDefinition({
                 fields: enumeration.map(
                     (x: string, index: number) =>
                         new EnumField({
@@ -1376,7 +1376,7 @@ export class NamespaceImpl implements NamespacePrivate {
             });
             assert(enumValues.browseName.toString() === "EnumValues");
 
-            (enumType as any).$definition = new EnumDefinition({
+            (enumType as any).$fullDefinition = new EnumDefinition({
                 fields: enumeration.map(
                     (x: EnumerationItem, index: number) =>
                         new EnumField({

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -592,7 +592,7 @@ function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, value: Var
 
 function _dumpArrayDimensionsAttribute(xw: XmlWriter, node: UAVariableType | UAVariable) {
     if (node.arrayDimensions) {
-        if (node.arrayDimensions.length === 1 && node.arrayDimensions[0] === 0) {
+        if (node.valueRank === -1 || (node.arrayDimensions.length === 1 && node.arrayDimensions[0] === 0)) {
             return;
         }
         xw.writeAttribute("ArrayDimensions", node.arrayDimensions.join(","));
@@ -749,7 +749,11 @@ function _dumpEnumDefinition(xw: XmlWriter, enumDefinition: EnumDefinition) {
         xw.endElement();
     }
 }
-function _dumpStructureDefinition(xw: XmlWriter, structureDefinition: StructureDefinition) {
+function _dumpStructureDefinition(
+    xw: XmlWriter,
+    structureDefinition: StructureDefinition,
+    baseStructureDefinition: StructureDefinition | null | undefined
+) {
     /*
      * note: baseDataType and defaultEncodingId are implicit and not stored in the XML file ??
      *
@@ -757,8 +761,12 @@ function _dumpStructureDefinition(xw: XmlWriter, structureDefinition: StructureD
     const baseDataType = structureDefinition.baseDataType;
     const defaultEncodingId = structureDefinition.defaultEncodingId;
 
-    structureDefinition.fields = structureDefinition.fields || [];
-    for (const defItem /*: StructureField*/ of structureDefinition.fields) {
+    // do not repeat elements that are already defined in base structure in the xml ouput!
+    const fields = structureDefinition.fields || [];
+    const nbFieldsInBase: number = baseStructureDefinition ? baseStructureDefinition.fields?.length || 0  : 0;
+
+    for(let index = nbFieldsInBase; index <fields.length; index++ ) {
+       const  defItem = fields[index];
         xw.startElement("Field");
         xw.writeAttribute("Name", defItem.name!);
 
@@ -788,27 +796,29 @@ function _dumpStructureDefinition(xw: XmlWriter, structureDefinition: StructureD
         xw.endElement();
     }
 }
-function _dumpUADataTypeDefinition(xw: XmlWriter, node: UADataType) {
+function _dumpUADataTypeDefinition(xw: XmlWriter, uaDataType: UADataType) {
     // to do remove DataType from base class
-
-    const definition = node.getDefinition();
+    const uaDataTypeBase = uaDataType.subtypeOfObj;
+    const definition = uaDataType.getDefinition();
     if (!definition) {
         return;
     }
     if (definition instanceof EnumDefinition) {
         xw.startElement("Definition");
-        xw.writeAttribute("Name", node.browseName.name!);
+        xw.writeAttribute("Name", uaDataType.browseName.name!);
         _dumpEnumDefinition(xw, definition);
         xw.endElement();
         return;
     }
     if (definition instanceof StructureDefinition) {
+        const baseDefinition = uaDataTypeBase ? (uaDataTypeBase.getDefinition() as StructureDefinition | null) : null;
+
         xw.startElement("Definition");
-        xw.writeAttribute("Name", node.browseName.name!);
+        xw.writeAttribute("Name", uaDataType.browseName.name!);
         if (definition.structureType === StructureType.Union) {
             xw.writeAttribute("IsUnion", "true");
         }
-        _dumpStructureDefinition(xw, definition);
+        _dumpStructureDefinition(xw, definition, baseDefinition);
         xw.endElement();
         return;
     }