node-opcua-address-space 2.77.0 → 2.79.0

package/dist/src/nodeset_tools/nodeset_to_xml.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dumpXml = void 0;
+/* eslint-disable complexity */
 /**
  * @module node-opcua-address-space
  */
 // produce nodeset xml files
 const node_opcua_assert_1 = require("node-opcua-assert");
+const node_opcua_constants_1 = require("node-opcua-constants");
 const node_opcua_debug_1 = require("node-opcua-debug");
 const node_opcua_data_model_1 = require("node-opcua-data-model");
 const node_opcua_nodeid_1 = require("node-opcua-nodeid");
@@ -23,6 +25,7 @@ const namespace_impl_1 = require("../namespace_impl");
 const ua_method_impl_1 = require("../ua_method_impl");
 const ua_data_type_impl_1 = require("../ua_data_type_impl");
 const ua_variable_type_impl_1 = require("../ua_variable_type_impl");
+const index_current_1 = require("../index_current");
 const decode_xml_extension_object_1 = require("../../source/loader/decode_xml_extension_object");
 const construct_namespace_dependency_1 = require("./construct_namespace_dependency");
 // tslint:disable:no-var-requires
@@ -63,6 +66,10 @@ function translateBrowseName(xw, browseName) {
 function b(xw, browseName) {
     return translateBrowseName(xw, browseName).toString().replace("ns=0;", "");
 }
+function _dumpReverseReferences(xw, node) {
+    const addressSpace = node.addressSpace;
+    const hasSubtypeReferenceType = addressSpace.findReferenceType("HasSubtype");
+}
 function _dumpReferences(xw, node) {
     xw.startElement("References");
     const addressSpace = node.addressSpace;
@@ -153,25 +160,54 @@ function _dumpQualifiedName(xw, v) {
 function _dumpXmlElement(xw, v) {
     xw.text(v);
 }
-/*
-<uax:ExtensionObject>
-    <uax:TypeId>
-        <uax:Identifier>i=339</uax:Identifier>
-    </uax:TypeId>
-    <uax:Body>
-        <BuildInfo xmlns="http://opcfoundation.org/UA/2008/02/Types.xsd">
-            <ProductUri></ProductUri>
-            <ManufacturerName></ManufacturerName>
-            <ProductName></ProductName>
-            <SoftwareVersion></SoftwareVersion>
-            <BuildNumber></BuildNumber>
-            <BuildDate>1900-01-01T00:00:00Z</BuildDate>
-        </BuildInfo>
-    </uax:Body>
-</uax:ExtensionObject>
-*/
+function initXmlWriterEx(xw, map, namespaceArray) {
+    const xwe = xw;
+    xwe.map = map;
+    xwe.stackMap = [];
+    xwe.namespaceArray = namespaceArray;
+}
+function findXsdNamespaceUri(xw, nodeId) {
+    const xwe = xw;
+    if (!xwe.namespaceArray) {
+        return "";
+    }
+    const namespace = xwe.namespaceArray[nodeId.namespace];
+    if (namespace === "http://opcfoundation.org/UA/") {
+        return "http://opcfoundation.org/UA/2008/02/Types.xsd";
+    }
+    return namespace.replace(/\/$/, "") + "/Types.xsd";
+}
+function getPrefix(xw, namespace) {
+    const xwe = xw;
+    if (!xwe.map)
+        return "";
+    const p = xwe.map[namespace] || "";
+    return p ? p + ":" : "";
+}
+function restoreDefaultNamespace(xw) {
+    const xwe = xw;
+    if (!xwe.map)
+        return;
+    xwe.map = xwe.stackMap.pop();
+}
+function setDefaultNamespace(xw, namespace) {
+    const xwe = xw;
+    if (!xwe.map)
+        return;
+    if (xwe.map[namespace] !== "") {
+        xw.writeAttribute("xmlns", namespace);
+    }
+    xwe.stackMap.push(Object.assign({}, xwe.map));
+    xwe.map[namespace] = "";
+}
+function startElementEx(xw, ns, name, defaultNamespace) {
+    const xwe = xw;
+    xw.startElement(name);
+    setDefaultNamespace(xw, defaultNamespace);
+}
 function _dumpNodeId(xw, v) {
-    xw.startElement("Identifier");
+    const xmlns = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+    xw.startElement(`${xmlns}Identifier`);
     xw.text(n(xw, v));
     xw.endElement();
 }
@@ -184,12 +220,15 @@ function _dumpVariantValue(xw, dataType, node, value) {
     if (dataType === node_opcua_variant_1.DataType.Null) {
         return;
     }
-    xw.startElement(node_opcua_variant_1.DataType[dataType]);
+    const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+    xw.startElement(`${uax}${node_opcua_variant_1.DataType[dataType]}`);
     const definitionMap = (0, decode_xml_extension_object_1.makeDefinitionMap)(node.addressSpace);
     _dumpVariantInnerValue(xw, dataType, dataTypeNode.nodeId, definitionMap, value);
     xw.endElement();
 }
 function _dumpVariantInnerExtensionObject(xw, definitionMap, definition, value) {
+    const namespaceUri = findXsdNamespaceUri(xw, definition.defaultEncodingId);
+    const ns = getPrefix(xw, namespaceUri);
     for (const field of definition.fields || []) {
         const dataTypeNodeId = field.dataType;
         const fieldName = field.name;
@@ -203,7 +242,8 @@ function _dumpVariantInnerExtensionObject(xw, definitionMap, definition, value)
                 continue; // ns=0;i=0 is reserved
             }
             const { name, definition } = definitionMap.findDefinition(dataTypeNodeId);
-            xw.startElement(fieldName);
+            startElementEx(xw, ns, fieldName, namespaceUri);
+            //  xw.startElement(fieldName);
             let fun = (value) => {
                 /** */
             };
@@ -239,6 +279,7 @@ function _dumpVariantInnerExtensionObject(xw, definitionMap, definition, value)
                 console.log(field);
                 // throw err;
             }
+            restoreDefaultNamespace(xw);
             xw.endElement();
         }
     }
@@ -252,6 +293,7 @@ function _dumpVariantInnerValueEnum(xw, definition, value) {
 }
 // eslint-disable-next-line complexity
 function _dumpVariantInnerValue(xw, dataType, dataTypeNodeId, definitionMap, value) {
+    const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
     switch (dataType) {
         case null:
         case node_opcua_variant_1.DataType.Null:
@@ -293,12 +335,12 @@ function _dumpVariantInnerValue(xw, dataType, dataTypeNodeId, definitionMap, val
         case node_opcua_variant_1.DataType.Guid:
             /*
              <uax:Guid>
-                <uax:String>947c29a7-490d-4dc9-adda-1109e3e8fcb7</uax:String>
+                 <uax:String>947c29a7-490d-4dc9-adda-1109e3e8fcb7</uax:String>
             </uax:Guid>
             */
             if (value !== undefined && value !== null) {
                 // xw.writeAttribute("xmlns", "http://opcfoundation.org/UA/2008/02/Types.xsd");
-                xw.startElement("String");
+                xw.startElement(`${uax}String`);
                 xw.text(value.toString());
                 xw.endElement();
             }
@@ -326,10 +368,13 @@ function _dumpVariantInnerValue(xw, dataType, dataTypeNodeId, definitionMap, val
  */
 function _dumpVariantExtensionObjectValue_Body(xw, definitionMap, name, definition, value) {
     if (value) {
-        xw.startElement(name);
+        const namespaceUri = findXsdNamespaceUri(xw, definition.defaultEncodingId);
+        const ns = getPrefix(xw, namespaceUri);
+        startElementEx(xw, ns, `${name}`, namespaceUri);
         if (value) {
             _dumpVariantInnerExtensionObject(xw, definitionMap, definition, value);
         }
+        restoreDefaultNamespace(xw);
         xw.endElement();
     }
 }
@@ -338,24 +383,29 @@ function _dumpVariantExtensionObjectValue(xw, dataTypeNodeId, definitionMap, val
     // const encodingDefaultXml = (getStructureTypeConstructor(schema.name) as any).encodingDefaultXml;
     const encodingDefaultXml = value.schema.encodingDefaultXml;
     if (!encodingDefaultXml) {
+        warningLog("dataType Name ", name, "with ", dataTypeNodeId.toString(), " does not have xml encoding");
         // throw new Error("Extension Object doesn't provide a XML ");
         return;
     }
-    xw.startElement("ExtensionObject");
+    const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+    startElementEx(xw, uax, `ExtensionObject`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
     {
-        xw.startElement("TypeId");
+        const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+        xw.startElement(`${uax}TypeId`);
         {
             // find HasEncoding node
             // xx var encodingDefaultXml = schema.encodingDefaultXml;
-            xw.startElement("Identifier");
+            xw.startElement(`${uax}Identifier`);
             xw.text(n(xw, encodingDefaultXml));
             xw.endElement();
         }
         xw.endElement();
-        xw.startElement("Body");
+        startElementEx(xw, uax, "Body", "http://opcfoundation.org/UA/2008/02/Types.xsd");
         _dumpVariantExtensionObjectValue_Body(xw, definitionMap, name, definition, value);
+        restoreDefaultNamespace(xw);
         xw.endElement();
     }
+    restoreDefaultNamespace(xw);
     xw.endElement();
 }
 function _dumpVariantExtensionObjectValue2(xw, dataTypeNode, value) {
@@ -384,10 +434,7 @@ function _isDefaultValue(value) {
                 }
                 break;
             case node_opcua_variant_1.DataType.Boolean:
-                if (!value.value) {
-                    return true;
-                }
-                break;
+                return false; // we want it all the time !
             case node_opcua_variant_1.DataType.SByte:
             case node_opcua_variant_1.DataType.Byte:
             case node_opcua_variant_1.DataType.UInt16:
@@ -440,7 +487,7 @@ function _dumpValue(xw, node, value) {
         return;
     }
     (0, node_opcua_assert_1.assert)(value instanceof node_opcua_variant_1.Variant);
-    const dataTypeNode = addressSpace.findNode(node.dataType);
+    const dataTypeNode = addressSpace.findDataType(node.dataType);
     if (!dataTypeNode) {
         console.log("Cannot find dataType:", node.dataType);
         return;
@@ -457,15 +504,13 @@ function _dumpValue(xw, node, value) {
         return;
     }
     xw.startElement("Value");
+    const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
     if (isExtensionObject) {
-        const dataTypeNode = addressSpace.findDataType(node.dataType);
-        if (!dataTypeNode) {
-            throw new Error("Cannot find data type " + node.dataType.toString());
-        }
         const encodeXml = _dumpVariantExtensionObjectValue2.bind(null, xw, dataTypeNode);
         if (value.arrayType === node_opcua_variant_1.VariantArrayType.Array) {
-            xw.startElement("ListOf" + baseDataTypeName);
+            startElementEx(xw, uax, `ListOf${baseDataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
             value.value.forEach(encodeXml);
+            restoreDefaultNamespace(xw);
             xw.endElement();
         }
         else if (value.arrayType === node_opcua_variant_1.VariantArrayType.Scalar) {
@@ -481,15 +526,15 @@ function _dumpValue(xw, node, value) {
         const encodeXml = _dumpVariantValue.bind(null, xw, value.dataType, node);
         if (value.arrayType === node_opcua_variant_1.VariantArrayType.Matrix) {
             // console.log("Warning _dumpValue : Matrix not supported yet");
-            xw.startElement("ListOf" + dataTypeName);
-            xw.writeAttribute("xmlns", "http://opcfoundation.org/UA/2008/02/Types.xsd");
+            startElementEx(xw, uax, `ListOf${dataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
             value.value.forEach(encodeXml);
+            restoreDefaultNamespace(xw);
             xw.endElement();
         }
         else if (value.arrayType === node_opcua_variant_1.VariantArrayType.Array) {
-            xw.startElement("ListOf" + dataTypeName);
-            xw.writeAttribute("xmlns", "http://opcfoundation.org/UA/2008/02/Types.xsd");
+            startElementEx(xw, uax, `ListOf${dataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
             value.value.forEach(encodeXml);
+            restoreDefaultNamespace(xw);
             xw.endElement();
         }
         else if (value.arrayType === node_opcua_variant_1.VariantArrayType.Scalar) {
@@ -511,11 +556,9 @@ function _dumpArrayDimensionsAttribute(xw, node) {
         xw.writeAttribute("ArrayDimensions", node.arrayDimensions.join(","));
     }
 }
-function visitUANode(node, options, forward) {
+function visitUANode(node, data, forward) {
     (0, node_opcua_assert_1.assert)(typeof forward === "boolean");
     const addressSpace = node.addressSpace;
-    options.elements = options.elements || [];
-    options.index_el = options.index_el || {};
     // visit references
     function process_reference(reference) {
         //  only backward or forward references
@@ -526,16 +569,16 @@ function visitUANode(node, options, forward) {
             return; // skip OPCUA namespace
         }
         const k = _hash(reference);
-        if (!options.index_el[k]) {
-            options.index_el[k] = 1;
+        if (!data.index_el[k]) {
+            data.index_el[k] = 1;
             const o = addressSpace.findNode(k);
             if (o) {
-                visitUANode(o, options, forward);
+                visitUANode(o, data, forward);
             }
         }
     }
     node.ownReferences().forEach(process_reference);
-    options.elements.push(node);
+    data.elements.push(node);
     return node;
 }
 function dumpNodeInXml(xw, node) {
@@ -593,10 +636,20 @@ function dumpReferencedNodes(xw, node, forward) {
         }
     }
 }
+function getParent(node) {
+    if (node instanceof ua_variable_impl_1.UAVariableImpl || node instanceof ua_method_impl_1.UAMethodImpl || node instanceof ua_object_impl_1.UAObjectImpl) {
+        return node.parent;
+    }
+    return null;
+}
 const currentReadFlag = (0, node_opcua_data_model_1.makeAccessLevelFlag)("CurrentRead");
 function dumpCommonAttributes(xw, node) {
     xw.writeAttribute("NodeId", n(xw, node.nodeId));
     xw.writeAttribute("BrowseName", b(xw, node.browseName));
+    const parentNode = getParent(node);
+    if (parentNode) {
+        xw.writeAttribute("ParentNodeId", n(xw, parentNode.nodeId));
+    }
     if (Object.prototype.hasOwnProperty.call(node, "symbolicName")) {
         xw.writeAttribute("SymbolicName", node.symbolicName);
     }
@@ -677,13 +730,20 @@ function _dumpStructureDefinition(xw, structureDefinition, baseStructureDefiniti
         xw.endElement();
     }
 }
+function _dumpEncoding(xw, uaEncoding) {
+    const uaDescription = uaEncoding.findReferencesAsObject("HasDescription")[0];
+    if (uaDescription) {
+        dumpUAVariable(xw, uaDescription);
+    }
+    _dumpUAObject(xw, uaEncoding);
+}
 function _dumpEncodings(xw, uaDataType) {
     const encodings = uaDataType.findReferencesExAsObject("HasEncoding", node_opcua_data_model_1.BrowseDirection.Forward);
-    for (const encoding of encodings) {
-        if (encoding.nodeClass !== node_opcua_data_model_1.NodeClass.Object) {
+    for (const uaEncoding of encodings) {
+        if (uaEncoding.nodeClass !== node_opcua_data_model_1.NodeClass.Object) {
             continue;
         }
-        _dumpUAObject(xw, encoding);
+        _dumpEncoding(xw, uaEncoding);
     }
 }
 function _dumpUADataTypeDefinition(xw, uaDataType) {
@@ -696,15 +756,20 @@ function _dumpUADataTypeDefinition(xw, uaDataType) {
         return;
     }
     if (uaDataType.isStructure()) {
-        const definition = uaDataType.getStructureDefinition();
-        const baseDefinition = uaDataTypeBase ? uaDataTypeBase.getStructureDefinition() : null;
-        xw.startElement("Definition");
-        xw.writeAttribute("Name", b(xw, uaDataType.browseName));
-        if (definition.structureType === node_opcua_types_1.StructureType.Union) {
-            xw.writeAttribute("IsUnion", "true");
+        // in case the namespace is conforming to 1.03 specification the DataTypeDefinition attribute
+        // will be not be readable....
+        const dataValue = uaDataType.readAttribute(index_current_1.SessionContext.defaultContext, node_opcua_basic_types_1.AttributeIds.DataTypeDefinition);
+        if (true || dataValue.statusCode === node_opcua_basic_types_1.StatusCodes.Good) {
+            const definition = uaDataType.getStructureDefinition();
+            const baseDefinition = uaDataTypeBase ? uaDataTypeBase.getStructureDefinition() : null;
+            xw.startElement("Definition");
+            xw.writeAttribute("Name", b(xw, uaDataType.browseName));
+            if (definition.structureType === node_opcua_types_1.StructureType.Union) {
+                xw.writeAttribute("IsUnion", "true");
+            }
+            _dumpStructureDefinition(xw, definition, baseDefinition);
+            xw.endElement();
         }
-        _dumpStructureDefinition(xw, definition, baseDefinition);
-        xw.endElement();
         return;
     }
 }
@@ -732,6 +797,10 @@ function _markAsVisited(xw, node) {
     xw.visitedNode[_hash(node)] = 1;
 }
 function dumpUAVariable(xw, node) {
+    (0, node_opcua_assert_1.assert)(node.nodeClass === node_opcua_data_model_1.NodeClass.Variable);
+    if (xw.visitedNode[_hash(node)]) {
+        return;
+    }
     _markAsVisited(xw, node);
     dumpReferencedNodes(xw, node, false);
     const addressSpace = node.addressSpace;
@@ -764,6 +833,7 @@ function dumpUAVariable(xw, node) {
     dumpAggregates(xw, node);
 }
 function dumpUAVariableType(xw, node) {
+    (0, node_opcua_assert_1.assert)(node.nodeClass === node_opcua_data_model_1.NodeClass.VariableType);
     xw.visitedNode = xw.visitedNode || {};
     (0, node_opcua_assert_1.assert)(!xw.visitedNode[_hash(node)]);
     xw.visitedNode[_hash(node)] = 1;
@@ -809,6 +879,7 @@ function dumpUAObject(xw, node) {
     xw.writeComment("Object - " + b(xw, node.browseName) + " }}}} ");
 }
 function _dumpUAObject(xw, node) {
+    (0, node_opcua_assert_1.assert)(node.nodeClass === node_opcua_data_model_1.NodeClass.Object);
     xw.visitedNode = xw.visitedNode || {};
     (0, node_opcua_assert_1.assert)(!xw.visitedNode[_hash(node)]);
     xw.visitedNode[_hash(node)] = 1;
@@ -853,6 +924,7 @@ function dumpAggregates(xw, node) {
     // Xx xw.writeComment("Aggregates }} ");
 }
 function dumpUAObjectType(xw, node) {
+    (0, node_opcua_assert_1.assert)(node.nodeClass === node_opcua_data_model_1.NodeClass.ObjectType);
     (0, node_opcua_assert_1.assert)(node instanceof ua_object_type_impl_1.UAObjectTypeImpl);
     xw.writeComment("ObjectType - " + b(xw, node.browseName) + " {{{{ ");
     _markAsVisited(xw, node);
@@ -866,6 +938,7 @@ function dumpUAObjectType(xw, node) {
     xw.writeComment("ObjectType - " + b(xw, node.browseName) + " }}}}");
 }
 function dumpUAMethod(xw, node) {
+    (0, node_opcua_assert_1.assert)(node.nodeClass === node_opcua_data_model_1.NodeClass.Method);
     _markAsVisited(xw, node);
     dumpReferencedNodes(xw, node, false);
     xw.startElement("UAMethod");
@@ -894,16 +967,16 @@ function resolveDataTypeName(addressSpace, dataType) {
     }
     return dataTypeNode.browseName;
 }
-function buildUpAliases(node, xw, options) {
+function buildUpAliases(node, xw, data) {
     const addressSpace = node.addressSpace;
-    options.aliases = options.aliases || {};
-    options.aliases_visited = options.aliases_visited || {};
+    if (!data.aliases_visited)
+        data.aliases_visited = {};
     const k = _hash(node);
     // istanbul ignore next
-    if (options.aliases_visited[k]) {
+    if (data.aliases_visited[k]) {
         return;
     }
-    options.aliases_visited[k] = 1;
+    data.aliases_visited[k] = 1;
     // put datatype into aliases list
     if (node.nodeClass === node_opcua_data_model_1.NodeClass.Variable || node.nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
         const nodeV = node;
@@ -911,8 +984,8 @@ function buildUpAliases(node, xw, options) {
             // name
             const dataTypeName = b(xw, resolveDataTypeName(addressSpace, nodeV.dataType));
             if (dataTypeName) {
-                if (!options.aliases[dataTypeName]) {
-                    options.aliases[dataTypeName] = n(xw, nodeV.dataType);
+                if (!data.aliases[dataTypeName]) {
+                    data.aliases[dataTypeName] = n(xw, nodeV.dataType);
                 }
             }
         }
@@ -920,8 +993,8 @@ function buildUpAliases(node, xw, options) {
             // name
             const dataTypeName = b(xw, resolveDataTypeName(addressSpace, nodeV.dataType));
             if (dataTypeName) {
-                if (!options.aliases[dataTypeName]) {
-                    options.aliases[dataTypeName] = n(xw, nodeV.dataType);
+                if (!data.aliases[dataTypeName]) {
+                    data.aliases[dataTypeName] = n(xw, nodeV.dataType);
                 }
             }
         }
@@ -929,12 +1002,12 @@ function buildUpAliases(node, xw, options) {
     function collectReferenceNameInAlias(reference) {
         // reference.referenceType
         const key = b(xw, (0, base_node_impl_1.getReferenceType)(reference).browseName);
-        if (!options.aliases.key) {
+        if (!data.aliases.key) {
             if (reference.referenceType.namespace === 0) {
-                options.aliases[key] = reference.referenceType.toString().replace("ns=0;", "");
+                data.aliases[key] = reference.referenceType.toString().replace("ns=0;", "");
             }
             else {
-                options.aliases[key] = n(xw, reference.referenceType);
+                data.aliases[key] = n(xw, reference.referenceType);
             }
         }
     }
@@ -989,12 +1062,12 @@ function sortByNodeId(a, b) {
 function dumpXml(node, options) {
     const namespace = node.namespace;
     // make a first visit so that we determine which node to output and in which order
-    const nodesToVisit = {};
+    const data = { aliases: {}, aliases_visited: {}, index_el: {}, elements: [] };
     const dependency = (0, construct_namespace_dependency_1.constructNamespaceDependency)(namespace);
     const translationTable = constructNamespaceTranslationTable(dependency);
     const xw = new XMLWriter(true);
     xw.translationTable = translationTable;
-    visitUANode(node, nodesToVisit, false);
+    visitUANode(node, data, false);
     xw.startDocument({ encoding: "utf-8" });
     xw.startElement("UANodeSet");
     xw.writeAttribute("xmlns:xs", "http://www.w3.org/2001/XMLSchema-instance");
@@ -1002,9 +1075,23 @@ function dumpXml(node, options) {
     xw.writeAttribute("Version", "1.02");
     xw.writeAttribute("LastModified", new Date().toISOString());
     xw.writeAttribute("xmlns", "http://opcfoundation.org/UA/2011/03/UANodeSet.xsd");
-    buildUpAliases(node, xw, nodesToVisit);
-    writeAliases(xw, nodesToVisit.aliases);
-    for (const el of nodesToVisit.elements) {
+    buildUpAliases(node, xw, data);
+    writeAliases(xw, data.aliases);
+    const xmlNamspace = {
+        default: { namespace: "http://opcfoundation.org/UA/2011/03/UANodeSet.xsd" }
+    };
+    xw.startElement("Extensions");
+    {
+        xw.startElement("Extension");
+        {
+            xw.startElement("ModelInfo");
+            xw.writeAttribute("NodeOPCUA");
+            xw.endElement();
+        }
+        xw.endElement();
+    }
+    xw.endElement();
+    for (const el of data.elements) {
         el.dumpXML(xw);
     }
     xw.endElement();
@@ -1033,10 +1120,17 @@ ua_object_type_impl_1.UAObjectTypeImpl.prototype.dumpXML = function (xw) {
 ua_data_type_impl_1.UADataTypeImpl.prototype.dumpXML = function (xw) {
     dumpUADataType(xw, this);
 };
+function makeTypeXsd(namespaceUri) {
+    return namespaceUri.replace(/\/$/, "") + "/Type.xsd";
+}
 // eslint-disable-next-line max-statements
 namespace_impl_1.NamespaceImpl.prototype.toNodeset2XML = function () {
     const dependency = (0, construct_namespace_dependency_1.constructNamespaceDependency)(this);
     const translationTable = constructNamespaceTranslationTable(dependency);
+    const namespaceArrayNode = this.addressSpace.findNode(node_opcua_constants_1.VariableIds.Server_NamespaceArray);
+    const namespaceArray = namespaceArrayNode
+        ? namespaceArrayNode.readAttribute(null, node_opcua_basic_types_1.AttributeIds.Value).value.value
+        : [];
     const xw = new XMLWriter(true);
     xw.translationTable = translationTable;
     xw.startDocument({ encoding: "utf-8", version: "1.0" });
@@ -1044,10 +1138,25 @@ namespace_impl_1.NamespaceImpl.prototype.toNodeset2XML = function () {
     xw.writeAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
     xw.writeAttribute("xmlns:uax", "http://opcfoundation.org/UA/2008/02/Types.xsd");
     xw.writeAttribute("xmlns", "http://opcfoundation.org/UA/2011/03/UANodeSet.xsd");
+    const namespacesMap = {
+        "http://opcfoundation.org/UA/2011/03/UANodeSet.xsd": "",
+        "http://opcfoundation.org/UA/2008/02/Types.xsd": "uax",
+        "http://www.w3.org/2001/XMLSchema-instance": "xsi"
+    };
+    for (const namespace of dependency) {
+        if (namespace.index === 0) {
+            continue;
+        }
+        const translatedIndex = translationTable[namespace.index];
+        const smallName = `ns${translatedIndex}`;
+        xw.writeAttribute(`xmlns:${smallName}`, makeTypeXsd(namespace.namespaceUri));
+        namespacesMap[namespace.namespaceUri] = smallName;
+    }
     // xx xw.writeAttribute("Version", "1.02");
     // xx xw.writeAttribute("LastModified", (new Date()).toISOString());
     // ------------- INamespace Uris
     xw.startElement("NamespaceUris");
+    initXmlWriterEx(xw, namespacesMap, namespaceArray);
     // xx const namespaceArray = namespace.addressSpace.getNamespaceArray();
     for (const depend of dependency) {
         if (depend.index === 0) {
@@ -1078,11 +1187,11 @@ namespace_impl_1.NamespaceImpl.prototype.toNodeset2XML = function () {
         xw.endElement();
     }
     xw.endElement();
-    const s = {};
+    const data = { aliases: {} };
     for (const node of this.nodeIterator()) {
-        buildUpAliases(node, xw, s);
+        buildUpAliases(node, xw, data);
     }
-    writeAliases(xw, s.aliases);
+    writeAliases(xw, data.aliases);
     xw.visitedNode = {};
     // -------------- writeReferences
     xw.writeComment("ReferenceTypes");
@@ -1092,10 +1201,7 @@ namespace_impl_1.NamespaceImpl.prototype.toNodeset2XML = function () {
     }
     // -------------- Dictionaries
     const addressSpace = this.addressSpace;
-    const opcBinaryTypeSystem = addressSpace.findNode("OPCBinarySchema_TypeSystem");
-    if (opcBinaryTypeSystem) {
-        // let find all DataType dictionary node corresponding to a given namespace
-        // (have DataTypeDictionaryType)
+    const getDataTypeDescription = (opcBinaryTypeSystem) => {
         const nodeToBrowse = new node_opcua_types_1.BrowseDescription({
             browseDirection: node_opcua_data_model_1.BrowseDirection.Forward,
             includeSubtypes: false,
@@ -1106,12 +1212,8 @@ namespace_impl_1.NamespaceImpl.prototype.toNodeset2XML = function () {
         });
         const result = opcBinaryTypeSystem.browseNode(nodeToBrowse).filter((r) => r.nodeId.namespace === this.index);
         (0, node_opcua_assert_1.assert)(result.length <= 1);
-        if (result.length === 1) {
-            xw.writeComment("DataSystem");
-            const dataSystemType = addressSpace.findNode(result[0].nodeId);
-            dumpNodeInXml(xw, dataSystemType);
-        }
-    }
+        return result;
+    };
     // -------------- DataTypes
     const dataTypes = [...this._dataTypeIterator()].sort(sortByBrowseName);
     if (dataTypes.length) {
@@ -1122,6 +1224,35 @@ namespace_impl_1.NamespaceImpl.prototype.toNodeset2XML = function () {
                 dumpNodeInXml(xw, dataType);
             }
         }
+        // --------------
+        const opcBinaryTypeSystem = addressSpace.findNode(node_opcua_constants_1.ObjectIds.OPCBinarySchema_TypeSystem);
+        const opcXmlSchemaTypeSystem = addressSpace.findNode(node_opcua_constants_1.ObjectIds.XmlSchema_TypeSystem);
+        if (opcBinaryTypeSystem) {
+            // let find all DataType dictionary node corresponding to a given namespace
+            // (have DataTypeDictionaryType)
+            const result = getDataTypeDescription(opcBinaryTypeSystem);
+            if (result.length === 1) {
+                xw.writeComment("DataSystem - Binary");
+                const dataSystemType = addressSpace.findNode(result[0].nodeId);
+                const types = dataSystemType.getComponents();
+                for (const f of types) {
+                    dumpNodeInXml(xw, f);
+                }
+                dumpNodeInXml(xw, dataSystemType);
+            }
+        }
+        if (opcXmlSchemaTypeSystem) {
+            const result = getDataTypeDescription(opcXmlSchemaTypeSystem);
+            if (result.length === 1) {
+                xw.writeComment("DataSystem - Xml");
+                const dataSystemType = addressSpace.findNode(result[0].nodeId);
+                const types = dataSystemType.getComponents();
+                for (const f of types) {
+                    dumpNodeInXml(xw, f);
+                }
+                dumpNodeInXml(xw, dataSystemType);
+            }
+        }
     }
     // -------------- ObjectTypes
     xw.writeComment("ObjectTypes");