node-opcua-address-space 2.183.0 → 2.184.0

package/dist/impl/namespace_impl.js

@@ -1,91 +1,85 @@
-"use strict";
 /**
  * @module node-opcua-address-space
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NamespaceImpl = void 0;
-exports.isNonEmptyQualifiedName = isNonEmptyQualifiedName;
-const chalk_1 = __importDefault(require("chalk"));
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_basic_types_1 = require("node-opcua-basic-types");
-const node_opcua_data_access_1 = require("node-opcua-data-access");
-const node_opcua_data_model_1 = require("node-opcua-data-model");
-const node_opcua_debug_1 = require("node-opcua-debug");
-const node_opcua_nodeid_1 = require("node-opcua-nodeid");
-const node_opcua_status_code_1 = require("node-opcua-status-code");
-const node_opcua_types_1 = require("node-opcua-types");
-const node_opcua_utils_1 = require("node-opcua-utils");
-const node_opcua_variant_1 = require("node-opcua-variant");
-const address_space_change_event_tools_js_1 = require("./address_space_change_event_tools.js");
-const index_js_1 = require("./alarms_and_conditions/index.js");
-const ua_exclusive_deviation_alarm_impl_js_1 = require("./alarms_and_conditions/ua_exclusive_deviation_alarm_impl.js");
-const ua_exclusive_limit_alarm_impl_js_1 = require("./alarms_and_conditions/ua_exclusive_limit_alarm_impl.js");
-const ua_limit_alarm_impl_js_1 = require("./alarms_and_conditions/ua_limit_alarm_impl.js");
-const ua_non_exclusive_deviation_alarm_impl_js_1 = require("./alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl.js");
-const ua_non_exclusive_limit_alarm_impl_js_1 = require("./alarms_and_conditions/ua_non_exclusive_limit_alarm_impl.js");
-const ua_off_normal_alarm_impl_js_1 = require("./alarms_and_conditions/ua_off_normal_alarm_impl.js");
-const base_node_impl_js_1 = require("./base_node_impl.js");
-const add_dataItem_stuff_js_1 = require("./data_access/add_dataItem_stuff.js");
-const ua_multistate_discrete_impl_js_1 = require("./data_access/ua_multistate_discrete_impl.js");
-const ua_multistate_value_discrete_impl_js_1 = require("./data_access/ua_multistate_value_discrete_impl.js");
-const ua_two_state_discrete_impl_js_1 = require("./data_access/ua_two_state_discrete_impl.js");
-const handle_hierarchy_parent_js_1 = require("./handle_hierarchy_parent.js");
+import chalk from "chalk";
+import { assert } from "node-opcua-assert";
+import { coerceInt64 } from "node-opcua-basic-types";
+import { AxisScaleEnumeration } from "node-opcua-data-access";
+import { AccessRestrictionsFlag, BrowseDirection, coerceLocalizedText, coerceQualifiedName, NodeClass, QualifiedName } from "node-opcua-data-model";
+import { dumpIf, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { coerceNodeId, NodeId, NodeIdType, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
+import { Argument, AxisInformation, EnumDefinition, EnumField, EnumValueType, EUInformation, Range } from "node-opcua-types";
+import { isNullOrUndefined } from "node-opcua-utils";
+import { DataType, Variant, VariantArrayType, verifyRankAndDimensions } from "node-opcua-variant";
+import { _handle_delete_node_model_change_event, _handle_model_change_event } from "./address_space_change_event_tools.js";
+import { UAAcknowledgeableConditionImplBase, UAAlarmConditionImplBase, UAConditionImplBase, UADiscreteAlarmImplBase } from "./alarms_and_conditions/index.js";
+import { UAExclusiveDeviationAlarmImplBase } from "./alarms_and_conditions/ua_exclusive_deviation_alarm_impl.js";
+import { UAExclusiveLimitAlarmImplBase } from "./alarms_and_conditions/ua_exclusive_limit_alarm_impl.js";
+import { UALimitAlarmImplBase } from "./alarms_and_conditions/ua_limit_alarm_impl.js";
+import { UANonExclusiveDeviationAlarmImplBase } from "./alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl.js";
+import { UANonExclusiveLimitAlarmImplBase } from "./alarms_and_conditions/ua_non_exclusive_limit_alarm_impl.js";
+import { UAOffNormalAlarmImplBase } from "./alarms_and_conditions/ua_off_normal_alarm_impl.js";
+import { BaseNodeImpl } from "./base_node_impl.js";
+import { BaseNode_getPrivate } from "./base_node_private.js";
+import { add_dataItem_stuff } from "./data_access/add_dataItem_stuff.js";
+import { _addMultiStateDiscrete } from "./data_access/ua_multistate_discrete_impl.js";
+import { _addMultiStateValueDiscrete } from "./data_access/ua_multistate_value_discrete_impl.js";
+import { _addTwoStateDiscrete } from "./data_access/ua_two_state_discrete_impl.js";
+import { _coerce_parent, _handle_hierarchy_parent } from "./handle_hierarchy_parent.js";
 //
-const namespace_private_js_1 = require("./namespace_private.js");
-const nodeid_manager_js_1 = require("./nodeid_manager.js");
-const role_permissions_js_1 = require("./role_permissions.js");
+import { UANamespace_process_modelling_rule } from "./namespace_private.js";
+import { NodeIdManager } from "./nodeid_manager.js";
+import { coerceRolePermissions } from "./role_permissions.js";
 // state machine
-const ua_two_state_variable_js_1 = require("./state_machine/ua_two_state_variable.js");
-const ua_data_type_impl_js_1 = require("./ua_data_type_impl.js");
-const ua_method_impl_js_1 = require("./ua_method_impl.js");
-const ua_object_impl_js_1 = require("./ua_object_impl.js");
-const ua_object_type_impl_js_1 = require("./ua_object_type_impl.js");
-const ua_reference_type_impl_js_1 = require("./ua_reference_type_impl.js");
-const ua_variable_impl_js_1 = require("./ua_variable_impl.js");
-const ua_variable_type_impl_js_1 = require("./ua_variable_type_impl.js");
-const ua_view_impl_js_1 = require("./ua_view_impl.js");
+import { _addTwoStateVariable } from "./state_machine/ua_two_state_variable.js";
+import { UADataTypeImpl } from "./ua_data_type_impl.js";
+import { UAMethodImpl } from "./ua_method_impl.js";
+import { UAObjectImpl } from "./ua_object_impl.js";
+import { UAObjectTypeImpl } from "./ua_object_type_impl.js";
+import { UAReferenceTypeImpl } from "./ua_reference_type_impl.js";
+import { UAVariableImpl } from "./ua_variable_impl.js";
+import { UAVariableTypeImpl } from "./ua_variable_type_impl.js";
+import { UAViewImpl } from "./ua_view_impl.js";
 function _makeHashKey(nodeId) {
     switch (nodeId.identifierType) {
-        case node_opcua_nodeid_1.NodeIdType.STRING:
-        case node_opcua_nodeid_1.NodeIdType.GUID:
+        case NodeIdType.STRING:
+        case NodeIdType.GUID:
             return nodeId.value;
-        case node_opcua_nodeid_1.NodeIdType.NUMERIC:
+        case NodeIdType.NUMERIC:
             return nodeId.value;
         default:
-            // c8 ignore next
-            if (nodeId.identifierType !== node_opcua_nodeid_1.NodeIdType.BYTESTRING) {
+            /* c8 ignore next */
+            if (nodeId.identifierType !== NodeIdType.BYTESTRING) {
                 throw new Error("invalid nodeIdType");
             }
             return nodeId.value ? nodeId.value.toString() : "OPAQUE:0";
     }
 }
 const doDebug = false;
-const errorLog = (0, node_opcua_debug_1.make_errorLog)("AddressSpace");
-const warningLog = (0, node_opcua_debug_1.make_warningLog)("AddressSpace");
+const errorLog = make_errorLog("AddressSpace");
+const warningLog = make_warningLog("AddressSpace");
 const regExp1 = /^(s|i|b|g)=/;
 const regExpNamespaceDotBrowseName = /^[0-9]+:(.*)/;
 function detachNode(node) {
     const addressSpace = node.addressSpace;
-    const nonHierarchicalReferences = node.findReferencesEx("NonHierarchicalReferences", node_opcua_data_model_1.BrowseDirection.Inverse);
+    const nonHierarchicalReferences = node.findReferencesEx("NonHierarchicalReferences", BrowseDirection.Inverse);
     for (const ref of nonHierarchicalReferences) {
-        (0, node_opcua_assert_1.assert)(!ref.isForward);
+        assert(!ref.isForward);
         ref.node?.removeReference({
             isForward: !ref.isForward,
             nodeId: node.nodeId,
             referenceType: ref.referenceType
         });
     }
-    const nonHierarchicalReferencesF = node.findReferencesEx("NonHierarchicalReferences", node_opcua_data_model_1.BrowseDirection.Forward);
+    const nonHierarchicalReferencesF = node.findReferencesEx("NonHierarchicalReferences", BrowseDirection.Forward);
     for (const ref of nonHierarchicalReferencesF) {
         if (!ref.node) {
             // could be a special case of a frequently use target node such as ModellingRule_Mandatory that do not back trace
             // their reference
             continue;
         }
-        (0, node_opcua_assert_1.assert)(ref.isForward);
+        assert(ref.isForward);
         ref.node?.removeReference({
             isForward: !ref.isForward,
             nodeId: node.nodeId,
@@ -93,9 +87,9 @@ function detachNode(node) {
         });
     }
     // remove reversed Hierarchical references
-    const hierarchicalReferences = node.findReferencesEx("HierarchicalReferences", node_opcua_data_model_1.BrowseDirection.Inverse);
+    const hierarchicalReferences = node.findReferencesEx("HierarchicalReferences", BrowseDirection.Inverse);
     for (const ref of hierarchicalReferences) {
-        (0, node_opcua_assert_1.assert)(!ref.isForward);
+        assert(!ref.isForward);
         const parent = addressSpace.findNode(ref.nodeId);
         parent.removeReference({
             isForward: !ref.isForward,
@@ -109,14 +103,14 @@ function toNodeId(nodeId) {
     if (!nodeId) {
         return undefined;
     }
-    if (nodeId instanceof node_opcua_nodeid_1.NodeId) {
+    if (nodeId instanceof NodeId) {
         return nodeId;
     }
     if (typeof nodeId === "string") {
-        return (0, node_opcua_nodeid_1.coerceNodeId)(nodeId);
+        return coerceNodeId(nodeId);
     }
     if (typeof nodeId === "number") {
-        return (0, node_opcua_nodeid_1.coerceNodeId)(nodeId);
+        return coerceNodeId(nodeId);
     }
     return nodeId.nodeId;
 }
@@ -132,8 +126,8 @@ function toNodeId(nodeId) {
  *
  * @internal
  */
-class NamespaceImpl {
-    static _handle_hierarchy_parent = handle_hierarchy_parent_js_1._handle_hierarchy_parent;
+export class NamespaceImpl {
+    static _handle_hierarchy_parent = _handle_hierarchy_parent;
     static isNonEmptyQualifiedName = isNonEmptyQualifiedName;
     namespaceUri;
     addressSpace;
@@ -154,7 +148,7 @@ class NamespaceImpl {
     defaultAccessRestrictions;
     defaultRolePermissions;
     constructor(options) {
-        // c8 ignore next
+        /* c8 ignore next */
         if (!(typeof options.namespaceUri === "string")) {
             throw new Error(`NamespaceImpl constructor: namespaceUri must exists and be a string : got ${options.namespaceUri}`);
         }
@@ -176,7 +170,7 @@ class NamespaceImpl {
         this._referenceTypeMap = new Map();
         this._referenceTypeMapInv = new Map();
         this._dataTypeMap = new Map();
-        this._nodeIdManager = new nodeid_manager_js_1.NodeIdManager(this.index, this.addressSpace);
+        this._nodeIdManager = new NodeIdManager(this.index, this.addressSpace);
     }
     getDefaultNamespace() {
         return this.index === 0 ? this : this.addressSpace.getDefaultNamespace();
@@ -278,7 +272,7 @@ class NamespaceImpl {
     }
     findNode2(nodeId) {
         // this one is faster assuming you have a nodeId
-        (0, node_opcua_assert_1.assert)(nodeId.namespace === this.index);
+        assert(nodeId.namespace === this.index);
         return this._nodeid_index.get(_makeHashKey(nodeId)) || null;
     }
     findNode(nodeId) {
@@ -287,7 +281,7 @@ class NamespaceImpl {
                 nodeId = `ns=${this.index};${nodeId}`;
             }
         }
-        nodeId = (0, node_opcua_nodeid_1.resolveNodeId)(nodeId);
+        nodeId = resolveNodeId(nodeId);
         return this.findNode2(nodeId);
     }
     /**
@@ -329,9 +323,9 @@ class NamespaceImpl {
      * @return {ReferenceType}
      */
     findReferenceTypeFromInverseName(inverseName) {
-        (0, node_opcua_assert_1.assert)(typeof inverseName === "string");
+        assert(typeof inverseName === "string");
         const node = this._referenceTypeMapInv.get(inverseName);
-        (0, node_opcua_assert_1.assert)(!node || (node.nodeClass === node_opcua_data_model_1.NodeClass.ReferenceType && node.inverseName.text === inverseName));
+        assert(!node || (node.nodeClass === NodeClass.ReferenceType && node.inverseName.text === inverseName));
         return node ? node : null;
     }
     /**
@@ -341,9 +335,9 @@ class NamespaceImpl {
      * @param nodeId {NodeId} NodeId must belong to this namespace
      */
     addAlias(alias_name, nodeId) {
-        (0, node_opcua_assert_1.assert)(typeof alias_name === "string");
-        (0, node_opcua_assert_1.assert)(nodeId instanceof node_opcua_nodeid_1.NodeId);
-        (0, node_opcua_assert_1.assert)(nodeId.namespace === this.index);
+        assert(typeof alias_name === "string");
+        assert(nodeId instanceof NodeId);
+        assert(nodeId.namespace === this.index);
         this._aliases.set(alias_name, nodeId);
     }
     resolveAlias(name) {
@@ -364,10 +358,10 @@ class NamespaceImpl {
      *
      */
     addObjectType(options) {
-        (0, node_opcua_assert_1.assert)(!Object.hasOwn(options, "dataType"), "an objectType should not have a dataType");
-        (0, node_opcua_assert_1.assert)(!Object.hasOwn(options, "valueRank"), "an objectType should not have a valueRank");
-        (0, node_opcua_assert_1.assert)(!Object.hasOwn(options, "arrayDimensions"), "an objectType should not have a arrayDimensions");
-        return this._addObjectOrVariableType(options, "BaseObjectType", node_opcua_data_model_1.NodeClass.ObjectType);
+        assert(!Object.hasOwn(options, "dataType"), "an objectType should not have a dataType");
+        assert(!Object.hasOwn(options, "valueRank"), "an objectType should not have a valueRank");
+        assert(!Object.hasOwn(options, "arrayDimensions"), "an objectType should not have a arrayDimensions");
+        return this._addObjectOrVariableType(options, "BaseObjectType", NodeClass.ObjectType);
     }
     /**
      * add a new Variable type to the address space
@@ -385,14 +379,14 @@ class NamespaceImpl {
      *
      */
     addVariableType(options) {
-        (0, node_opcua_assert_1.assert)(!Object.hasOwn(options, "arrayDimension"), "Do you mean ArrayDimensions ?");
+        assert(!Object.hasOwn(options, "arrayDimension"), "Do you mean ArrayDimensions ?");
         // dataType
         options.dataType = options.dataType || "Int32";
         options.dataType = this.addressSpace._coerce_DataType(options.dataType);
         // valueRank/ arrayDimensions
-        (0, node_opcua_variant_1.verifyRankAndDimensions)(options);
+        verifyRankAndDimensions(options);
         // arrayDimensions
-        const variableType = this._addObjectOrVariableType(options, "BaseVariableType", node_opcua_data_model_1.NodeClass.VariableType);
+        const variableType = this._addObjectOrVariableType(options, "BaseVariableType", NodeClass.VariableType);
         variableType.dataType = options.dataType;
         variableType.valueRank = options.valueRank || 0;
         variableType.arrayDimensions = options.arrayDimensions || [];
@@ -403,19 +397,19 @@ class NamespaceImpl {
      */
     addVariable(options) {
         if (Object.hasOwn(options, "propertyOf") && options.propertyOf) {
-            (0, node_opcua_assert_1.assert)(!options.typeDefinition || options.typeDefinition === "PropertyType");
+            assert(!options.typeDefinition || options.typeDefinition === "PropertyType");
             options.typeDefinition = options.typeDefinition || "PropertyType";
         }
         else {
-            (0, node_opcua_assert_1.assert)(!options.typeDefinition || options.typeDefinition !== "PropertyType");
+            assert(!options.typeDefinition || options.typeDefinition !== "PropertyType");
         }
         return this._addVariable(options);
     }
     addView(options) {
-        (0, node_opcua_assert_1.assert)(Object.hasOwn(options, "browseName"));
-        (0, node_opcua_assert_1.assert)(Object.hasOwn(options, "organizedBy"));
+        assert(Object.hasOwn(options, "browseName"));
+        assert(Object.hasOwn(options, "organizedBy"));
         const browseName = options.browseName;
-        (0, node_opcua_assert_1.assert)(typeof browseName === "string");
+        assert(typeof browseName === "string");
         const addressSpace = this.addressSpace;
         const baseDataVariableTypeId = addressSpace.findVariableType("BaseDataVariableType")?.nodeId;
         // ------------------------------------------ TypeDefinition
@@ -423,28 +417,28 @@ class NamespaceImpl {
         options.references = options.references || [];
         options.references.push({
             isForward: true,
-            nodeId: toNodeId(_typeDefinition) || node_opcua_nodeid_1.NodeId.nullNodeId,
+            nodeId: toNodeId(_typeDefinition) || NodeId.nullNodeId,
             referenceType: "HasTypeDefinition"
         });
         const createOptions = options;
-        (0, node_opcua_assert_1.assert)(!createOptions.nodeClass);
-        createOptions.nodeClass = node_opcua_data_model_1.NodeClass.View;
+        assert(!createOptions.nodeClass);
+        createOptions.nodeClass = NodeClass.View;
         const view = this.createNode(createOptions);
-        (0, node_opcua_assert_1.assert)(view.nodeId instanceof node_opcua_nodeid_1.NodeId);
-        (0, node_opcua_assert_1.assert)(view.nodeClass === node_opcua_data_model_1.NodeClass.View);
+        assert(view.nodeId instanceof NodeId);
+        assert(view.nodeClass === NodeClass.View);
         return view;
     }
     addObject(options1) {
         const options = options1;
-        (0, node_opcua_assert_1.assert)(!options.nodeClass || options.nodeClass === node_opcua_data_model_1.NodeClass.Object);
-        options.nodeClass = node_opcua_data_model_1.NodeClass.Object;
+        assert(!options.nodeClass || options.nodeClass === NodeClass.Object);
+        options.nodeClass = NodeClass.Object;
         const typeDefinition = options.typeDefinition || "BaseObjectType";
         options.references = options.references || [];
         options.references.push({ referenceType: "HasTypeDefinition", isForward: true, nodeId: typeDefinition });
         options.eventNotifier = +(options.eventNotifier || 0);
         const obj = this.createNode(options);
-        (0, node_opcua_assert_1.assert)(obj instanceof ua_object_impl_js_1.UAObjectImpl);
-        (0, node_opcua_assert_1.assert)(obj.nodeClass === node_opcua_data_model_1.NodeClass.Object);
+        assert(obj instanceof UAObjectImpl);
+        assert(obj.nodeClass === NodeClass.Object);
         return obj;
     }
     /**
@@ -462,10 +456,10 @@ class NamespaceImpl {
             options = { browseName: options };
         }
         const addressSpace = this.addressSpace;
-        (0, node_opcua_assert_1.assert)(!options.typeDefinition, "addFolder does not expect typeDefinition to be defined ");
+        assert(!options.typeDefinition, "addFolder does not expect typeDefinition to be defined ");
         const typeDefinition = addressSpace._coerceTypeDefinition("FolderType");
         parentFolder = addressSpace._coerceFolder(parentFolder);
-        options.nodeClass = node_opcua_data_model_1.NodeClass.Object;
+        options.nodeClass = NodeClass.Object;
         options.references = [
             { referenceType: "HasTypeDefinition", isForward: true, nodeId: typeDefinition },
             { referenceType: "Organizes", isForward: false, nodeId: parentFolder.nodeId }
@@ -483,12 +477,12 @@ class NamespaceImpl {
     addReferenceType(options) {
         const addressSpace = this.addressSpace;
         const options1 = options;
-        options1.nodeClass = node_opcua_data_model_1.NodeClass.ReferenceType;
+        options1.nodeClass = NodeClass.ReferenceType;
         options1.references = options.references || [];
         options1.nodeId = options.nodeId;
         if (options.subtypeOf) {
-            const subtypeOfNodeId = addressSpace._coerceType(options.subtypeOf, "References", node_opcua_data_model_1.NodeClass.ReferenceType);
-            (0, node_opcua_assert_1.assert)(subtypeOfNodeId);
+            const subtypeOfNodeId = addressSpace._coerceType(options.subtypeOf, "References", NodeClass.ReferenceType);
+            assert(subtypeOfNodeId);
             options1.references.push({
                 isForward: false,
                 nodeId: subtypeOfNodeId,
@@ -505,17 +499,17 @@ class NamespaceImpl {
     // compared with their parameters erased to constraints, so declaring the narrower one
     // here makes this method fail to satisfy the very interface it implements
     addMultiStateDiscrete(options) {
-        return (0, ua_multistate_discrete_impl_js_1._addMultiStateDiscrete)(this, options);
+        return _addMultiStateDiscrete(this, options);
     }
     /**
 
      */
     createDataType(options) {
-        (0, node_opcua_assert_1.assert)(Object.hasOwn(options, "isAbstract"), "must provide isAbstract");
-        (0, node_opcua_assert_1.assert)(!Object.hasOwn(options, "nodeClass"));
-        (0, node_opcua_assert_1.assert)(Object.hasOwn(options, "browseName"), "must provide a browseName");
+        assert(Object.hasOwn(options, "isAbstract"), "must provide isAbstract");
+        assert(!Object.hasOwn(options, "nodeClass"));
+        assert(Object.hasOwn(options, "browseName"), "must provide a browseName");
         const options1 = options;
-        options1.nodeClass = node_opcua_data_model_1.NodeClass.DataType;
+        options1.nodeClass = NodeClass.DataType;
         options1.references = options.references || [];
         if (options1.references.length === 0) {
             if (!options1.subtypeOf) {
@@ -523,7 +517,7 @@ class NamespaceImpl {
             }
         }
         if (options1.subtypeOf) {
-            if (!(options1.subtypeOf instanceof ua_data_type_impl_js_1.UADataTypeImpl)) {
+            if (!(options1.subtypeOf instanceof UADataTypeImpl)) {
                 options1.subtypeOf = this.addressSpace.findDataType(options1.subtypeOf);
             }
             if (!options1.subtypeOf) {
@@ -551,21 +545,21 @@ class NamespaceImpl {
         let node = null;
         const addressSpace = this.addressSpace;
         addressSpace.modelChangeTransaction(() => {
-            (0, node_opcua_assert_1.assert)(isNonEmptyQualifiedName(options.browseName));
+            assert(isNonEmptyQualifiedName(options.browseName));
             // xx assert(Object.prototype.hasOwnProperty.call(options,"browseName") && options.browseName.length > 0);
-            (0, node_opcua_assert_1.assert)(Object.hasOwn(options, "nodeClass"));
+            assert(Object.hasOwn(options, "nodeClass"));
             options.references = addressSpace.normalizeReferenceTypes(options.references);
             const references = _copy_references(options.references);
-            (0, handle_hierarchy_parent_js_1._handle_hierarchy_parent)(addressSpace, references, options);
+            _handle_hierarchy_parent(addressSpace, references, options);
             _handle_event_hierarchy_parent(addressSpace, references, options);
-            (0, namespace_private_js_1.UANamespace_process_modelling_rule)(references, options.modellingRule);
+            UANamespace_process_modelling_rule(references, options.modellingRule);
             options.references = references;
             node = this.internalCreateNode(options);
-            (0, node_opcua_assert_1.assert)(node.nodeId instanceof node_opcua_nodeid_1.NodeId);
+            assert(node.nodeId instanceof NodeId);
             node.propagate_back_references();
             node.install_extra_properties();
             _create_node_version_if_needed(node, options);
-            (0, address_space_change_event_tools_js_1._handle_model_change_event)(node);
+            _handle_model_change_event(node);
         });
         return node;
     }
@@ -579,8 +573,8 @@ class NamespaceImpl {
      */
     deleteNode(nodeOrNodeId) {
         let node = null;
-        let nodeId = new node_opcua_nodeid_1.NodeId();
-        if (nodeOrNodeId instanceof node_opcua_nodeid_1.NodeId) {
+        let nodeId = new NodeId();
+        if (nodeOrNodeId instanceof NodeId) {
             nodeId = nodeOrNodeId;
             node = this.findNode(nodeId);
             // c8 ignore next
@@ -588,7 +582,7 @@ class NamespaceImpl {
                 throw new Error(` deleteNode : cannot find node with nodeId${nodeId.toString()}`);
             }
         }
-        else if (nodeOrNodeId instanceof base_node_impl_js_1.BaseNodeImpl) {
+        else if (nodeOrNodeId instanceof BaseNodeImpl) {
             node = nodeOrNodeId;
             nodeId = node.nodeId;
         }
@@ -603,11 +597,11 @@ class NamespaceImpl {
                 throw new Error("this node doesn't belong to this namespace");
             }
             // notify parent that node is being removed
-            const hierarchicalReferences = node.findReferencesEx("HierarchicalReferences", node_opcua_data_model_1.BrowseDirection.Inverse);
+            const hierarchicalReferences = node.findReferencesEx("HierarchicalReferences", BrowseDirection.Inverse);
             for (const ref of hierarchicalReferences) {
-                (0, node_opcua_assert_1.assert)(!ref.isForward);
+                assert(!ref.isForward);
                 const parent = addressSpace.findNode(ref.nodeId);
-                (0, node_opcua_assert_1.assert)(parent);
+                assert(parent);
                 parent._on_child_removed(node);
             }
             function deleteNodePointedByReference(ref) {
@@ -616,10 +610,10 @@ class NamespaceImpl {
             }
             // recursively delete all nodes below in the hierarchy of nodes
             // TODO : a better idea would be to extract any references of type "HasChild"
-            const components = node.findReferencesEx("HasComponent", node_opcua_data_model_1.BrowseDirection.Forward);
-            const properties = node.findReferencesEx("HasProperty", node_opcua_data_model_1.BrowseDirection.Forward);
+            const components = node.findReferencesEx("HasComponent", BrowseDirection.Forward);
+            const properties = node.findReferencesEx("HasProperty", BrowseDirection.Forward);
             // TODO: shall we delete nodes pointed by "Organizes" links here ?
-            const subFolders = node.findReferencesEx("Organizes", node_opcua_data_model_1.BrowseDirection.Forward);
+            const subFolders = node.findReferencesEx("Organizes", BrowseDirection.Forward);
             for (const r of components) {
                 deleteNodePointedByReference(r);
             }
@@ -629,13 +623,89 @@ class NamespaceImpl {
             for (const r of subFolders) {
                 deleteNodePointedByReference(r);
             }
-            (0, address_space_change_event_tools_js_1._handle_delete_node_model_change_event)(node);
+            _handle_delete_node_model_change_event(node);
             detachNode(node);
             // delete nodes from global index
             const namespace = addressSpace.getNamespace(node.nodeId.namespace);
             namespace._deleteNode(node);
         });
     }
+    /**
+     * Empty the namespace: every node it holds goes, and so does every reference that crossed
+     * between one of them and a node of another namespace. The namespace object itself survives,
+     * registered under the same index and uri, ready to be populated again - this is a recycle,
+     * not a {@link dispose}.
+     *
+     * Only the references that cross out are severed. A reference between two nodes of this
+     * namespace needs no work at all: both ends are about to be dropped and nothing outside will
+     * ever ask about them again. On a model grafted onto loaded base nodesets the crossing
+     * references are a small fraction of the total, which is what makes this cheaper than
+     * deleting the nodes one by one.
+     *
+     * @internal
+     *
+     * Callers want {@link IAddressSpace.deleteNamespace}: the rest of the operation - the single
+     * model-change transaction, the DataType factory of this namespace, the address space's set
+     * of historizing nodes - is address-space state that a namespace has no business reaching
+     * into.
+     */
+    _deleteAllNodes() {
+        const addressSpace = this.addressSpace;
+        const index = this.index;
+        // a node deleted while someone watches for model changes still has to say so; the probe
+        // is skipped wholesale when nobody is listening (see AddressSpace#suspendModelChangeEvents)
+        for (const node of this._nodeid_index.values()) {
+            _handle_delete_node_model_change_event(node);
+        }
+        for (const node of this._nodeid_index.values()) {
+            const _private = BaseNode_getPrivate(node);
+            // snapshot first: removing the far end of a reference mutates this node's own indexes
+            const crossing = [];
+            for (const ref of _private._referenceIdx.values()) {
+                if (ref.nodeId.namespace !== index) {
+                    crossing.push(ref);
+                }
+            }
+            for (const ref of _private._back_referenceIdx.values()) {
+                if (ref.nodeId.namespace !== index) {
+                    crossing.push(ref);
+                }
+            }
+            for (const ref of crossing) {
+                const other = addressSpace.findNode(ref.nodeId);
+                if (!other) {
+                    // the other end was never there, or has gone already: nothing holds this
+                    continue;
+                }
+                // removeReference copes with the reference being held by either end, and undoes
+                // the child accessor, the hierarchical index and the memoized scans on both
+                other.removeReference({
+                    isForward: !ref.isForward,
+                    nodeId: node.nodeId,
+                    referenceType: ref.referenceType
+                });
+            }
+        }
+        for (const node of this._nodeid_index.values()) {
+            node.dispose();
+        }
+        // the per-node unregister of _deleteNode would walk every map entry; emptying them
+        // outright says the same thing and is what makes the namespace reusable
+        this._nodeid_index = new Map();
+        this._aliases = new Map();
+        this._objectTypeMap = new Map();
+        this._variableTypeMap = new Map();
+        this._referenceTypeMap = new Map();
+        this._referenceTypeMapInv = new Map();
+        this._dataTypeMap = new Map();
+        // the counter restarts, so a second population hands out the same ids as the first; the
+        // symbolic name table is kept, for the same reason
+        this._nodeIdManager.reset();
+        // the header the nodeset carried, which the next population will set again
+        this._requiredModels = undefined;
+        this.version = "0.0.0";
+        this.publicationDate = new Date(Date.UTC(1900, 0, 1));
+    }
     /**
      * @internal
      */
@@ -698,7 +768,7 @@ class NamespaceImpl {
             dataType,
             typeDefinition: dataItemType.nodeId
         });
-        (0, add_dataItem_stuff_js_1.add_dataItem_stuff)(variable, options);
+        add_dataItem_stuff(variable, options);
         variable.install_extra_properties();
         return variable;
     }
@@ -737,7 +807,7 @@ class NamespaceImpl {
      */
     addAnalogDataItem(options) {
         const addressSpace = this.addressSpace;
-        (0, node_opcua_assert_1.assert)(Object.hasOwn(options, "engineeringUnitsRange"), "expecting engineeringUnitsRange");
+        assert(Object.hasOwn(options, "engineeringUnitsRange"), "expecting engineeringUnitsRange");
         const dataType = options.dataType || "Number";
         const analogItemType = addressSpace.findVariableType("AnalogItemType");
         if (!analogItemType) {
@@ -749,7 +819,7 @@ class NamespaceImpl {
         // silently downgrading the variable to a plain AnalogItemType.
         let requestedTypeDefinition = analogItemType;
         if (options.typeDefinition) {
-            const t = options.typeDefinition instanceof base_node_impl_js_1.BaseNodeImpl
+            const t = options.typeDefinition instanceof BaseNodeImpl
                 ? options.typeDefinition
                 : addressSpace.findVariableType(options.typeDefinition);
             if (!t) {
@@ -760,7 +830,7 @@ class NamespaceImpl {
             }
             requestedTypeDefinition = t;
         }
-        const isStrictSubtype = !(0, node_opcua_nodeid_1.sameNodeId)(requestedTypeDefinition.nodeId, analogItemType.nodeId);
+        const isStrictSubtype = !sameNodeId(requestedTypeDefinition.nodeId, analogItemType.nodeId);
         let variable;
         if (isStrictSubtype) {
             // instantiate the requested subtype so that its own mandatory members
@@ -788,7 +858,7 @@ class NamespaceImpl {
             const clone_options = { ...options, dataType, typeDefinition: analogItemType.nodeId };
             variable = this.addVariable(clone_options);
         }
-        (0, add_dataItem_stuff_js_1.add_dataItem_stuff)(variable, options);
+        add_dataItem_stuff(variable, options);
         // mandatory (EURange in the specs)
         // OPC Unified Architecture, Part 8  6  Release 1.02
         // EURange  defines the value range likely to be obtained in normal operation. It is intended for such
@@ -811,15 +881,15 @@ class NamespaceImpl {
                 modellingRule: options.modellingRule,
                 propertyOf: variable,
                 typeDefinition: "PropertyType",
-                value: new node_opcua_variant_1.Variant({
-                    dataType: node_opcua_variant_1.DataType.ExtensionObject,
-                    value: new node_opcua_types_1.Range(options.engineeringUnitsRange)
+                value: new Variant({
+                    dataType: DataType.ExtensionObject,
+                    value: new Range(options.engineeringUnitsRange)
                 })
             });
         if (euRangeExisting) {
-            euRange.setValueFromSource(new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.ExtensionObject, value: new node_opcua_types_1.Range(options.engineeringUnitsRange) }), node_opcua_status_code_1.StatusCodes.Good);
+            euRange.setValueFromSource(new Variant({ dataType: DataType.ExtensionObject, value: new Range(options.engineeringUnitsRange) }), StatusCodes.Good);
         }
-        (0, node_opcua_assert_1.assert)(euRange.readValue().value.value instanceof node_opcua_types_1.Range);
+        assert(euRange.readValue().value.value instanceof Range);
         // the SemanticsChanged wiring of EURange/InstrumentRange/EngineeringUnits is generic and
         // lives in impl/data_access/semantics_changed.ts: it covers DataItems built any other way too.
         if (Object.hasOwn(options, "instrumentRange")) {
@@ -833,19 +903,19 @@ class NamespaceImpl {
                     modellingRule: options.modellingRule ? "Mandatory" : undefined,
                     propertyOf: variable,
                     typeDefinition: "PropertyType",
-                    value: new node_opcua_variant_1.Variant({
-                        dataType: node_opcua_variant_1.DataType.ExtensionObject,
-                        value: new node_opcua_types_1.Range(options.instrumentRange)
+                    value: new Variant({
+                        dataType: DataType.ExtensionObject,
+                        value: new Range(options.instrumentRange)
                     })
                 });
             if (instrumentRangeExisting) {
-                instrumentRange.setValueFromSource(new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.ExtensionObject, value: new node_opcua_types_1.Range(options.instrumentRange) }), node_opcua_status_code_1.StatusCodes.Good);
+                instrumentRange.setValueFromSource(new Variant({ dataType: DataType.ExtensionObject, value: new Range(options.instrumentRange) }), StatusCodes.Good);
             }
         }
         variable.acceptValueOutOfRange = options.acceptValueOutOfRange;
         if (Object.hasOwn(options, "engineeringUnits")) {
-            const engineeringUnits = new node_opcua_types_1.EUInformation(options.engineeringUnits);
-            (0, node_opcua_assert_1.assert)(engineeringUnits instanceof node_opcua_types_1.EUInformation, "expecting engineering units");
+            const engineeringUnits = new EUInformation(options.engineeringUnits);
+            assert(engineeringUnits instanceof EUInformation, "expecting engineering units");
             // EngineeringUnits  specifies the units for the   DataItem‟s value (e.g., degree, hertz, seconds).   The
             // EUInformation   type is specified in   5.6.3.
             const euExisting = variable.getPropertyByName("EngineeringUnits");
@@ -858,13 +928,13 @@ class NamespaceImpl {
                     modellingRule: options.modellingRule ? "Mandatory" : undefined,
                     propertyOf: variable,
                     typeDefinition: "PropertyType",
-                    value: new node_opcua_variant_1.Variant({
-                        dataType: node_opcua_variant_1.DataType.ExtensionObject,
+                    value: new Variant({
+                        dataType: DataType.ExtensionObject,
                         value: engineeringUnits
                     })
                 });
             if (euExisting) {
-                eu.setValueFromSource(new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.ExtensionObject, value: engineeringUnits }), node_opcua_status_code_1.StatusCodes.Good);
+                eu.setValueFromSource(new Variant({ dataType: DataType.ExtensionObject, value: engineeringUnits }), StatusCodes.Good);
             }
         }
         variable.install_extra_properties();
@@ -915,7 +985,7 @@ class NamespaceImpl {
      *      });
      */
     addMultiStateValueDiscrete(options) {
-        return (0, ua_multistate_value_discrete_impl_js_1._addMultiStateValueDiscrete)(this, options);
+        return _addMultiStateValueDiscrete(this, options);
     }
     // -
     /**
@@ -948,9 +1018,9 @@ class NamespaceImpl {
      * @param options.value
      */
     addYArrayItem(options) {
-        (0, node_opcua_assert_1.assert)(Object.hasOwn(options, "engineeringUnitsRange"), "expecting engineeringUnitsRange");
-        (0, node_opcua_assert_1.assert)(Object.hasOwn(options, "axisScaleType"), "expecting axisScaleType");
-        (0, node_opcua_assert_1.assert)(options.xAxisDefinition !== null && typeof options.xAxisDefinition === "object", "expecting a xAxisDefinition");
+        assert(Object.hasOwn(options, "engineeringUnitsRange"), "expecting engineeringUnitsRange");
+        assert(Object.hasOwn(options, "axisScaleType"), "expecting axisScaleType");
+        assert(options.xAxisDefinition !== null && typeof options.xAxisDefinition === "object", "expecting a xAxisDefinition");
         const addressSpace = this.addressSpace;
         const YArrayItemType = addressSpace.findVariableType("YArrayItemType");
         if (!YArrayItemType) {
@@ -968,33 +1038,33 @@ class NamespaceImpl {
             optionals
         });
         function coerceAxisScale(value) {
-            const ret = node_opcua_data_access_1.AxisScaleEnumeration[value];
-            (0, node_opcua_assert_1.assert)(!(0, node_opcua_utils_1.isNullOrUndefined)(ret));
+            const ret = AxisScaleEnumeration[value];
+            assert(!isNullOrUndefined(ret));
             return ret;
         }
-        variable.setValueFromSource(options.value, node_opcua_status_code_1.StatusCodes.Good);
-        variable.euRange.setValueFromSource(new node_opcua_variant_1.Variant({
-            dataType: node_opcua_variant_1.DataType.ExtensionObject,
-            value: new node_opcua_types_1.Range(options.engineeringUnitsRange)
+        variable.setValueFromSource(options.value, StatusCodes.Good);
+        variable.euRange.setValueFromSource(new Variant({
+            dataType: DataType.ExtensionObject,
+            value: new Range(options.engineeringUnitsRange)
         }));
         if (Object.hasOwn(options, "instrumentRange") && variable.instrumentRange) {
-            variable.instrumentRange.setValueFromSource(new node_opcua_variant_1.Variant({
-                dataType: node_opcua_variant_1.DataType.ExtensionObject,
-                value: new node_opcua_types_1.Range(options.instrumentRange)
+            variable.instrumentRange.setValueFromSource(new Variant({
+                dataType: DataType.ExtensionObject,
+                value: new Range(options.instrumentRange)
             }));
         }
-        variable.title.setValueFromSource(new node_opcua_variant_1.Variant({
-            dataType: node_opcua_variant_1.DataType.LocalizedText,
-            value: (0, node_opcua_data_model_1.coerceLocalizedText)(options.title || "")
+        variable.title.setValueFromSource(new Variant({
+            dataType: DataType.LocalizedText,
+            value: coerceLocalizedText(options.title || "")
         }));
         // Linear/Log/Ln
-        variable.axisScaleType.setValueFromSource(new node_opcua_variant_1.Variant({
-            dataType: node_opcua_variant_1.DataType.Int32,
+        variable.axisScaleType.setValueFromSource(new Variant({
+            dataType: DataType.Int32,
             value: coerceAxisScale(options.axisScaleType)
         }));
-        variable.xAxisDefinition.setValueFromSource(new node_opcua_variant_1.Variant({
-            dataType: node_opcua_variant_1.DataType.ExtensionObject,
-            value: new node_opcua_types_1.AxisInformation(options.xAxisDefinition)
+        variable.xAxisDefinition.setValueFromSource(new Variant({
+            dataType: DataType.ExtensionObject,
+            value: new AxisInformation(options.xAxisDefinition)
         }));
         return variable;
     }
@@ -1012,17 +1082,17 @@ class NamespaceImpl {
      */
     addMethod(parentObject, options) {
         const addressSpace = this.addressSpace;
-        (0, node_opcua_assert_1.assert)(parentObject !== null && typeof parentObject === "object" && parentObject instanceof base_node_impl_js_1.BaseNodeImpl, "expecting a valid parent object");
-        (0, node_opcua_assert_1.assert)(Object.hasOwn(options, "browseName"));
+        assert(parentObject !== null && typeof parentObject === "object" && parentObject instanceof BaseNodeImpl, "expecting a valid parent object");
+        assert(Object.hasOwn(options, "browseName"));
         options.componentOf = parentObject;
         const method = this._addMethod(options);
         const propertyTypeId = addressSpace._coerce_VariableTypeIds("PropertyType");
         const nodeId_ArgumentDataType = "Argument"; // makeNodeId(DataTypeIds.Argument);
         if (options.inputArguments) {
-            const _inputArgs = new node_opcua_variant_1.Variant({
-                arrayType: node_opcua_variant_1.VariantArrayType.Array,
-                dataType: node_opcua_variant_1.DataType.ExtensionObject,
-                value: options.inputArguments.map((opt) => new node_opcua_types_1.Argument(opt))
+            const _inputArgs = new Variant({
+                arrayType: VariantArrayType.Array,
+                dataType: DataType.ExtensionObject,
+                value: options.inputArguments.map((opt) => new Argument(opt))
             });
             const inputArguments = this.addVariable({
                 accessLevel: "CurrentRead",
@@ -1041,14 +1111,14 @@ class NamespaceImpl {
                 valueRank: 1
             });
             inputArguments.setValueFromSource(_inputArgs);
-            (0, node_opcua_assert_1.assert)(inputArguments.typeDefinition.toString() === propertyTypeId.toString());
-            (0, node_opcua_assert_1.assert)(Array.isArray(inputArguments.arrayDimensions));
+            assert(inputArguments.typeDefinition.toString() === propertyTypeId.toString());
+            assert(Array.isArray(inputArguments.arrayDimensions));
         }
         if (options.outputArguments) {
-            const _outputArgs = new node_opcua_variant_1.Variant({
-                arrayType: node_opcua_variant_1.VariantArrayType.Array,
-                dataType: node_opcua_variant_1.DataType.ExtensionObject,
-                value: options.outputArguments.map((opts) => new node_opcua_types_1.Argument(opts))
+            const _outputArgs = new Variant({
+                arrayType: VariantArrayType.Array,
+                dataType: DataType.ExtensionObject,
+                value: options.outputArguments.map((opts) => new Argument(opts))
             });
             const outputArguments = this.addVariable({
                 accessLevel: "CurrentRead",
@@ -1067,8 +1137,8 @@ class NamespaceImpl {
                 valueRank: 1
             });
             outputArguments.setValueFromSource(_outputArgs);
-            (0, node_opcua_assert_1.assert)(outputArguments.typeDefinition.toString() === propertyTypeId.toString());
-            (0, node_opcua_assert_1.assert)(Array.isArray(outputArguments.arrayDimensions));
+            assert(outputArguments.typeDefinition.toString() === propertyTypeId.toString());
+            assert(Array.isArray(outputArguments.arrayDimensions));
         }
         // verifying post-conditions
         parentObject.install_extra_properties();
@@ -1136,20 +1206,20 @@ class NamespaceImpl {
         // When it is used to define the string representation of an Enumeration DataType, the value range
         // is limited to Int32, because the Enumeration DataType is a subtype of Int32. Part 8 specifies
         // other usages where the actual value might be between 8 and 64 Bit.
-        (0, node_opcua_assert_1.assert)(typeof options.browseName === "string");
-        (0, node_opcua_assert_1.assert)(Array.isArray(options.enumeration));
+        assert(typeof options.browseName === "string");
+        assert(Array.isArray(options.enumeration));
         const addressSpace = this.addressSpace;
         const enumerationType = addressSpace.findDataType("Enumeration");
-        (0, node_opcua_assert_1.assert)(enumerationType.nodeId instanceof node_opcua_nodeid_1.NodeId);
-        (0, node_opcua_assert_1.assert)(enumerationType instanceof ua_data_type_impl_js_1.UADataTypeImpl);
+        assert(enumerationType.nodeId instanceof NodeId);
+        assert(enumerationType instanceof UADataTypeImpl);
         const references = [{ referenceType: "HasSubtype", isForward: false, nodeId: enumerationType.nodeId }];
         const opts = {
             browseName: options.browseName,
             definition: undefined,
-            description: (0, node_opcua_data_model_1.coerceLocalizedText)(options.description) || null,
+            description: coerceLocalizedText(options.description) || null,
             displayName: options.displayName || null,
             isAbstract: false,
-            nodeClass: node_opcua_data_model_1.NodeClass.DataType,
+            nodeClass: NodeClass.DataType,
             references
         };
         const enumType = this.internalCreateNode(opts); //  as UAEnumeration;
@@ -1157,10 +1227,10 @@ class NamespaceImpl {
         if (typeof options.enumeration[0] === "string") {
             const enumeration = options.enumeration;
             // enumeration is a array of string
-            const definition = enumeration.map((str, _index) => (0, node_opcua_data_model_1.coerceLocalizedText)(str));
-            const value = new node_opcua_variant_1.Variant({
-                arrayType: node_opcua_variant_1.VariantArrayType.Array,
-                dataType: node_opcua_variant_1.DataType.LocalizedText,
+            const definition = enumeration.map((str, _index) => coerceLocalizedText(str));
+            const value = new Variant({
+                arrayType: VariantArrayType.Array,
+                dataType: DataType.LocalizedText,
                 value: definition
             });
             const enumStrings = this.addVariable({
@@ -1172,7 +1242,7 @@ class NamespaceImpl {
                 value,
                 valueRank: 1
             });
-            (0, node_opcua_assert_1.assert)(enumStrings.browseName.toString() === "EnumStrings");
+            assert(enumStrings.browseName.toString() === "EnumStrings");
             // set $definition
             // EnumDefinition
             //   This Structured DataType is used to provide the metadata for a custom Enumeration or
@@ -1182,11 +1252,11 @@ class NamespaceImpl {
             //   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.$fullDefinition = new node_opcua_types_1.EnumDefinition({
-                fields: enumeration.map((x, index) => new node_opcua_types_1.EnumField({
+            enumType.$fullDefinition = new EnumDefinition({
+                fields: enumeration.map((x, index) => new EnumField({
                     name: x,
-                    description: (0, node_opcua_data_model_1.coerceLocalizedText)(x),
-                    value: (0, node_opcua_basic_types_1.coerceInt64)(index)
+                    description: coerceLocalizedText(x),
+                    value: coerceInt64(index)
                 }))
             });
         }
@@ -1194,15 +1264,15 @@ class NamespaceImpl {
             const enumeration = options.enumeration;
             // construct the definition object
             const definition = enumeration.map((enumItem) => {
-                return new node_opcua_types_1.EnumValueType({
-                    description: (0, node_opcua_data_model_1.coerceLocalizedText)(enumItem.description),
-                    displayName: (0, node_opcua_data_model_1.coerceLocalizedText)(enumItem.displayName),
-                    value: (0, node_opcua_basic_types_1.coerceInt64)(enumItem.value)
+                return new EnumValueType({
+                    description: coerceLocalizedText(enumItem.description),
+                    displayName: coerceLocalizedText(enumItem.displayName),
+                    value: coerceInt64(enumItem.value)
                 });
             });
-            const value = new node_opcua_variant_1.Variant({
-                arrayType: node_opcua_variant_1.VariantArrayType.Array,
-                dataType: node_opcua_variant_1.DataType.ExtensionObject,
+            const value = new Variant({
+                arrayType: VariantArrayType.Array,
+                dataType: DataType.ExtensionObject,
                 value: definition
             });
             const enumValues = this.addVariable({
@@ -1214,12 +1284,12 @@ class NamespaceImpl {
                 value,
                 valueRank: 1
             });
-            (0, node_opcua_assert_1.assert)(enumValues.browseName.toString() === "EnumValues");
-            enumType.$fullDefinition = new node_opcua_types_1.EnumDefinition({
-                fields: enumeration.map((x, _index) => new node_opcua_types_1.EnumField({
+            assert(enumValues.browseName.toString() === "EnumValues");
+            enumType.$fullDefinition = new EnumDefinition({
+                fields: enumeration.map((x, _index) => new EnumField({
                     name: x.displayName.toString(),
                     description: x.description || "",
-                    value: (0, node_opcua_basic_types_1.coerceInt64)(x.value)
+                    value: coerceInt64(x.value)
                 }))
             });
         }
@@ -1269,7 +1339,7 @@ class NamespaceImpl {
         const addressSpace = this.addressSpace;
         isInitialState = !!isInitialState;
         const _component = component;
-        (0, node_opcua_assert_1.assert)(_component.nodeClass === node_opcua_data_model_1.NodeClass.Object || _component.nodeClass === node_opcua_data_model_1.NodeClass.ObjectType);
+        assert(_component.nodeClass === NodeClass.Object || _component.nodeClass === NodeClass.ObjectType);
         const initialStateType = addressSpace.findObjectType("InitialStateType");
         const stateType = addressSpace.findObjectType("StateType");
         if (!initialStateType) {
@@ -1293,7 +1363,7 @@ class NamespaceImpl {
         }
         // ensure state number is unique
         state.stateNumber.setValueFromSource({
-            dataType: node_opcua_variant_1.DataType.UInt32,
+            dataType: DataType.UInt32,
             value: stateNumber
         });
         return state;
@@ -1303,22 +1373,22 @@ class NamespaceImpl {
     addTransition(component, fromState, toState, transitionNumber, browseName) {
         const addressSpace = this.addressSpace;
         const _component = component;
-        (0, node_opcua_assert_1.assert)(_component.nodeClass === node_opcua_data_model_1.NodeClass.Object || _component.nodeClass === node_opcua_data_model_1.NodeClass.ObjectType);
-        (0, node_opcua_assert_1.assert)(typeof fromState === "string");
-        (0, node_opcua_assert_1.assert)(typeof toState === "string");
-        (0, node_opcua_assert_1.assert)(Number.isFinite(transitionNumber));
+        assert(_component.nodeClass === NodeClass.Object || _component.nodeClass === NodeClass.ObjectType);
+        assert(typeof fromState === "string");
+        assert(typeof toState === "string");
+        assert(Number.isFinite(transitionNumber));
         const fromStateNode = _component.getComponentByName(fromState);
         // c8 ignore next
         if (!fromStateNode) {
             throw new Error(`Cannot find state with name ${fromState}`);
         }
-        (0, node_opcua_assert_1.assert)(fromStateNode.browseName.name?.toString() === fromState);
+        assert(fromStateNode.browseName.name?.toString() === fromState);
         const toStateNode = _component.getComponentByName(toState);
         // c8 ignore next
         if (!toStateNode) {
             throw new Error(`Cannot find state with name ${toState}`);
         }
-        (0, node_opcua_assert_1.assert)(toStateNode.browseName.name?.toString() === toState);
+        assert(toStateNode.browseName.name?.toString() === toState);
         const transitionType = addressSpace.findObjectType("TransitionType");
         if (!transitionType) {
             throw new Error("Cannot find TransitionType");
@@ -1339,7 +1409,7 @@ class NamespaceImpl {
             referenceType: "FromState"
         });
         transition.transitionNumber.setValueFromSource({
-            dataType: node_opcua_variant_1.DataType.UInt32,
+            dataType: DataType.UInt32,
             value: transitionNumber
         });
         return transition;
@@ -1350,7 +1420,7 @@ class NamespaceImpl {
      * @return {UATwoStateVariable}
      */
     addTwoStateVariable(options) {
-        return (0, ua_two_state_variable_js_1._addTwoStateVariable)(this, options);
+        return _addTwoStateVariable(this, options);
     }
     /**
 
@@ -1359,42 +1429,42 @@ class NamespaceImpl {
      * @return {UATwoStateDiscrete}
      */
     addTwoStateDiscrete(options) {
-        return (0, ua_two_state_discrete_impl_js_1._addTwoStateDiscrete)(this, options);
+        return _addTwoStateDiscrete(this, options);
     }
     // --- Alarms & Conditions -------------------------------------------------
     instantiateCondition(conditionTypeId, options, data) {
-        return index_js_1.UAConditionImplBase.instantiate(this, conditionTypeId, options, data);
+        return UAConditionImplBase.instantiate(this, conditionTypeId, options, data);
     }
     instantiateAcknowledgeableCondition(conditionTypeId, options, data) {
-        return index_js_1.UAAcknowledgeableConditionImplBase.instantiate(this, conditionTypeId, options, data);
+        return UAAcknowledgeableConditionImplBase.instantiate(this, conditionTypeId, options, data);
     }
     instantiateAlarmCondition(alarmConditionTypeId, options, data) {
-        return index_js_1.UAAlarmConditionImplBase.instantiate(this, alarmConditionTypeId, options, data);
+        return UAAlarmConditionImplBase.instantiate(this, alarmConditionTypeId, options, data);
     }
     instantiateLimitAlarm(limitAlarmTypeId, options, data) {
-        return ua_limit_alarm_impl_js_1.UALimitAlarmImplBase.instantiate(this, limitAlarmTypeId, options, data);
+        return UALimitAlarmImplBase.instantiate(this, limitAlarmTypeId, options, data);
     }
     instantiateExclusiveLimitAlarm(exclusiveLimitAlarmTypeId, options, data) {
-        return ua_exclusive_limit_alarm_impl_js_1.UAExclusiveLimitAlarmImplBase.instantiate(this, exclusiveLimitAlarmTypeId, options, data);
+        return UAExclusiveLimitAlarmImplBase.instantiate(this, exclusiveLimitAlarmTypeId, options, data);
     }
     instantiateExclusiveDeviationAlarm(options, data) {
-        return ua_exclusive_deviation_alarm_impl_js_1.UAExclusiveDeviationAlarmImplBase.instantiate(this, "ExclusiveDeviationAlarmType", options, data);
+        return UAExclusiveDeviationAlarmImplBase.instantiate(this, "ExclusiveDeviationAlarmType", options, data);
     }
     instantiateNonExclusiveLimitAlarm(nonExclusiveLimitAlarmTypeId, options, data) {
-        return ua_non_exclusive_limit_alarm_impl_js_1.UANonExclusiveLimitAlarmImplBase.instantiate(this, nonExclusiveLimitAlarmTypeId, options, data);
+        return UANonExclusiveLimitAlarmImplBase.instantiate(this, nonExclusiveLimitAlarmTypeId, options, data);
     }
     instantiateNonExclusiveDeviationAlarm(options, data) {
-        return ua_non_exclusive_deviation_alarm_impl_js_1.UANonExclusiveDeviationAlarmImplBase.instantiate(this, "NonExclusiveDeviationAlarmType", options, data);
+        return UANonExclusiveDeviationAlarmImplBase.instantiate(this, "NonExclusiveDeviationAlarmType", options, data);
     }
     instantiateDiscreteAlarm(discreteAlarmType, options, data) {
-        return index_js_1.UADiscreteAlarmImplBase.instantiate(this, discreteAlarmType, options, data);
+        return UADiscreteAlarmImplBase.instantiate(this, discreteAlarmType, options, data);
     }
     instantiateOffNormalAlarm(options, data) {
-        return ua_off_normal_alarm_impl_js_1.UAOffNormalAlarmImplBase.instantiate(this, "OffNormalAlarmType", options, data);
+        return UAOffNormalAlarmImplBase.instantiate(this, "OffNormalAlarmType", options, data);
     }
     // default roles and permissions
     setDefaultRolePermissions(rolePermissions) {
-        this.defaultRolePermissions = rolePermissions ? (0, role_permissions_js_1.coerceRolePermissions)(rolePermissions) : undefined;
+        this.defaultRolePermissions = rolePermissions ? coerceRolePermissions(rolePermissions) : undefined;
     }
     getDefaultRolePermissions() {
         return this.defaultRolePermissions || null;
@@ -1403,7 +1473,7 @@ class NamespaceImpl {
         this.defaultAccessRestrictions = accessRestrictions;
     }
     getDefaultAccessRestrictions() {
-        return this.defaultAccessRestrictions || node_opcua_data_model_1.AccessRestrictionsFlag.None;
+        return this.defaultAccessRestrictions || AccessRestrictionsFlag.None;
     }
     // --- internal stuff
     constructNodeId(options) {
@@ -1413,8 +1483,8 @@ class NamespaceImpl {
         });
     }
     _register(node) {
-        (0, node_opcua_assert_1.assert)(node instanceof base_node_impl_js_1.BaseNodeImpl, "Expecting a instance of BaseNode in _register");
-        (0, node_opcua_assert_1.assert)(node.nodeId instanceof node_opcua_nodeid_1.NodeId, "Expecting a NodeId");
+        assert(node instanceof BaseNodeImpl, "Expecting a instance of BaseNode in _register");
+        assert(node.nodeId instanceof NodeId, "Expecting a NodeId");
         // c8 ignore next
         if (node.nodeId.namespace !== this.index) {
             throw new Error("node must belong to this namespace : " +
@@ -1425,8 +1495,8 @@ class NamespaceImpl {
                 " this.index = " +
                 this.index);
         }
-        (0, node_opcua_assert_1.assert)(node.nodeId.namespace === this.index, "node must belongs to this namespace");
-        (0, node_opcua_assert_1.assert)(Object.hasOwn(node, "browseName"), "Node must have a browseName");
+        assert(node.nodeId.namespace === this.index, "node must belongs to this namespace");
+        assert(Object.hasOwn(node, "browseName"), "Node must have a browseName");
         const hashKey = _makeHashKey(node.nodeId);
         // c8 ignore next
         if (this._nodeid_index.has(hashKey)) {
@@ -1450,22 +1520,22 @@ class NamespaceImpl {
         }
         this._nodeid_index.set(hashKey, node);
         switch (node.nodeClass) {
-            case node_opcua_data_model_1.NodeClass.ObjectType:
+            case NodeClass.ObjectType:
                 this._registerObjectType(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.VariableType:
+            case NodeClass.VariableType:
                 this._registerVariableType(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.ReferenceType:
+            case NodeClass.ReferenceType:
                 this._registerReferenceType(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.DataType:
+            case NodeClass.DataType:
                 this._registerDataType(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.Object:
-            case node_opcua_data_model_1.NodeClass.Variable:
-            case node_opcua_data_model_1.NodeClass.Method:
-            case node_opcua_data_model_1.NodeClass.View:
+            case NodeClass.Object:
+            case NodeClass.Variable:
+            case NodeClass.Method:
+            case NodeClass.View:
                 break;
             default:
                 errorLog("Invalid class Name", node.nodeClass);
@@ -1477,24 +1547,24 @@ class NamespaceImpl {
      * @internal
      */
     internalCreateNode(options) {
-        (0, node_opcua_assert_1.assert)(options.nodeClass !== undefined, " options.nodeClass must be specified");
-        (0, node_opcua_assert_1.assert)(options.browseName, "options.browseName must be specified");
+        assert(options.nodeClass !== undefined, " options.nodeClass must be specified");
+        assert(options.browseName, "options.browseName must be specified");
         // xx assert(options.browseName instanceof QualifiedName
         // ? (options.browseName.namespaceIndex === this.index): true,
         // "Expecting browseName to have the same namespaceIndex as the namespace");
-        options.description = (0, node_opcua_data_model_1.coerceLocalizedText)(options.description) || "";
+        options.description = coerceLocalizedText(options.description) || "";
         // browseName adjustment
         if (typeof options.browseName === "string") {
             const match = options.browseName.match(regExpNamespaceDotBrowseName);
             if (match) {
                 const correctedName = match[1];
                 // the application is using an old scheme
-                warningLog(chalk_1.default.green("Warning : since node-opcua 0.4.2 " + "namespace index should not be prepended to the browse name anymore"));
+                warningLog(chalk.green("Warning : since node-opcua 0.4.2 " + "namespace index should not be prepended to the browse name anymore"));
                 warningLog("   ", options.browseName, " will be replaced with ", correctedName);
                 warningLog(" Please update your code");
                 const indexVerify = parseInt(match[0], 10);
                 if (indexVerify !== this.index) {
-                    errorLog(chalk_1.default.red.bold("Error: namespace index used at the front of the browseName " +
+                    errorLog(chalk.red.bold("Error: namespace index used at the front of the browseName " +
                         indexVerify +
                         " do not match the index of the current namespace (" +
                         this.index +
@@ -1503,29 +1573,29 @@ class NamespaceImpl {
                         " please refer to the NodeOPCUA documentation");
                 }
             }
-            options.browseName = new node_opcua_data_model_1.QualifiedName({ name: options.browseName, namespaceIndex: this.index });
+            options.browseName = new QualifiedName({ name: options.browseName, namespaceIndex: this.index });
         }
-        else if (!(options.browseName instanceof node_opcua_data_model_1.QualifiedName)) {
-            options.browseName = new node_opcua_data_model_1.QualifiedName(options.browseName);
+        else if (!(options.browseName instanceof QualifiedName)) {
+            options.browseName = new QualifiedName(options.browseName);
         }
-        (0, node_opcua_assert_1.assert)(options.browseName instanceof node_opcua_data_model_1.QualifiedName, "Expecting options.browseName to be instanceof  QualifiedName ");
+        assert(options.browseName instanceof QualifiedName, "Expecting options.browseName to be instanceof  QualifiedName ");
         // ------------- set display name
         if (!options.displayName) {
-            (0, node_opcua_assert_1.assert)(typeof options.browseName.name === "string");
-            options.displayName = (0, node_opcua_data_model_1.coerceLocalizedText)(options.browseName.name || "");
+            assert(typeof options.browseName.name === "string");
+            options.displayName = coerceLocalizedText(options.browseName.name || "");
         }
         if (!options.nodeClass || options.nodeClass === undefined) {
             throw new Error("nodeclass must be specified");
         }
         // --- nodeId adjustment
         options.nodeId = this.constructNodeId(options);
-        (0, node_opcua_debug_1.dumpIf)(!options.nodeId, options); // missing node Id
-        (0, node_opcua_assert_1.assert)(options.nodeId instanceof node_opcua_nodeid_1.NodeId);
+        dumpIf(!options.nodeId, options); // missing node Id
+        assert(options.nodeId instanceof NodeId);
         // assert(options.browseName.namespaceIndex === this.index,"Expecting browseName to have
         // the same namespaceIndex as the namespace");
-        const Constructor = _constructors_map[node_opcua_data_model_1.NodeClass[options.nodeClass]];
+        const Constructor = _constructors_map[NodeClass[options.nodeClass]];
         if (!Constructor) {
-            throw new Error(` missing constructor for NodeClass ${node_opcua_data_model_1.NodeClass[options.nodeClass]}`);
+            throw new Error(` missing constructor for NodeClass ${NodeClass[options.nodeClass]}`);
         }
         options.addressSpace = this.addressSpace;
         const node = new Constructor(options);
@@ -1533,60 +1603,66 @@ class NamespaceImpl {
         // object shall now be registered
         // c8 ignore next
         if (doDebug) {
-            (0, node_opcua_assert_1.assert)(this.findNode(node.nodeId) !== null && typeof this.findNode(node.nodeId) === "object");
+            assert(this.findNode(node.nodeId) !== null && typeof this.findNode(node.nodeId) === "object");
         }
         return node;
     }
     _deleteNode(node) {
-        (0, node_opcua_assert_1.assert)(node instanceof base_node_impl_js_1.BaseNodeImpl);
+        assert(node instanceof BaseNodeImpl);
         const hashKey = _makeHashKey(node.nodeId);
         // c8 ignore next
         if (!this._nodeid_index.has(hashKey)) {
             throw new Error(`deleteNode : nodeId ${node.nodeId.displayText()} is not registered ${node.nodeId.toString()}`);
         }
         switch (node.nodeClass) {
-            case node_opcua_data_model_1.NodeClass.ObjectType:
+            case NodeClass.ObjectType:
                 this._unregisterObjectType(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.VariableType:
+            case NodeClass.VariableType:
                 this._unregisterVariableType(node);
                 break;
-            case node_opcua_data_model_1.NodeClass.Object:
-            case node_opcua_data_model_1.NodeClass.Variable:
-            case node_opcua_data_model_1.NodeClass.Method:
-            case node_opcua_data_model_1.NodeClass.View:
+            case NodeClass.ReferenceType:
+                this._unregisterReferenceType(node);
+                break;
+            case NodeClass.DataType:
+                this._unregisterDataType(node);
+                break;
+            case NodeClass.Object:
+            case NodeClass.Variable:
+            case NodeClass.Method:
+            case NodeClass.View:
                 break;
             default:
                 warningLog("Invalid class Name", node.nodeClass);
                 throw new Error("Invalid class name specified");
         }
         const deleted = this._nodeid_index.delete(hashKey);
-        (0, node_opcua_assert_1.assert)(deleted);
+        assert(deleted);
         node.dispose();
     }
     // --- Private stuff
     _addObjectOrVariableType(options1, topMostBaseType, nodeClass) {
         const addressSpace = this.addressSpace;
-        (0, node_opcua_assert_1.assert)(typeof topMostBaseType === "string");
-        (0, node_opcua_assert_1.assert)(nodeClass === node_opcua_data_model_1.NodeClass.ObjectType || nodeClass === node_opcua_data_model_1.NodeClass.VariableType);
+        assert(typeof topMostBaseType === "string");
+        assert(nodeClass === NodeClass.ObjectType || nodeClass === NodeClass.VariableType);
         const options = options1;
-        (0, node_opcua_assert_1.assert)(!options.nodeClass);
-        (0, node_opcua_assert_1.assert)(options.browseName);
-        (0, node_opcua_assert_1.assert)(typeof options.browseName === "string");
+        assert(!options.nodeClass);
+        assert(options.browseName);
+        assert(typeof options.browseName === "string");
         if (Object.hasOwn(options, "references")) {
             throw new Error("options.references should not be provided, use options.subtypeOf instead");
         }
         const references = [];
         function process_subtypeOf_options(options2, references1) {
             // check common misspelling mistake
-            (0, node_opcua_assert_1.assert)(!options2.subTypeOf, "misspell error : it should be 'subtypeOf' instead");
+            assert(!options2.subTypeOf, "misspell error : it should be 'subtypeOf' instead");
             if (Object.hasOwn(options2, "hasTypeDefinition")) {
                 throw new Error("hasTypeDefinition option is invalid. Do you mean typeDefinition instead ?");
             }
-            (0, node_opcua_assert_1.assert)(!options2.typeDefinition, " do you mean subtypeOf ?");
+            assert(!options2.typeDefinition, " do you mean subtypeOf ?");
             // subtypeOf is optional: _coerceType defaults to topMostBaseType when it's falsy.
             const subtypeOfNodeId = addressSpace._coerceType(options2.subtypeOf, topMostBaseType, nodeClass);
-            (0, node_opcua_assert_1.assert)(subtypeOfNodeId);
+            assert(subtypeOfNodeId);
             references1.push({
                 isForward: false,
                 nodeId: subtypeOfNodeId,
@@ -1627,7 +1703,7 @@ class NamespaceImpl {
     //     return options;
     // }
     _registerObjectType(node) {
-        (0, node_opcua_assert_1.assert)(this.index === node.nodeId.namespace);
+        assert(this.index === node.nodeId.namespace);
         const key = node.browseName.name || "";
         if (this._objectTypeMap.has(key)) {
             throw new Error(` UAObjectType already declared ${node.browseName.toString()}  ${node.nodeId.toString()}`);
@@ -1635,23 +1711,23 @@ class NamespaceImpl {
         this._objectTypeMap.set(key, node);
     }
     _registerVariableType(node) {
-        (0, node_opcua_assert_1.assert)(this.index === node.nodeId.namespace);
+        assert(this.index === node.nodeId.namespace);
         const key = node.browseName.name || "";
-        (0, node_opcua_assert_1.assert)(!this._variableTypeMap.has(key), " UAVariableType already declared");
+        assert(!this._variableTypeMap.has(key), " UAVariableType already declared");
         this._variableTypeMap.set(key, node);
     }
     _registerReferenceType(node) {
-        (0, node_opcua_assert_1.assert)(this.index === node.nodeId.namespace);
-        (0, node_opcua_assert_1.assert)(node.browseName instanceof node_opcua_data_model_1.QualifiedName);
+        assert(this.index === node.nodeId.namespace);
+        assert(node.browseName instanceof QualifiedName);
         const key = node.browseName.name || "";
         this._referenceTypeMap.set(key, node);
         this._referenceTypeMapInv.set(node.inverseName.text || "", node);
     }
     _registerDataType(node) {
-        (0, node_opcua_assert_1.assert)(this.index === node.nodeId.namespace);
+        assert(this.index === node.nodeId.namespace);
         const key = node.browseName.name || "";
-        (0, node_opcua_assert_1.assert)(node.browseName instanceof node_opcua_data_model_1.QualifiedName);
-        (0, node_opcua_assert_1.assert)(!this._dataTypeMap.has(key), " DataType already declared");
+        assert(node.browseName instanceof QualifiedName);
+        assert(!this._dataTypeMap.has(key), " DataType already declared");
         this._dataTypeMap.set(key, node);
     }
     _unregisterObjectType(node) {
@@ -1662,6 +1738,31 @@ class NamespaceImpl {
         const key = node.browseName.name || "";
         this._variableTypeMap.delete(key);
     }
+    /**
+     * the mirror of `_registerReferenceType`: both maps it fills have to be emptied, the inverse
+     * one keyed on the inverse name rather than the browse name.
+     *
+     * Only an entry that still points at this very node goes: `_registerReferenceType` does not
+     * refuse a duplicate key the way the object/variable/dataType ones do, so a second reference
+     * type of the same browse name (or the same inverse name) would otherwise have its entry
+     * removed by the deletion of the first.
+     */
+    _unregisterReferenceType(node) {
+        const key = node.browseName.name || "";
+        if (this._referenceTypeMap.get(key) === node) {
+            this._referenceTypeMap.delete(key);
+        }
+        const inverseKey = node.inverseName?.text || "";
+        if (this._referenceTypeMapInv.get(inverseKey) === node) {
+            this._referenceTypeMapInv.delete(inverseKey);
+        }
+    }
+    _unregisterDataType(node) {
+        const key = node.browseName.name || "";
+        if (this._dataTypeMap.get(key) === node) {
+            this._dataTypeMap.delete(key);
+        }
+    }
     /**
      * @private
      */
@@ -1672,8 +1773,8 @@ class NamespaceImpl {
             throw new Error("cannot find BaseDataVariableType");
         }
         const baseDataVariableTypeId = baseDataVariableType.nodeId;
-        (0, node_opcua_assert_1.assert)(Object.hasOwn(options, "browseName"), "options.browseName must be provided");
-        (0, node_opcua_assert_1.assert)(Object.hasOwn(options, "dataType"), "options.dataType must be provided");
+        assert(Object.hasOwn(options, "browseName"), "options.browseName must be provided");
+        assert(Object.hasOwn(options, "dataType"), "options.dataType must be provided");
         options.historizing = !!options.historizing;
         // c8 ignore next
         if (Object.hasOwn(options, "hasTypeDefinition")) {
@@ -1681,26 +1782,26 @@ class NamespaceImpl {
         }
         // ------------------------------------------ TypeDefinition
         let typeDefinition = options.typeDefinition || baseDataVariableTypeId;
-        if (typeDefinition instanceof base_node_impl_js_1.BaseNodeImpl) {
+        if (typeDefinition instanceof BaseNodeImpl) {
             // c8 ignore next
-            if (typeDefinition.nodeClass !== node_opcua_data_model_1.NodeClass.VariableType) {
-                const message = `invalid typeDefinition expecting a VariableType got ${node_opcua_data_model_1.NodeClass[typeDefinition.nodeClass]}`;
+            if (typeDefinition.nodeClass !== NodeClass.VariableType) {
+                const message = `invalid typeDefinition expecting a VariableType got ${NodeClass[typeDefinition.nodeClass]}`;
                 errorLog(message);
                 throw new Error(message);
             }
         }
         typeDefinition = addressSpace._coerce_VariableTypeIds(typeDefinition);
-        (0, node_opcua_assert_1.assert)(typeDefinition instanceof node_opcua_nodeid_1.NodeId);
+        assert(typeDefinition instanceof NodeId);
         // ------------------------------------------ DataType
-        options.dataType = addressSpace._coerce_DataType(options.dataType || node_opcua_variant_1.DataType.Null);
-        options.valueRank = (0, node_opcua_utils_1.isNullOrUndefined)(options.valueRank)
+        options.dataType = addressSpace._coerce_DataType(options.dataType || DataType.Null);
+        options.valueRank = isNullOrUndefined(options.valueRank)
             ? options.arrayDimensions
                 ? options.arrayDimensions.length
                 : -1
             : options.valueRank;
-        (0, node_opcua_assert_1.assert)(typeof options.valueRank === "number" && Number.isFinite(options.valueRank));
+        assert(typeof options.valueRank === "number" && Number.isFinite(options.valueRank));
         options.arrayDimensions = options.arrayDimensions || null;
-        (0, node_opcua_assert_1.assert)(options.arrayDimensions === null || Array.isArray(options.arrayDimensions));
+        assert(options.arrayDimensions === null || Array.isArray(options.arrayDimensions));
         // -----------------------------------------------------
         const hasGetter = (options) => {
             return typeof options.value?.get === "function" || typeof options.value?.timestamped_get === "function";
@@ -1725,8 +1826,8 @@ class NamespaceImpl {
                 referenceType: "HasTypeDefinition"
             }
         ]);
-        (0, node_opcua_assert_1.assert)(!options.nodeClass || options.nodeClass === node_opcua_data_model_1.NodeClass.Variable);
-        options.nodeClass = node_opcua_data_model_1.NodeClass.Variable;
+        assert(!options.nodeClass || options.nodeClass === NodeClass.Variable);
+        options.nodeClass = NodeClass.Variable;
         options.references = references;
         const variable = this.createNode(options);
         return variable;
@@ -1736,48 +1837,47 @@ class NamespaceImpl {
      */
     _addMethod(options) {
         const addressSpace = this.addressSpace;
-        (0, node_opcua_assert_1.assert)(isNonEmptyQualifiedName(options.browseName));
+        assert(isNonEmptyQualifiedName(options.browseName));
         const references = [];
-        (0, node_opcua_assert_1.assert)(isNonEmptyQualifiedName(options.browseName));
-        (0, handle_hierarchy_parent_js_1._handle_hierarchy_parent)(addressSpace, references, options);
-        (0, namespace_private_js_1.UANamespace_process_modelling_rule)(references, options.modellingRule);
+        assert(isNonEmptyQualifiedName(options.browseName));
+        _handle_hierarchy_parent(addressSpace, references, options);
+        UANamespace_process_modelling_rule(references, options.modellingRule);
         const method = this.internalCreateNode({
             browseName: options.browseName,
             description: options.description || "",
             displayName: options.displayName,
             eventNotifier: +(options.eventNotifier || 0),
             isAbstract: false,
-            nodeClass: node_opcua_data_model_1.NodeClass.Method,
+            nodeClass: NodeClass.Method,
             nodeId: options.nodeId,
             references,
             rolePermissions: options.rolePermissions
         });
-        (0, node_opcua_assert_1.assert)(method.nodeId !== null);
+        assert(method.nodeId !== null);
         method.propagate_back_references();
-        (0, node_opcua_assert_1.assert)(!method.typeDefinition);
+        assert(!method.typeDefinition);
         return method;
     }
 }
-exports.NamespaceImpl = NamespaceImpl;
 // each concrete constructor below takes a different, incompatible options type (UADataTypeOptions,
 // UAVariableOptions, ...) — the map is only ever indexed by nodeClass and invoked with the matching
 // options shape by the caller, so a wider `new (options: any) => ...` signature is required here.
 // biome-ignore lint/suspicious/noExplicitAny: see comment above
 const _constructors_map = {
-    DataType: ua_data_type_impl_js_1.UADataTypeImpl,
-    Method: ua_method_impl_js_1.UAMethodImpl,
-    Object: ua_object_impl_js_1.UAObjectImpl,
-    ObjectType: ua_object_type_impl_js_1.UAObjectTypeImpl,
-    ReferenceType: ua_reference_type_impl_js_1.UAReferenceTypeImpl,
-    Variable: ua_variable_impl_js_1.UAVariableImpl,
-    VariableType: ua_variable_type_impl_js_1.UAVariableTypeImpl,
-    View: ua_view_impl_js_1.UAViewImpl
+    DataType: UADataTypeImpl,
+    Method: UAMethodImpl,
+    Object: UAObjectImpl,
+    ObjectType: UAObjectTypeImpl,
+    ReferenceType: UAReferenceTypeImpl,
+    Variable: UAVariableImpl,
+    VariableType: UAVariableTypeImpl,
+    View: UAViewImpl
 };
 function _handle_event_hierarchy_parent(addressSpace, references, options) {
-    options.eventSourceOf = (0, handle_hierarchy_parent_js_1._coerce_parent)(addressSpace, options.eventSourceOf, addressSpace._coerceNode);
-    options.notifierOf = (0, handle_hierarchy_parent_js_1._coerce_parent)(addressSpace, options.notifierOf, addressSpace._coerceNode);
+    options.eventSourceOf = _coerce_parent(addressSpace, options.eventSourceOf, addressSpace._coerceNode);
+    options.notifierOf = _coerce_parent(addressSpace, options.notifierOf, addressSpace._coerceNode);
     if (options.eventSourceOf) {
-        (0, node_opcua_assert_1.assert)(!options.notifierOf, "notifierOf shall not be provided with eventSourceOf ");
+        assert(!options.notifierOf, "notifierOf shall not be provided with eventSourceOf ");
         references.push({
             isForward: false,
             nodeId: options.eventSourceOf.nodeId,
@@ -1786,7 +1886,7 @@ function _handle_event_hierarchy_parent(addressSpace, references, options) {
         options.eventNotifier = options.eventNotifier || 1;
     }
     else if (options.notifierOf) {
-        (0, node_opcua_assert_1.assert)(!options.eventSourceOf, "eventSourceOf shall not be provided with notifierOf ");
+        assert(!options.eventSourceOf, "eventSourceOf shall not be provided with notifierOf ");
         references.push({
             isForward: false,
             nodeId: options.notifierOf.nodeId,
@@ -1795,10 +1895,10 @@ function _handle_event_hierarchy_parent(addressSpace, references, options) {
     }
 }
 function _copy_reference(reference) {
-    (0, node_opcua_assert_1.assert)(Object.hasOwn(reference, "referenceType"));
-    (0, node_opcua_assert_1.assert)(Object.hasOwn(reference, "isForward"));
-    (0, node_opcua_assert_1.assert)(Object.hasOwn(reference, "nodeId"));
-    (0, node_opcua_assert_1.assert)(reference.nodeId instanceof node_opcua_nodeid_1.NodeId);
+    assert(Object.hasOwn(reference, "referenceType"));
+    assert(Object.hasOwn(reference, "isForward"));
+    assert(Object.hasOwn(reference, "nodeId"));
+    assert(reference.nodeId instanceof NodeId);
     return {
         isForward: reference.isForward,
         nodeId: reference.nodeId,
@@ -1809,31 +1909,31 @@ function _copy_references(references) {
     references = references || [];
     return references.map(_copy_reference);
 }
-function isNonEmptyQualifiedName(browseName) {
+export function isNonEmptyQualifiedName(browseName) {
     if (!browseName) {
         return false;
     }
     if (typeof browseName === "string") {
         return browseName.length >= 0;
     }
-    if (!(browseName instanceof node_opcua_data_model_1.QualifiedName)) {
-        browseName = new node_opcua_data_model_1.QualifiedName(browseName);
+    if (!(browseName instanceof QualifiedName)) {
+        browseName = new QualifiedName(browseName);
     }
-    (0, node_opcua_assert_1.assert)(browseName instanceof node_opcua_data_model_1.QualifiedName);
+    assert(browseName instanceof QualifiedName);
     return (browseName.name?.length || 0) > 0;
 }
 function _create_node_version_if_needed(node, options) {
-    (0, node_opcua_assert_1.assert)(options);
+    assert(options);
     if (typeof options.nodeVersion === "string") {
-        (0, node_opcua_assert_1.assert)(node.nodeClass === node_opcua_data_model_1.NodeClass.Variable || node.nodeClass === node_opcua_data_model_1.NodeClass.Object);
+        assert(node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.Object);
         // c8 ignore next
         if (node.getNodeVersion()) {
             return; // already exists
         }
         const namespace = node.namespace;
         const nodeVersion = namespace.addVariable({
-            browseName: (0, node_opcua_data_model_1.coerceQualifiedName)({ name: "NodeVersion", namespaceIndex: 0 }),
-            dataType: node_opcua_variant_1.DataType.String,
+            browseName: coerceQualifiedName({ name: "NodeVersion", namespaceIndex: 0 }),
+            dataType: DataType.String,
             propertyOf: node
         });
         const initialValue = typeof options.nodeVersion === "string" ? options.nodeVersion : "0";