node-opcua-address-space 2.56.2 → 2.60.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.56.2",
+    "version": "2.60.0",
     "description": "pure nodejs OPCUA SDK - module -address-space",
     "main": "./dist/src/index_current.js",
     "types": "./dist/source/index.d.ts",
@@ -16,40 +16,40 @@
         "c": "mocha --version"
     },
     "dependencies": {
-        "@types/lodash": "4.14.174",
-        "async": "^3.2.1",
+        "@types/lodash": "4.14.177",
+        "async": "^3.2.2",
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
         "lodash": "4.17.21",
-        "node-opcua-address-space-base": "2.56.2",
+        "node-opcua-address-space-base": "2.60.0",
         "node-opcua-assert": "2.55.0",
-        "node-opcua-basic-types": "2.56.0",
-        "node-opcua-client-dynamic-extension-object": "2.56.2",
+        "node-opcua-basic-types": "2.60.0",
+        "node-opcua-client-dynamic-extension-object": "2.60.0",
         "node-opcua-constants": "2.52.0",
-        "node-opcua-data-access": "2.56.2",
-        "node-opcua-data-model": "2.56.0",
-        "node-opcua-data-value": "2.56.0",
-        "node-opcua-date-time": "2.55.0",
-        "node-opcua-debug": "2.55.0",
+        "node-opcua-data-access": "2.60.0",
+        "node-opcua-data-model": "2.60.0",
+        "node-opcua-data-value": "2.60.0",
+        "node-opcua-date-time": "2.60.0",
+        "node-opcua-debug": "2.60.0",
         "node-opcua-enum": "2.55.0",
-        "node-opcua-factory": "2.56.0",
-        "node-opcua-nodeid": "2.55.0",
-        "node-opcua-nodeset-ua": "2.56.2",
-        "node-opcua-numeric-range": "2.56.0",
-        "node-opcua-object-registry": "2.56.0",
-        "node-opcua-pseudo-session": "2.56.2",
-        "node-opcua-schemas": "2.56.0",
-        "node-opcua-service-browse": "2.56.2",
-        "node-opcua-service-call": "2.56.2",
-        "node-opcua-service-filter": "2.56.2",
-        "node-opcua-service-history": "2.56.2",
-        "node-opcua-service-translate-browse-path": "2.56.2",
-        "node-opcua-service-write": "2.56.2",
+        "node-opcua-factory": "2.60.0",
+        "node-opcua-nodeid": "2.60.0",
+        "node-opcua-nodeset-ua": "2.60.0",
+        "node-opcua-numeric-range": "2.60.0",
+        "node-opcua-object-registry": "2.60.0",
+        "node-opcua-pseudo-session": "2.60.0",
+        "node-opcua-schemas": "2.60.0",
+        "node-opcua-service-browse": "2.60.0",
+        "node-opcua-service-call": "2.60.0",
+        "node-opcua-service-filter": "2.60.0",
+        "node-opcua-service-history": "2.60.0",
+        "node-opcua-service-translate-browse-path": "2.60.0",
+        "node-opcua-service-write": "2.60.0",
         "node-opcua-status-code": "2.56.0",
-        "node-opcua-types": "2.56.2",
-        "node-opcua-utils": "2.56.0",
-        "node-opcua-variant": "2.56.0",
-        "node-opcua-xml2json": "2.56.0",
+        "node-opcua-types": "2.60.0",
+        "node-opcua-utils": "2.60.0",
+        "node-opcua-variant": "2.60.0",
+        "node-opcua-xml2json": "2.60.0",
         "set-prototype-of": "^1.0.0",
         "thenify": "^3.3.1",
         "xml-writer": "^1.7.0"
@@ -58,14 +58,14 @@
         "humanize": "0.0.9",
         "node-opcua-benchmarker": "2.55.0",
         "node-opcua-binary-stream": "2.55.0",
-        "node-opcua-extension-object": "2.56.0",
-        "node-opcua-leak-detector": "2.56.0",
-        "node-opcua-nodesets": "2.51.0",
-        "node-opcua-packet-analyzer": "2.56.0",
-        "node-opcua-test-fixtures": "2.55.0",
+        "node-opcua-extension-object": "2.60.0",
+        "node-opcua-leak-detector": "2.60.0",
+        "node-opcua-nodesets": "2.57.0",
+        "node-opcua-packet-analyzer": "2.60.0",
+        "node-opcua-test-fixtures": "2.60.0",
         "should": "^13.2.3",
-        "sinon": "^11.1.2",
-        "source-map-support": "^0.5.20"
+        "sinon": "^12.0.1",
+        "source-map-support": "^0.5.21"
     },
     "author": "Etienne Rossignon",
     "license": "MIT",
@@ -82,5 +82,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "45dbf2f65d96a91fae6e884bb5006af4249cf1fa"
+    "gitHead": "56dc8584b9118ee2f3bfb0b2e9d456b609ccbac8"
 }

package/source/address_space_ts.ts

@@ -185,7 +185,6 @@ export declare class VariableHistorian implements IVariableHistorian {
 
 export type UAClonable = UAObject | UAVariable | UAMethod;
 
-export interface Enumeration extends UAVariable {}
 export declare function createExtObjArrayNode<T extends ExtensionObject>(
     parentFolder: UAObject,
     options: any

package/source/helpers/argument_list.ts

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

package/source/loader/load_nodeset2.ts

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

package/source/session_context.ts

@@ -3,7 +3,7 @@
  */
 
 import { assert } from "node-opcua-assert";
-import { CertificateInternals, exploreCertificate } from "node-opcua-crypto/dist/source/crypto_explore_certificate";
+import { CertificateInternals, exploreCertificate } from "node-opcua-crypto";
 import { AccessRestrictionsFlag, allPermissions, AttributeIds, PermissionFlag } from "node-opcua-data-model";
 import { PreciseClock } from "node-opcua-date-time";
 import { NodeId, NodeIdLike, resolveNodeId, sameNodeId } from "node-opcua-nodeid";

package/source/set_namespace_meta_data.ts

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

package/source_nodejs/index.ts

@@ -1 +1 @@
-export * from "./generate_address_space";
+export * from "./generate_address_space";

package/src/address_space.ts

@@ -10,7 +10,7 @@ import { ExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object
 import { DataTypeIds, VariableTypeIds } from "node-opcua-constants";
 import { BrowseDirection, NodeClass, QualifiedName } from "node-opcua-data-model";
 import { ExtensionObject } from "node-opcua-extension-object";
-import { coerceExpandedNodeId, makeNodeId, NodeId, NodeIdLike, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import { coerceExpandedNodeId, coerceNodeId, makeNodeId, NodeId, NodeIdLike, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { ObjectRegistry } from "node-opcua-object-registry";
 import { BrowseResult } from "node-opcua-service-browse";
 import { StatusCodes } from "node-opcua-status-code";
@@ -47,12 +47,13 @@ import {
 
 import { adjustBrowseDirection } from "../source/helpers/adjust_browse_direction";
 import { UARootFolder } from "../source/ua_root_folder";
+import { Namespace } from "../source/namespace";
 
 import { AddressSpacePrivate } from "./address_space_private";
 import { UAAcknowledgeableConditionImpl, UAConditionImpl } from "./alarms_and_conditions";
 import { EventData } from "./event_data";
 import { AddressSpace_installHistoricalDataNode } from "./historical_access/address_space_historical_data_node";
-import { UANamespace } from "./namespace_impl";
+import { NamespaceImpl } from "./namespace_impl";
 import { isNonEmptyQualifiedName } from "./namespace_impl";
 import { NamespacePrivate } from "./namespace_private";
 import { ExtensionObjectConstructorFuncWithSchema, UADataTypeImpl } from "./ua_data_type_impl";
@@ -68,7 +69,8 @@ const doDebug = false;
 const Dequeue = require("dequeue");
 
 const regexNumberColumnString = /^([0-9]+):(.*)/;
-
+const enumerationTypeNodeId = coerceNodeId(DataTypeIds.Enumeration);
+ 
 function _extract_namespace_and_browse_name_as_string(
     addressSpace: AddressSpace,
     browseName: NodeIdLike | QualifiedName,
@@ -153,7 +155,7 @@ export class AddressSpace implements AddressSpacePrivate {
 
     public readonly isNodeIdString = isNodeIdString;
     private readonly _private_namespaceIndex: number;
-    private readonly _namespaceArray: UANamespace[];
+    private readonly _namespaceArray: NamespacePrivate[];
     private _shutdownTask: ShutdownTask[] = [];
     private _modelChangeTransactionCounter = 0;
     private _modelChanges: ModelChangeStructureDataType[] = [];
@@ -186,7 +188,7 @@ export class AddressSpace implements AddressSpacePrivate {
      * @param {string|number} namespace index or namespace uri.
      * @return {NameSpace} the namespace
      */
-    public getNamespace(namespaceIndexOrName: string | number): UANamespace {
+    public getNamespace(namespaceIndexOrName: string | number): NamespacePrivate {
         if (typeof namespaceIndexOrName === "number") {
             const namespaceIndex = namespaceIndexOrName;
             assert(namespaceIndex >= 0 && namespaceIndex < this._namespaceArray.length, "invalid namespace index ( out of bound)");
@@ -241,7 +243,7 @@ export class AddressSpace implements AddressSpacePrivate {
      * @param namespaceUri {string}
      * @returns {Namespace}
      */
-    public registerNamespace(namespaceUri: string): UANamespace {
+    public registerNamespace(namespaceUri: string): NamespacePrivate {
         let index = this._namespaceArray.findIndex((ns) => ns.namespaceUri === namespaceUri);
         if (index !== -1) {
             assert((this._namespaceArray[index].addressSpace as any) === (this as any));
@@ -249,7 +251,7 @@ export class AddressSpace implements AddressSpacePrivate {
         }
         index = this._namespaceArray.length;
         this._namespaceArray.push(
-            new UANamespace({
+            new NamespaceImpl({
                 addressSpace: this,
                 index,
                 namespaceUri,
@@ -471,10 +473,8 @@ export class AddressSpace implements AddressSpacePrivate {
                     dataTypeNode.constructor.name
             );
         }
-        dataTypeNode = dataTypeNode as UADataType;
-
-        const enumerationType = this.findDataType("Enumeration")!;
-        if (sameNodeId(enumerationType.nodeId, dataTypeNode!.nodeId)) {
+        
+        if (sameNodeId(enumerationTypeNodeId, dataTypeNode!.nodeId)) {
             return DataType.Int32;
         }
 
@@ -482,11 +482,18 @@ export class AddressSpace implements AddressSpacePrivate {
             // Number
             return DataType.Null; //which one ?
         }
-
-        if (dataTypeNode.nodeId.namespace === 0 && DataType[dataTypeNode.nodeId.value as number]) {
+ 
+        if (dataTypeNode.nodeId.namespace === 0 && dataTypeNode.nodeId.value === 0) {
+            return DataType.Null;
+        }
+ 
+        if (dataTypeNode.nodeId.namespace === 0 && dataTypeNode.nodeId.value <= 25) {
             return dataTypeNode.nodeId.value as DataType;
         }
-        return this.findCorrespondingBasicDataType(dataTypeNode.subtypeOfObj as UADataType);
+ 
+        const result =  this.findCorrespondingBasicDataType(dataTypeNode.subtypeOfObj as UADataType);
+ 
+        return result;
     }
 
     /**

package/src/address_space_private.ts

@@ -27,7 +27,7 @@ import { UARootFolder } from "../source/ua_root_folder";
 
 import { NamespacePrivate } from "./namespace_private";
 import { ExtensionObjectConstructorFuncWithSchema } from "./ua_data_type_impl";
-import { UANamespace } from "./namespace_impl";
+import { NamespaceImpl } from "./namespace_impl";
 
 export interface AddressSpacePrivate extends IAddressSpace {
     rootFolder: UARootFolder;
@@ -52,9 +52,9 @@ export interface AddressSpacePrivate extends IAddressSpace {
 
     getOwnNamespace(): NamespacePrivate;
 
-    getNamespace(indexOrName: number | string): UANamespace;
+    getNamespace(indexOrName: number | string): NamespacePrivate;
 
-    registerNamespace(namespaceUri: string): UANamespace;
+    registerNamespace(namespaceUri: string): NamespacePrivate;
 
     getNamespaceArray(): NamespacePrivate[];
 

package/src/alarms_and_conditions/condition_snapshot.ts

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