node-opcua-address-space 2.73.0 → 2.75.0

package/src/alarms_and_conditions/ua_limit_alarm_impl.ts

@@ -14,9 +14,7 @@ import { UAShelvedStateMachineEx } from "../../source";
 import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
 import { UALimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_limit_alarm_ex";
 import { NamespacePrivate } from "../namespace_private";
-import {
-    UAAlarmConditionImpl
-} from "./ua_alarm_condition_impl";
+import { UAAlarmConditionImpl } from "./ua_alarm_condition_impl";
 
 const warningLog = make_warningLog("AlarmsAndConditions");
 
@@ -35,11 +33,11 @@ const uaLimitAlarmInputSupportedDataType: DataType[] = [
     DataType.UInt32
 ];
 
-export interface UALimitAlarmImpl extends UALimitAlarmEx  {
+export interface UALimitAlarmImpl extends UALimitAlarmEx {
     shelvingState?: UAShelvedStateMachineEx;
 }
 export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAlarmEx {
-   /**
+    /**
      * @method (static)UALimitAlarm.instantiate
      * @param namespace {INamespace}
      * @param limitAlarmTypeId
@@ -127,8 +125,8 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
             throw new Error(message);
         }
 
-        if (Object.prototype.hasOwnProperty.call(options, "highHighLimit")) {
-            alarmNode.setHighHighLimit(options.highHighLimit);
+        if (Object.prototype.hasOwnProperty.call(options, "highHighLimit") && options.highHighLimit !== undefined) {
+            alarmNode.setHighHighLimit(options.highHighLimit!);
         }
         if (Object.prototype.hasOwnProperty.call(options, "highLimit")) {
             alarmNode.setHighLimit(options.highLimit);
@@ -136,7 +134,7 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
         if (Object.prototype.hasOwnProperty.call(options, "lowLimit")) {
             alarmNode.setLowLimit(options.lowLimit);
         }
-        if (Object.prototype.hasOwnProperty.call(options, "lowLowLimit")) {
+        if (Object.prototype.hasOwnProperty.call(options, "lowLowLimit") && options.lowLowLimit != undefined) {
             alarmNode.setLowLowLimit(options.lowLowLimit);
         }
 

package/src/alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl.ts

@@ -6,8 +6,8 @@ import { assert } from "node-opcua-assert";
 
 import { DataValue } from "node-opcua-data-value";
 import { NodeId } from "node-opcua-nodeid";
-import { VariantOptions } from "node-opcua-variant";
-import { UAVariable } from "node-opcua-address-space-base";
+import { DataType, VariantOptions } from "node-opcua-variant";
+import { UAVariable, UAVariableT } from "node-opcua-address-space-base";
 import { NamespacePrivate } from "../namespace_private";
 import { AddressSpace } from "../address_space";
 import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
@@ -20,6 +20,8 @@ import {
 } from "./deviation_alarm_helper";
 import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
 import { UANonExclusiveLimitAlarmImpl } from "./ua_non_exclusive_limit_alarm_impl";
+
+
 export declare interface UANonExclusiveDeviationAlarmImpl extends UANonExclusiveLimitAlarmImpl, UANonExclusiveDeviationAlarmEx {
     on(eventName: string, eventHandler: any): this;
     get addressSpace(): AddressSpace;
@@ -63,7 +65,7 @@ export class UANonExclusiveDeviationAlarmImpl extends UANonExclusiveLimitAlarmIm
         super._setStateBasedOnInputValue(value - setpointValue);
     }
 
-    public getSetpointNodeNode(): UAVariable {
+    public getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined  {
         return DeviationAlarmHelper_getSetpointNodeNode.call(this);
     }
 

package/src/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -12,7 +12,7 @@ import { DataType, VariantOptions } from "node-opcua-variant";
 import { InstantiateOffNormalAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
 import { UADiscreteAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
 import { AddressSpacePrivate } from "../address_space_private";
-import {  UADiscreteAlarmImpl } from "./ua_discrete_alarm_impl";
+import { UADiscreteAlarmImpl } from "./ua_discrete_alarm_impl";
 
 function isEqual(value1: any, value2: any) {
     return value1 === value2;
@@ -39,7 +39,6 @@ export declare interface UAOffNormalAlarmEx
     setNormalStateValue(value: any): void;
 }
 
-
 export declare interface UAOffNormalAlarmImpl extends UAOffNormalAlarmEx, UADiscreteAlarmImpl {
     on(eventName: string, eventHandler: any): this;
 }
@@ -103,21 +102,24 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
          * If this Variable is not in the AddressSpace, a NULL NodeId shall be provided.
          *
          */
-        const normalState = addressSpace._coerceNode(options.normalState) as UAVariable | null;
-        const normalStateNodeId = normalState ? normalState.nodeId : new NodeId();
-        alarmNode.normalState.setValueFromSource({ dataType: DataType.NodeId, value: normalStateNodeId });
-        alarmNode.normalState.on("value_changed", (newDataValue: DataValue /*, oldDataValue: DataValue*/) => {
-            // The node that contains the normalState value has changed.
-            //   we must remove the listener on current normalState and replace
-            //   normalState with the new one and set listener again
-            //   to do:
-        });
-
-        if (normalState) {
-            // install normalState monitoring for change
-            normalState.on("value_changed", (newDataValue: DataValue /*, oldDataValue: DataValue*/) => {
-                alarmNode._onNormalStateDataValueChange(newDataValue);
+        if (options.normalState) {
+            const normalState = addressSpace._coerceNode(options.normalState) as UAVariable | null;
+            const normalStateNodeId = normalState ? normalState.nodeId : new NodeId();
+            alarmNode.normalState.setValueFromSource({ dataType: DataType.NodeId, value: normalStateNodeId });
+            alarmNode.normalState.on("value_changed", (newDataValue: DataValue /*, oldDataValue: DataValue*/) => {
+                // The node that contains the normalState value has changed.
+                //   we must remove the listener on current normalState and replace
+                //   normalState with the new one and set listener again
+                //   to do:
             });
+            if (normalState) {
+                // install normalState monitoring for change
+                normalState.on("value_changed", (newDataValue: DataValue /*, oldDataValue: DataValue*/) => {
+                    alarmNode._onNormalStateDataValueChange(newDataValue);
+                });
+            }
+        } else {
+            alarmNode.normalState.setValueFromSource({ dataType: DataType.NodeId, value: NodeId.nullNodeId });
         }
 
         alarmNode._mayBe_updateAlarmState();

package/src/event_data.ts

@@ -2,16 +2,16 @@
  * @module node-opcua-address-space.Private
  */
 import { assert } from "node-opcua-assert";
-import { AttributeIds, NodeClass } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
-import { NodeId } from "node-opcua-nodeid";
-import { constructBrowsePathFromQualifiedName } from "node-opcua-service-translate-browse-path";
+import { coerceExpandedNodeId, NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import { SimpleAttributeOperand } from "node-opcua-types";
-import { DataType, Variant, VariantLike } from "node-opcua-variant";
+import { BrowsePath, BrowsePathResult } from "node-opcua-types";
+import { Variant, VariantLike } from "node-opcua-variant";
 
-import { ISessionContext, BaseNode, IEventData, UAVariable } from "node-opcua-address-space-base";
+import { BaseNode, IEventData } from "node-opcua-address-space-base";
+import { lowerFirstLetter } from "node-opcua-utils";
 
+type NodeIdString = string;
+type FullBrowsePath = string;
 /**
  * @class EventData
  * @param eventTypeNode {BaseNode}
@@ -21,91 +21,61 @@ export class EventData implements IEventData {
     public eventId: NodeId;
     public $eventDataSource: BaseNode;
 
-    private __nodes: { [key: string]: Variant };
+    public $cache: {
+        __values: { [key: NodeIdString]: Variant };
+        __nodeIdToNode: { [key: NodeIdString]: BaseNode };
+        __pathToNodeId: { [key: FullBrowsePath]: NodeId };
+        __nodeIdToFullPath: { [key: NodeIdString]: FullBrowsePath };
+    };
 
     constructor(eventTypeNode: BaseNode) {
-        this.__nodes = {};
+        this.$cache = {
+            __values: {},
+            __nodeIdToNode: {},
+            __pathToNodeId: {},
+            __nodeIdToFullPath: {}
+        };
+
         this.eventId = new NodeId();
         this.$eventDataSource = eventTypeNode;
     }
 
-    /**
-     * @method resolveSelectClause
-     * @param selectClause {SimpleAttributeOperand}
-     * @return {NodeId|null}
-     */
-    public resolveSelectClause(selectClause: SimpleAttributeOperand): NodeId | null {
-        assert(selectClause instanceof SimpleAttributeOperand);
-        const addressSpace = this.$eventDataSource.addressSpace;
-
-        if (selectClause.browsePath!.length === 0 && selectClause.attributeId === AttributeIds.NodeId) {
-            assert(!"Cannot use resolveSelectClause on this selectClause as it has no browsePath");
-        }
-        // navigate to the innerNode specified by the browsePath [ QualifiedName]
-        const browsePath = constructBrowsePathFromQualifiedName(this.$eventDataSource, selectClause.browsePath);
+    public _createValue(fullBrowsePath: string, node: BaseNode, variant: VariantLike): void {
+        const eventData = this as any;
+        assert(!eventData[fullBrowsePath], "already exists " + fullBrowsePath);
 
-        // xx console.log(self.$eventDataSource.browseName.toString());
-        // xx console.log("xx browse Path", browsePath.toString());
+        const lowerName = fullBrowsePath.split(".").map(lowerFirstLetter).join(".");
 
-        const browsePathResult = addressSpace.browsePath(browsePath);
+        eventData[lowerName] = Variant.coerce(variant);
 
-        // xx console.log(" br",
-        //    self.$eventDataSource.nodeId.toString(),
-        //    selectClause.browsePath.toString(),
-        //    browsePathResult.targets[0] ? browsePathResult.targets[0].targetId.toString() : "!!!NOT FOUND!!!"é)
+        this.$cache.__pathToNodeId[fullBrowsePath] = node.nodeId;
+        this.$cache.__nodeIdToNode[node.nodeId.toString()] = node;
+        this.$cache.__nodeIdToFullPath[node.nodeId.toString()] = fullBrowsePath;
+        this.$cache.__values[node.nodeId.toString()] = eventData[lowerName];
+    }
 
-        if (browsePathResult.statusCode !== StatusCodes.Good) {
-            return null;
-        }
-        if (!browsePathResult.targets) {
+    public _browse(browsePath: BrowsePath): BrowsePathResult | null {
+        if (!sameNodeId(browsePath.startingNode, this.$eventDataSource.nodeId)) {
             return null;
         }
-        // istanbul ignore next
-        if (browsePathResult.targets.length !== 1) {
-            // xx console.log("selectClause ",selectClause.toString());
-            // xx console.log("browsePathResult ",browsePathResult.toString());
-            // xx throw new Error("browsePathResult.targets.length !== 1"  + browsePathResult.targets.length);
-        }
-        return browsePathResult.targets[0].targetId;
+        const fullBrowsePath = (browsePath.relativePath.elements || []).map((b=>b.targetName.toString())).join(".");
+        const nodeId = this.$cache.__pathToNodeId[fullBrowsePath];
+        if (!nodeId) return null;
+        return new BrowsePathResult({
+            statusCode: StatusCodes.Good,
+            targets: [{
+                remainingPathIndex: 0,
+                targetId: coerceExpandedNodeId(nodeId),
+            }]
+        })
     }
 
-    public setValue(lowerName: string, node: BaseNode, variant: VariantLike): void {
-        const eventData = this as any;
-        eventData[lowerName] = Variant.coerce(variant); /// _coerceVariant(variant);
-        eventData.__nodes[node.nodeId.toString()] = eventData[lowerName];
-    }
-    /**
-     * @method readValue
-     * @param nodeId {NodeId}
-     * @param selectClause {SimpleAttributeOperand}
-     * @return {Variant}
-     */
-    public readValue(sessionContext: ISessionContext, nodeId: NodeId, selectClause: SimpleAttributeOperand): Variant {
-        assert(nodeId instanceof NodeId);
-        assert(selectClause instanceof SimpleAttributeOperand);
-        assert(nodeId instanceof NodeId);
-        const addressSpace = this.$eventDataSource.addressSpace;
-
-        const node = addressSpace.findNode(nodeId)!;
-        const key = node.nodeId.toString();
-
-        // if the value exists in cache ... we read it from cache...
-        const cached_value = this.__nodes[key];
+    public _readValue(nodeId: NodeId): Variant | null {
+        const key = nodeId.toString();
+        const cached_value = this.$cache.__values[key];
         if (cached_value) {
             return cached_value;
         }
-
-        if (node.nodeClass === NodeClass.Variable && selectClause.attributeId === AttributeIds.Value) {
-            const nodeVariable = node as UAVariable;
-            return prepare(nodeVariable.readValue(sessionContext, selectClause.indexRange));
-        }
-        return prepare(node.readAttribute(sessionContext, selectClause.attributeId));
-    }
-}
-
-function prepare(dataValue: DataValue): Variant {
-    if (dataValue.statusCode === StatusCodes.Good) {
-        return dataValue.value;
+        return null;
     }
-    return new Variant({ dataType: DataType.StatusCode, value: dataValue.statusCode });
-}
+}

package/src/index_current.ts

@@ -7,7 +7,6 @@ export * from "../source/helpers/dump_tools";
 export * from "../source/helpers/adjust_browse_direction";
 export * from "../source/pseudo_session";
 export * from "../source/helpers/make_optionals_map";
-export * from "../source/helpers/check_event_clause";
 export * from "../source/helpers/argument_list";
 export * from "../source/helpers/call_helpers";
 export * from "../source/helpers/ensure_secure_access";

package/src/namespace_impl.ts

@@ -28,7 +28,7 @@ import {
     RolePermissionTypeOptions
 } from "node-opcua-types";
 import * as utils from "node-opcua-utils";
-import { DataType, Variant, VariantArrayType, verifyRankAndDimensions } from "node-opcua-variant";
+import { DataType, Variant, VariantArrayType, VariantOptions, verifyRankAndDimensions } from "node-opcua-variant";
 import {
     AddBaseNodeOptions,
     AddEnumerationTypeOptions,
@@ -67,7 +67,14 @@ import {
 } from "../source/address_space_ts";
 import { UAStateMachineEx } from "../source/interfaces/state_machine/ua_state_machine_type";
 import { UATransitionEx } from "../source/interfaces/state_machine/ua_transition_ex";
-import { UATwoStateDiscreteEx, UAYArrayItemEx } from "../source";
+import {
+    InstantiateAlarmConditionOptions,
+    InstantiateExclusiveLimitAlarmOptions,
+    InstantiateLimitAlarmOptions,
+    InstantiateOffNormalAlarmOptions,
+    UATwoStateDiscreteEx,
+    UAYArrayItemEx
+} from "../source";
 import { AddAnalogDataItemOptions, AddDataItemOptions } from "../source/namespace_data_access";
 import { UATwoStateVariableEx } from "../source/ua_two_state_variable_ex";
 import { UAMultiStateValueDiscreteEx } from "../source/interfaces/data_access/ua_multistate_value_discrete_ex";
@@ -79,22 +86,19 @@ import { UALimitAlarmEx } from "../source/interfaces/alarms_and_conditions/ua_li
 import { UANonExclusiveDeviationAlarmEx } from "../source/interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
 import { UANonExclusiveLimitAlarmEx } from "../source/interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex";
 import { UAConditionEx } from "../source/interfaces/alarms_and_conditions/ua_condition_ex";
+import { InstantiateExclusiveDeviationAlarmOptions } from "../source/interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options";
+import { InstantiateNonExclusiveLimitAlarmOptions } from "../source/interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options";
+import { InstantiateNonExclusiveDeviationAlarmOptions } from "../source/interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options";
 
 import { _handle_delete_node_model_change_event, _handle_model_change_event } from "./address_space_change_event_tools";
 import { AddressSpacePrivate } from "./address_space_private";
 import { UAConditionImpl } from "./alarms_and_conditions/ua_condition_impl";
 import { UADiscreteAlarmImpl } from "./alarms_and_conditions/ua_discrete_alarm_impl";
-import {
-    UAExclusiveDeviationAlarmImpl
-} from "./alarms_and_conditions/ua_exclusive_deviation_alarm_impl";
-import {  UAExclusiveLimitAlarmImpl } from "./alarms_and_conditions/ua_exclusive_limit_alarm_impl";
-import {  UALimitAlarmImpl } from "./alarms_and_conditions/ua_limit_alarm_impl";
-import {
-    UANonExclusiveDeviationAlarmImpl
-} from "./alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl";
-import {
-    UANonExclusiveLimitAlarmImpl
-} from "./alarms_and_conditions/ua_non_exclusive_limit_alarm_impl";
+import { UAExclusiveDeviationAlarmImpl } from "./alarms_and_conditions/ua_exclusive_deviation_alarm_impl";
+import { UAExclusiveLimitAlarmImpl } from "./alarms_and_conditions/ua_exclusive_limit_alarm_impl";
+import { UALimitAlarmImpl } from "./alarms_and_conditions/ua_limit_alarm_impl";
+import { UANonExclusiveDeviationAlarmImpl } from "./alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl";
+import { UANonExclusiveLimitAlarmImpl } from "./alarms_and_conditions/ua_non_exclusive_limit_alarm_impl";
 import { UAAcknowledgeableConditionImpl, UAAlarmConditionImpl } from "./alarms_and_conditions";
 import { UAOffNormalAlarmEx, UAOffNormalAlarmImpl } from "./alarms_and_conditions/ua_off_normal_alarm_impl";
 import { add_dataItem_stuff } from "./data_access/add_dataItem_stuff";
@@ -1541,52 +1545,69 @@ export class NamespaceImpl implements NamespacePrivate {
 
     public instantiateAcknowledgeableCondition(
         conditionTypeId: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
     ): UAAcknowledgeableConditionImpl {
         return UAAcknowledgeableConditionImpl.instantiate(this, conditionTypeId, options, data);
     }
 
     public instantiateAlarmCondition(
         alarmConditionTypeId: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
     ): UAAlarmConditionEx {
         return UAAlarmConditionImpl.instantiate(this, alarmConditionTypeId, options, data);
     }
 
-    public instantiateLimitAlarm(limitAlarmTypeId: UAEventType | NodeId | string, options: any, data: any): UALimitAlarmEx {
+    public instantiateLimitAlarm(
+        limitAlarmTypeId: UAEventType | NodeId | string,
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UALimitAlarmEx {
         return UALimitAlarmImpl.instantiate(this, limitAlarmTypeId, options, data);
     }
 
     public instantiateExclusiveLimitAlarm(
         exclusiveLimitAlarmTypeId: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UAExclusiveLimitAlarmEx {
         return UAExclusiveLimitAlarmImpl.instantiate(this, exclusiveLimitAlarmTypeId, options, data);
     }
 
-    public instantiateExclusiveDeviationAlarm(options: any, data: any): UAExclusiveDeviationAlarmEx {
+    public instantiateExclusiveDeviationAlarm(
+        options: InstantiateExclusiveDeviationAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UAExclusiveDeviationAlarmEx {
         return UAExclusiveDeviationAlarmImpl.instantiate(this, "ExclusiveDeviationAlarmType", options, data);
     }
 
     public instantiateNonExclusiveLimitAlarm(
         nonExclusiveLimitAlarmTypeId: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateNonExclusiveLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UANonExclusiveLimitAlarmEx {
         return UANonExclusiveLimitAlarmImpl.instantiate(this, nonExclusiveLimitAlarmTypeId, options, data);
     }
 
-    public instantiateNonExclusiveDeviationAlarm(options: any, data: any): UANonExclusiveDeviationAlarmEx {
+    public instantiateNonExclusiveDeviationAlarm(
+        options: InstantiateNonExclusiveDeviationAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UANonExclusiveDeviationAlarmEx {
         return UANonExclusiveDeviationAlarmImpl.instantiate(this, "NonExclusiveDeviationAlarmType", options, data);
     }
 
-    public instantiateDiscreteAlarm(discreteAlarmType: UAEventType | NodeId | string, options: any, data: any): UADiscreteAlarmEx {
+    public instantiateDiscreteAlarm(
+        discreteAlarmType: UAEventType | NodeId | string,
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
+    ): UADiscreteAlarmEx {
         return UADiscreteAlarmImpl.instantiate(this, discreteAlarmType, options, data);
     }
-    public instantiateOffNormalAlarm(options: any, data: any): UAOffNormalAlarmEx {
+    public instantiateOffNormalAlarm(
+        options: InstantiateOffNormalAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UAOffNormalAlarmEx {
         return UAOffNormalAlarmImpl.instantiate(this, "OffNormalAlarmType", options, data);
     }
 

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -294,8 +294,8 @@ function _dumpVariantInnerValueEnum(xw: XmlWriter, definition: EnumDefinition, v
     if (!definition.fields) {
         return;
     }
-    const field = definition.fields.find((f) => f.value[1] === value);
-    xw.text(`${field?.name}_${value}`);
+    const field = definition.fields.find((f) => f.value[1] === value || f.name === value);
+    xw.text(`${field?.name}_${field?.value[1]}`);
 }
 
 // eslint-disable-next-line complexity
@@ -329,7 +329,6 @@ function _dumpVariantInnerValue(
         case DataType.Boolean:
         case DataType.SByte:
         case DataType.Byte:
-        case DataType.SByte:
         case DataType.Float:
         case DataType.Double:
         case DataType.Int16:
@@ -779,6 +778,16 @@ function _dumpStructureDefinition(
         xw.endElement();
     }
 }
+
+function _dumpEncodings(xw: XmlWriter, uaDataType: UADataType) {
+    const encodings = uaDataType.findReferencesExAsObject("HasEncoding", BrowseDirection.Forward);
+    for (const encoding of encodings) {
+        if (encoding.nodeClass !== NodeClass.Object) {
+            continue;
+        }
+        _dumpUAObject(xw, encoding as UAObject);
+    }
+}
 function _dumpUADataTypeDefinition(xw: XmlWriter, uaDataType: UADataType) {
     const uaDataTypeBase = uaDataType.subtypeOfObj;
 
@@ -824,6 +833,8 @@ function dumpUADataType(xw: XmlWriter, node: UADataType) {
 
     xw.endElement();
 
+    _dumpEncodings(xw, node);
+
     dumpAggregates(xw, node);
 }
 
@@ -927,7 +938,10 @@ function dumpUAVariableType(xw: XmlWriter, node: UAVariableType) {
 
 function dumpUAObject(xw: XmlWriter, node: UAObject) {
     xw.writeComment("Object - " + b(xw, node.browseName) + " {{{{ ");
-
+    _dumpUAObject(xw, node);
+    xw.writeComment("Object - " + b(xw, node.browseName) + " }}}} ");
+}
+function _dumpUAObject(xw: XmlWriter, node: UAObject) {
     xw.visitedNode = xw.visitedNode || {};
     assert(!xw.visitedNode[_hash(node)]);
     xw.visitedNode[_hash(node)] = 1;
@@ -945,8 +959,6 @@ function dumpUAObject(xw: XmlWriter, node: UAObject) {
     dumpAggregates(xw, node);
 
     dumpElementInFolder(xw, node as UAObjectImpl);
-
-    xw.writeComment("Object - " + b(xw, node.browseName) + " }}}} ");
 }
 function dumpElementInFolder(xw: XmlWriter, node: BaseNodeImpl) {
     const aggregates = node

package/src/state_machine/ua_two_state_variable.ts

@@ -297,7 +297,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
         // for which state or sub-state should be used. It is up to the Server and will depend on the
         // semantics of the StateMachineType
         //
-        // EffectiveDisplayName will be constructed by adding the EnableState
+        // EffectiveDisplayName will be constructed by adding the EnabledState
         // and the State of the addTrue state
         if (this.effectiveDisplayName) {
             this.id.on("value_changed", () => {

package/src/ua_object_impl.ts

@@ -156,8 +156,7 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         // coerce EventType
         eventTypeNode = addressSpace.findEventType(eventType as UAEventType) as UAEventType;
         const baseEventType = addressSpace.findEventType("BaseEventType")!;
-        assert(eventTypeNode.isSupertypeOf(baseEventType));
-
+   
         data.$eventDataSource = eventTypeNode;
         data.sourceNode = data.sourceNode || { dataType: DataType.NodeId, value: this.nodeId };
 

package/src/ua_variable_impl.ts

@@ -16,12 +16,8 @@ import {
     defaultCloneFilter,
     GetFunc,
     SetFunc,
-    VariableDataValueGetterCallback,
-    VariableDataValueGetterPromise,
     VariableDataValueGetterSync,
-    VariableDataValueSetterWithCallback,
-    VariableDataValueSetterWithPromise
-} from "node-opcua-address-space-base";
+    VariableDataValueSetterWithCallback} from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import {
     isValidDataEncoding,
@@ -49,12 +45,9 @@ import {
     ReadEventDetails,
     ReadProcessedDetails,
     ReadRawModifiedDetails,
-    StructureDefinition,
-    StructureField,
     WriteValueOptions
 } from "node-opcua-types";
 import * as utils from "node-opcua-utils";
-import { lowerFirstLetter } from "node-opcua-utils";
 import {
     Variant,
     VariantLike,
@@ -68,7 +61,6 @@ import { StatusCodeCallback } from "node-opcua-status-code";
 import {
     IAddressSpace,
     BindVariableOptions,
-    ContinuationPoint,
     IVariableHistorian,
     TimestampGetFunc,
     TimestampSetFunc,
@@ -81,12 +73,12 @@ import {
     BaseNode,
     UAVariableT
 } from "node-opcua-address-space-base";
-import { EnumFilterOperator, UAHistoricalDataConfiguration } from "node-opcua-nodeset-ua";
+import { UAHistoricalDataConfiguration } from "node-opcua-nodeset-ua";
 
 import { SessionContext } from "../source/session_context";
 import { convertToCallbackFunction1 } from "../source/helpers/multiform_func";
 import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
-import { _clone, ToStringBuilder, UAVariable_toString, valueRankToString } from "./base_node_private";
+import { _clone, ToStringBuilder, UAVariable_toString } from "./base_node_private";
 import { EnumerationInfo, IEnumItem, UADataTypeImpl } from "./ua_data_type_impl";
 import { apply_condition_refresh, ConditionRefreshCache } from "./apply_condition_refresh";
 import {

package/test_helpers/alarms_and_conditions_demo.ts

@@ -69,7 +69,10 @@ export function construct_demo_alarm_in_address_space(test: IAlarmTestData, addr
         optionals: [
             "ConfirmedState",
             "Confirm" // confirm state and confirm Method
-        ]
+        ],
+
+        setpointNode: null,
+
     }) as UAExclusiveLimitAlarmEx;
 
     assert(tankLevelCondition.browseName.toString() === "1:TankLevelCondition");

package/test_helpers/test_fixtures/variabletype_with_value.xml

@@ -37,7 +37,7 @@
         <Alias Alias="GasComposition">ns=1;i=48</Alias>
         <Alias Alias="FlowDirection">ns=1;i=49</Alias>
         <Alias Alias="MyEnum">ns=1;i=3002</Alias>
-        <Alias Alias="MyStruct">ns=1;i=3003</Alias>
+        <Alias Alias="MyStructDataType">ns=1;i=3003</Alias>
     </Aliases>
     <Extensions>
     </Extensions>
@@ -272,32 +272,32 @@
         </References>
     </UAObject>
     
-    <UADataType NodeId="ns=1;i=3003" BrowseName="1:MyStruct">
-        <DisplayName>MyStruct</DisplayName>
+    <UADataType NodeId="ns=1;i=3003" BrowseName="1:MyStructDataType">
+        <DisplayName>MyStructDataType</DisplayName>
         <References>
             <Reference ReferenceType="HasEncoding">ns=1;i=5001</Reference>
             <Reference ReferenceType="HasEncoding">ns=1;i=5003</Reference>
             <Reference ReferenceType="HasEncoding">ns=1;i=5002</Reference>
             <Reference ReferenceType="HasSubtype" IsForward="false">i=22</Reference>
         </References>
-        <Definition Name="1:MyStruct">
+        <Definition Name="1:MyStructDataType">
             <Field DataType="MyEnum" Name="F1"/>
             <Field DataType="MyEnum" ValueRank="1" ArrayDimensions="0" Name="F2"/>
         </Definition>
     </UADataType>
-    <UAVariable DataType="String" ParentNodeId="ns=1;i=6002" NodeId="ns=1;i=6006" BrowseName="1:MyStruct">
-        <DisplayName>MyStruct</DisplayName>
+    <UAVariable DataType="String" ParentNodeId="ns=1;i=6002" NodeId="ns=1;i=6006" BrowseName="1:MyStructType">
+        <DisplayName>MyStructType</DisplayName>
         <References>
             <Reference ReferenceType="HasComponent" IsForward="false">ns=1;i=6002</Reference>
             <Reference ReferenceType="HasTypeDefinition">i=69</Reference>
             <Reference ReferenceType="HasDescription" IsForward="false">ns=1;i=5001</Reference>
         </References>
         <Value>
-            <uax:String>MyStruct</uax:String>
+            <uax:String>MyStructDataType</uax:String>
         </Value>
     </UAVariable>
 
-    <UAVariable DataType="MyStruct" NodeId="ns=1;i=6009" BrowseName="1:TestVar" AccessLevel="3">
+    <UAVariable DataType="MyStructDataType" NodeId="ns=1;i=6009" BrowseName="1:TestVar" AccessLevel="3">
         <DisplayName>TestVar</DisplayName>
         <References>
             <Reference ReferenceType="HasTypeDefinition">i=63</Reference>
@@ -309,14 +309,14 @@
                     <uax:Identifier>ns=1;i=5002</uax:Identifier>
                 </uax:TypeId>
                 <uax:Body>
-                    <MyStruct xmlns="http://yourorganisation.org/enumInExtObj/Types.xsd">
+                    <MyStructDataType xmlns="http://yourorganisation.org/enumInExtObj/Types.xsd">
                         <F1>Orange_200</F1>
                         <F2>
                             <MyEnum>Green_100</MyEnum>
                             <MyEnum>Orange_200</MyEnum>
                             <MyEnum>Red_300</MyEnum>
                         </F2>
-                    </MyStruct>
+                    </MyStructDataType>
                 </uax:Body>
             </uax:ExtensionObject>
         </Value>