node-opcua-address-space 2.81.0 → 2.83.0

package/source/loader/load_nodeset2.ts

@@ -12,6 +12,7 @@ import {
     CreateNodeOptions,
     IAddressSpace,
     INamespace,
+    RequiredModel,
     UADataType,
     UAVariable,
     UAVariableType
@@ -52,11 +53,11 @@ import * as semver from "semver";
 
 import { AddressSpacePrivate } from "../../src/address_space_private";
 import { NamespacePrivate } from "../../src/namespace_private";
+import { NodeSetLoaderOptions } from "../interfaces/nodeset_loader_options";
 import { promoteObjectsAndVariables } from "./namespace_post_step";
 import { ensureDatatypeExtracted } from "./ensure_datatype_extracted";
 import { decodeXmlExtensionObject } from "./decode_xml_extension_object";
 import { makeSemverCompatible } from "./make_semver_compatible";
-import { NodeSetLoaderOptions } from "../interfaces/nodeset_loader_options";
 
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
@@ -150,9 +151,9 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
     const addressSpace1 = addressSpace as AddressSpacePrivate;
     addressSpace1.suspendBackReference = true;
 
-    options.loadDeprecatedNodes = options.loadDeprecatedNodes === undefined ? true:  options.loadDeprecatedNodes;
+    options.loadDeprecatedNodes = options.loadDeprecatedNodes === undefined ? true : options.loadDeprecatedNodes;
     options.loadDraftNodes = options.loadDraftNodes || false;
-    
+
     const postTasks: Task[] = [];
     const postTasks0_InitializeVariable: Task[] = [];
     const postTasks0_DecodePojoString: Task[] = [];
@@ -225,6 +226,8 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
             return;
         }
         const namespace = addressSpace1.getNamespace(namespaceUri);
+
+        // istanbul ignore next
         if (!namespace) {
             throw new Error(
                 "cannot find namespace for " +
@@ -254,6 +257,8 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
             // check that required models exist already in the address space
             for (const requiredModel of model.requiredModels) {
                 const existingNamespace = addressSpace1.getNamespace(requiredModel.modelUri);
+                
+                // istanbul ignore next
                 if (!existingNamespace) {
                     errorLog(
                         "Please ensure that the required namespace ",
@@ -274,6 +279,7 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
                     const requiredSemver = makeSemverCompatible(requiredVersion);
                     return semver.lt(existingSemver, requiredSemver);
                 };
+                
                 if (isLowerVersion(existingNamespace.version, requiredModel.version)) {
                     errorLog(
                         "Expecting ",
@@ -302,6 +308,7 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
         const existingNamespace = addressSpace1.getNamespace(model.modelUri);
         if (existingNamespace) {
             // special treatment for namespace 0
+            // istanbul ignore else
             if (model.modelUri === "http://opcfoundation.org/UA/") {
                 namespace = existingNamespace;
             } else {
@@ -309,6 +316,7 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
             }
         } else {
             namespace = addressSpace1.registerNamespace(model.modelUri);
+            namespace.setRequiredModels(model.requiredModels)
         }
 
         namespace.version = model.version;
@@ -516,25 +524,6 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
             if (canIngore({ isDraft: this.isDraft, isDeprecated: this.isDeprecated }, this.obj)) {
                 return;
             }
-            /*
-            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[];
 
@@ -872,11 +861,14 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
                         break;
                     default: {
                         // istanbul ignore next
-                        if (! this._cloneFragment) {
+                        if (!this._cloneFragment) {
                             // the XML file is probably not exposing standard UA extension object correctly.
                             // this has been seen in some generated xml files using the dataType nodeId instead of the default encoding
-                            // nodeid 
-                            errorLog("[NODE-OPCUA-E12] standard OPCUA Extension object from (namespace=0) has a invalid TypeId", self.typeDefinitionId.toString());
+                            // nodeid
+                            errorLog(
+                                "[NODE-OPCUA-E12] standard OPCUA Extension object from (namespace=0) has a invalid TypeId",
+                                self.typeDefinitionId.toString()
+                            );
                             break;
                         }
                         this.bodyXML = this._cloneFragment!.value;
@@ -1416,8 +1408,6 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
                     // do them later
                     postTasks1_InitializeVariable.push(task);
                 }
-
-               
             } else {
                 const task = async (addressSpace2: IAddressSpace) => {
                     const dataTypeNode = capturedVariable.dataType;
@@ -1543,11 +1533,7 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
         }
     };
 
-    interface RequiredModel {
-        modelUri: string;
-        version: string;
-        publicationDate: Date;
-    }
+
     interface Model {
         modelUri: string;
         version: string;
@@ -1726,7 +1712,8 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
             doDebug && debugLog(chalk.bgGreenBright("Performing post loading tasks -------------------------------------------"));
             await performPostLoadingTasks(postTasks);
 
-            doDebug && debugLog(chalk.bgGreenBright("Performing post loading task: Initializing Simple Variables ---------------------"));
+            doDebug &&
+                debugLog(chalk.bgGreenBright("Performing post loading task: Initializing Simple Variables ---------------------"));
             await performPostLoadingTasks(postTasks0_InitializeVariable);
 
             doDebug && debugLog(chalk.bgGreenBright("Performing DataType extraction -------------------------------------------"));
@@ -1748,7 +1735,8 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
             doDebug && debugLog(chalk.bgGreenBright("Performing post loading task: Decoding Pojo String (parsing XML objects) -"));
             await performPostLoadingTasks(postTasks0_DecodePojoString);
 
-            doDebug && debugLog(chalk.bgGreenBright("Performing post loading task: Initializing Complex Variables ---------------------"));
+            doDebug &&
+                debugLog(chalk.bgGreenBright("Performing post loading task: Initializing Complex Variables ---------------------"));
             await performPostLoadingTasks(postTasks1_InitializeVariable);
 
             doDebug && debugLog(chalk.bgGreenBright("Performing post loading tasks: (assigning Extension Object to Variables) -"));
@@ -1775,8 +1763,6 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
     };
 }
 
-
-
 export class NodeSetLoader {
     _s: NodeSet2ParserEngine;
     constructor(addressSpace: IAddressSpace, private options?: NodeSetLoaderOptions) {

package/source/xml_writer.ts

@@ -1,5 +1,9 @@
+export interface ITranslationTable {
+    [key: number]: number;
+}
 export interface XmlWriter {
-    translationTable: any;
+    translationTable: ITranslationTable;
+    priorityTable: number[];
     visitedNode: any;
 
     startDocument(options: { encoding: string; version: string }): void;

package/src/address_space.ts

@@ -1451,8 +1451,7 @@ export class AddressSpace implements AddressSpacePrivate {
         if (!baseType) {
             return topMostBaseTypeNode;
         }
-
-        assert(typeof baseType === "string" || baseType instanceof BaseNodeImpl);
+        assert(typeof baseType === "string" || baseType instanceof BaseNodeImpl || baseType instanceof NodeId);
         let baseTypeNode: T;
         if (baseType instanceof BaseNodeImpl) {
             baseTypeNode = baseType as BaseNode as T;

package/src/apply_condition_refresh.ts

@@ -4,9 +4,9 @@ import { BaseNodeImpl } from "./base_node_impl";
 import { UAObjectImpl } from "./ua_object_impl";
 
 export type ConditionRefreshCache = { [key in string]: UAObject };
-export function apply_condition_refresh(this: BaseNodeImpl, _cache?: ConditionRefreshCache): void {
+export function apply_condition_refresh(this: BaseNodeImpl, cache?: ConditionRefreshCache): void {
     // visit all notifiers recursively
-    _cache = _cache || {};
+    cache = cache || {};
     const notifiers = this.getNotifiers();
     const eventSources = this.getEventSources();
 
@@ -20,10 +20,10 @@ export function apply_condition_refresh(this: BaseNodeImpl, _cache?: ConditionRe
 
     for (const notifier of arr) {
         const key = notifier.nodeId.toString();
-        if (!_cache[key]) {
-            _cache[key] = notifier;
+        if (!cache[key]) {
+            cache[key] = notifier;
             if (notifier._conditionRefresh) {
-                notifier._conditionRefresh(_cache);
+                notifier._conditionRefresh(cache);
             }
         }
     }

package/src/base_node_impl.ts

@@ -54,6 +54,7 @@ import { lowerFirstLetter } from "node-opcua-utils";
 import { DataType, VariantArrayType } from "node-opcua-variant";
 
 import { UAStateVariable } from "node-opcua-nodeset-ua";
+import { ObjectTypeIds, VariableTypeIds } from "node-opcua-constants";
 
 import { XmlWriter } from "../source/xml_writer";
 import { dumpReferenceDescriptions, dumpReferences } from "../source/helpers/dump_tools";
@@ -209,7 +210,19 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         const _cache = BaseNode_getCache(this);
         if (!_cache.typeDefinition) {
             const has_type_definition_ref = this.findReference("HasTypeDefinition", true);
-            _cache.typeDefinition = has_type_definition_ref ? has_type_definition_ref.nodeId : null;
+            let nodeId = has_type_definition_ref ? has_type_definition_ref.nodeId : null;
+            if (!nodeId) {
+                switch (this.nodeClass) {
+                    case NodeClass.Object:
+                        nodeId = coerceNodeId(ObjectTypeIds.BaseObjectType);
+                        break;
+                    case NodeClass.Variable:
+                        nodeId = coerceNodeId(VariableTypeIds.BaseVariableType);
+                        break;
+                    default:
+                }
+            }
+            _cache.typeDefinition = nodeId as NodeId;
         }
         return _cache.typeDefinition;
     }
@@ -221,9 +234,12 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         const _cache = BaseNode_getCache(this);
         if (undefined === _cache.typeDefinitionObj) {
             const nodeId = this.typeDefinition;
-            _cache.typeDefinitionObj = nodeId ? this.addressSpace.findNode(nodeId) : null;
+            _cache.typeDefinitionObj = nodeId ? (this.addressSpace.findNode(nodeId) as UAObjectType | UAVariableType) : null;
         }
-        return _cache.typeDefinitionObj;
+        if (!_cache.typeDefinitionObj) {
+            warningLog("cannot find typeDefinitionObj ", this.browseName.toString(), this.nodeId.toString());
+        }
+        return _cache.typeDefinitionObj as UAObjectType | UAVariableType;
     }
 
     public get parentNodeId(): NodeId | undefined {
@@ -374,26 +390,9 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         return results;
     }
 
-    public findReferences(referenceType: string | NodeId | UAReferenceType, isForward = true): UAReference[] {
-        const _cache = BaseNode_getCache(this);
-        const _private = BaseNode_getPrivate(this);
-
-        const referenceTypeNode = this._coerceReferenceType(referenceType);
-        if (!referenceTypeNode) {
-            // note: when loading nodeset2.xml files, reference type may not exit yet
-            // throw new Error("expecting valid reference name " + strReference);
-            return [];
-        }
-        const hash = "_ref_" + referenceTypeNode.nodeId.toString() + isForward.toString();
-        if (_cache[hash]) {
-            return _cache[hash];
-        }
-
-        // istanbul ignore next
-        if (doDebug && !this.addressSpace.findReferenceType(referenceTypeNode.nodeId)) {
-            throw new Error("expecting valid reference name " + referenceType);
-        }
 
+    public findReferences_no_cache(referenceTypeNode: UAReferenceType, isForward = true): UAReference[] {
+        const _private = BaseNode_getPrivate(this);
         const result: UAReference[] = [];
         for (const ref of Object.values(_private._referenceIdx)) {
             if (ref.isForward === isForward) {
@@ -410,8 +409,28 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
                 }
             }
         }
+        return result;
+    }
 
-        _cache[hash] = result;
+    public findReferences(referenceType: string | NodeId | UAReferenceType, isForward = true): UAReference[] {
+        const _cache = BaseNode_getCache(this);
+        const referenceTypeNode = this._coerceReferenceType(referenceType);
+        if (!referenceTypeNode) {
+            // note: when loading nodeset2.xml files, reference type may not exit yet
+            // throw new Error("expecting valid reference name " + strReference);
+            return [];
+        }
+        _cache._ref = _cache._ref || {};
+        const hash = "_ref_" + referenceTypeNode.nodeId.toString() + isForward.toString();
+        if (_cache._ref[hash]) {
+            return _cache._ref[hash];
+        }
+        // istanbul ignore next
+        if (doDebug && !this.addressSpace.findReferenceType(referenceTypeNode.nodeId)) {
+            throw new Error("expecting valid reference name " + referenceType);
+        }
+        const result = this.findReferences_no_cache(referenceTypeNode, isForward);
+        _cache._ref[hash] = result;
         return result;
     }
 
@@ -440,66 +459,72 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
      * return an array with the Aggregates of this object.
      */
     public getAggregates(): BaseNode[] {
-        const _cache = BaseNode_getCache(this);
-        if (!_cache._aggregates) {
-            _cache._aggregates = this.findReferencesExAsObject("Aggregates", BrowseDirection.Forward);
-        }
-        return _cache._aggregates;
+        // const _cache = BaseNode_getCache(this);
+        // if (!_cache._aggregates) {
+        //     _cache._aggregates = this.findReferencesExAsObject("Aggregates", BrowseDirection.Forward);
+        // }
+        // return _cache._aggregates;
+        return this.findReferencesExAsObject("Aggregates", BrowseDirection.Forward);
     }
 
     /**
      * return an array with the components of this object.
      */
     public getComponents(): BaseNode[] {
-        const _cache = BaseNode_getCache(this);
-        if (!_cache._components) {
-            _cache._components = this.findReferencesExAsObject("HasComponent", BrowseDirection.Forward);
-        }
-        return _cache._components;
+        // const _cache = BaseNode_getCache(this);
+        // if (!_cache._components) {
+        //     _cache._components = this.findReferencesExAsObject("HasComponent", BrowseDirection.Forward);
+        // }
+        // return _cache._components;
+        return this.findReferencesExAsObject("HasComponent", BrowseDirection.Forward);
     }
 
     /**
      *  return a array with the properties of this object.
      */
     public getProperties(): BaseNode[] {
-        const _cache = BaseNode_getCache(this);
-        if (!_cache._properties) {
-            _cache._properties = this.findReferencesExAsObject("HasProperty", BrowseDirection.Forward);
-        }
-        return _cache._properties;
+        // const _cache = BaseNode_getCache(this);
+        // if (!_cache._properties) {
+        //     _cache._properties = this.findReferencesExAsObject("HasProperty", BrowseDirection.Forward);
+        // }
+        // return _cache._properties;
+        return this.findReferencesExAsObject("HasProperty", BrowseDirection.Forward);
     }
 
     /**
      * return a array with the notifiers of this object.
      */
     public getNotifiers(): BaseNode[] {
-        const _cache = BaseNode_getCache(this);
-        if (!_cache._notifiers) {
-            _cache._notifiers = this.findReferencesAsObject("HasNotifier", true);
-        }
-        return _cache._notifiers;
+        // const _cache = BaseNode_getCache(this);
+        // if (!_cache._notifiers) {
+        //     _cache._notifiers = this.findReferencesAsObject("HasNotifier", true);
+        // }
+        // return _cache._notifiers;
+        return  this.findReferencesAsObject("HasNotifier", true);
     }
 
     /**
      * return a array with the event source of this object.
      */
     public getEventSources(): BaseNode[] {
-        const _cache = BaseNode_getCache(this);
-        if (!_cache._eventSources) {
-            _cache._eventSources = this.findReferencesAsObject("HasEventSource", true);
-        }
-        return _cache._eventSources;
+        // const _cache = BaseNode_getCache(this);
+        // if (!_cache._eventSources) {
+        //     _cache._eventSources = this.findReferencesAsObject("HasEventSource", true);
+        // }
+        // return _cache._eventSources;
+        return this.findReferencesAsObject("HasEventSource", true);
     }
 
     /**
      * return a array of the objects for which this node is an EventSource
      */
     public getEventSourceOfs(): BaseNode[] {
-        const _cache = BaseNode_getCache(this);
-        if (!_cache._eventSources) {
-            _cache._eventSources = this.findReferencesAsObject("HasEventSource", false);
-        }
-        return _cache._eventSources;
+        // const _cache = BaseNode_getCache(this);
+        // if (!_cache._eventSources) {
+        //     _cache._eventSources = this.findReferencesAsObject("HasEventSource", false);
+        // }
+        // return _cache._eventSources;
+        return this.findReferencesAsObject("HasEventSource", false);
     }
 
     /**
@@ -566,12 +591,14 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
      * Note: internally, methods are special types of components
      */
     public getMethods(): UAMethod[] {
-        const _cache = BaseNode_getCache(this);
-        if (!_cache._methods) {
-            const components = this.getComponents();
-            _cache._methods = components.filter((obj) => obj.nodeClass === NodeClass.Method);
-        }
-        return _cache._methods;
+        // const _cache = BaseNode_getCache(this);
+        // if (!_cache._methods) {
+        //     const components = this.getComponents();
+        //     _cache._methods = components.filter((obj) => obj.nodeClass === NodeClass.Method) as UAMethod[];
+        // }
+        // return _cache._methods;
+        const components = this.getComponents();
+        return components.filter((obj) => obj.nodeClass === NodeClass.Method) as UAMethod[];
     }
 
     /**

package/src/base_node_private.ts

@@ -49,17 +49,35 @@ const g_weakMap = new WeakMap();
 
 const warningLog = make_warningLog(__filename);
 
+interface BaseNodeCacheInner {
+    typeDefinition?: NodeId;
+    _childByNameMap?: Record<string, BaseNode>;
+    typeDefinitionObj?: UAVariableType | UAObjectType | null;
+    _aggregates?: BaseNode[];
+    _components?: BaseNode[];
+    _properties?: BaseNode[];
+    _notifiers?: BaseNode[];
+    _eventSources?: BaseNode[];
+    _methods?: UAMethod[];
+    _ref?: Record<string, UAReference[]>;
+    _encoding?: Record<string, UAObject | null>;
+    _subtype_id?: Record<string, UAReferenceType[]> | null;
+    _subtype_idx?: Record<string, UAReferenceType> | null;
+    _subtype_idxVersion?: number;
+    _allSubTypes?: UAReferenceType[] | null;
+    _allSubTypesVersion?: number;
+    _subtypeOfObj?: BaseNode | null;
+}
+
 interface BaseNodeCache {
     __address_space: IAddressSpace | null;
     _browseFilter?: (this: BaseNode, context?: ISessionContext) => boolean;
-    _cache: any;
+    _cache: BaseNodeCacheInner;
     _description?: LocalizedText;
     _displayName: LocalizedText[];
     _parent?: BaseNode | null;
-
     _back_referenceIdx: { [key: string]: UAReference };
     _referenceIdx: { [key: string]: UAReference };
-
     _subtype_idxVersion: number;
     _subtype_idx: any;
 }
@@ -100,7 +118,7 @@ export function BaseNode_getPrivate(self: BaseNode): BaseNodeCache {
     return g_weakMap.get(self);
 }
 
-export function BaseNode_getCache(node: BaseNode): any {
+export function BaseNode_getCache(node: BaseNode): BaseNodeCacheInner {
     return BaseNode_getPrivate(node)._cache;
 }
 export function BaseNode_clearCache(node: BaseNode): void {
@@ -484,7 +502,8 @@ function _clone_collection_new(
         }
 
         if (optionalFilter && node && !optionalFilter.shouldKeep(node)) {
-            doTrace && traceLog(extraInfo.pad(), "skipping optional ", node.browseName.toString(), "that doesn't appear in the filter");
+            doTrace &&
+                traceLog(extraInfo.pad(), "skipping optional ", node.browseName.toString(), "that doesn't appear in the filter");
             continue; // skip this node
         }
         const key = node.browseName.toString();
@@ -541,7 +560,7 @@ function _extractInterfaces2(typeDefinitionNode: UAObjectType | UAVariableType,
 
     const hasInterfaceReference = addressSpace.findReferenceType("HasInterface");
     if (!hasInterfaceReference) {
-        // this version of the standard UA namespace doesn't support Interface yet 
+        // this version of the standard UA namespace doesn't support Interface yet
         return [];
     }
     // example:
@@ -669,10 +688,7 @@ function _cloneInterface(
     const interfaces = _extractInterfaces2(typeDefinitionNode, extraInfo);
     if (interfaces.length === 0) {
         if (doTrace) {
-            traceLog(
-                extraInfo.pad(),
-                chalk.yellow("No interface for ", node.browseName.toString(), node.nodeId.toString())
-            );
+            traceLog(extraInfo.pad(), chalk.yellow("No interface for ", node.browseName.toString(), node.nodeId.toString()));
         }
         return;
     }

package/src/index_current.ts

@@ -37,7 +37,7 @@ export * from "./extension_object_array_node";
 export * from "./event_data";
 
 export { NamespaceOptions } from "./nodeid_manager";
-export { dumpXml } from "./nodeset_tools/nodeset_to_xml";
+export * from "./nodeset_tools/nodeset_to_xml";
 export { dumpToBSD } from "./nodeset_tools/dump_to_bsd";
 export { adjustNamespaceArray } from "./nodeset_tools/adjust_namespace_array";
 export { makeAttributeEventName } from "./base_node_impl";

package/src/namespace_impl.ts

@@ -46,6 +46,7 @@ import {
     CreateNodeOptions,
     EnumerationItem,
     INamespace,
+    RequiredModel,
     UADataType,
     UAEventType,
     UAMethod,
@@ -123,6 +124,7 @@ import { UAReferenceTypeImpl } from "./ua_reference_type_impl";
 import { UAViewImpl } from "./ua_view_impl";
 import { UAStateMachineImpl, UATransitionImpl } from "./state_machine/finite_state_machine";
 import { _addMultiStateValueDiscrete } from "./data_access/ua_multistate_value_discrete_impl";
+import { notDeepEqual } from "assert";
 
 function _makeHashKey(nodeId: NodeId): string | number {
     switch (nodeId.identifierType) {
@@ -218,7 +220,6 @@ export class NamespaceImpl implements NamespacePrivate {
     public readonly namespaceUri: string;
     public addressSpace: AddressSpacePrivate;
     public readonly index: number;
-
     public emulateVersion103 = false;
 
     public version = "0.0.0";
@@ -226,6 +227,7 @@ export class NamespaceImpl implements NamespacePrivate {
 
     public registerSymbolicNames = false;
 
+    private _requiredModels?: RequiredModel[];
     private _objectTypeMap: Map<string, UAObjectType>;
     private _variableTypeMap: Map<string, UAVariableType>;
     private _referenceTypeMap: Map<string, UAReferenceType>;
@@ -1416,7 +1418,13 @@ export class NamespaceImpl implements NamespacePrivate {
     // State and Transition
     // -------------------------------------------------------------------------
     public toNodeset2XML(): string {
-        return "";
+        return "<toNodeset2XML>has not be installed</toNodeset2XML>!";
+    }
+    public setRequiredModels(requiredModels: RequiredModel[]): void {
+        this._requiredModels = requiredModels;
+    }
+    public getRequiredModels(): RequiredModel[] | undefined {
+        return this._requiredModels;
     }
 
     // -------------------------------------------------------------------------
@@ -1896,7 +1904,9 @@ export class NamespaceImpl implements NamespacePrivate {
     private _registerObjectType(node: UAObjectType) {
         assert(this.index === node.nodeId.namespace);
         const key = node.browseName.name!;
-        assert(!this._objectTypeMap.has(key), " UAObjectType already declared");
+        if (this._objectTypeMap.has(key)) {
+            throw new Error(" UAObjectType already declared " + node.browseName.toString() + "  " + node.nodeId.toString());
+        }
         this._objectTypeMap.set(key, node);
     }
 

package/src/namespace_private.ts

@@ -10,14 +10,18 @@ import {
     CreateNodeOptions,
     ModellingRuleType,
     INamespace,
-    UADataType
+    UADataType,
+    RequiredModel
 } from "node-opcua-address-space-base";
 
 import { AddressSpacePrivate } from "./address_space_private";
 
+
 export interface NamespacePrivate extends INamespace {
     addressSpace: AddressSpacePrivate;
 
+    setRequiredModels(requiredModels: RequiredModel[]): void;
+
     nodeIterator(): IterableIterator<BaseNode>;
 
     constructNodeId(options: ConstructNodeIdOptions): NodeId;
@@ -35,6 +39,8 @@ export interface NamespacePrivate extends INamespace {
     _dataTypeIterator(): IterableIterator<UADataType>;
 
     registerSymbolicNames: boolean;
+
+
 }
 
 export declare const NamespacePrivate: new (options: any) => NamespacePrivate;