node-opcua-address-space 2.70.3 → 2.72.1

package/src/alarms_and_conditions/ua_condition_impl.ts

@@ -23,17 +23,25 @@ import { minDate } from "node-opcua-factory";
 import { coerceNodeId, makeNodeId, NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
 import { CallMethodResultOptions, TimeZoneDataType } from "node-opcua-types";
-import { DataType, Variant, VariantLike } from "node-opcua-variant";
-import { UAVariable, INamespace, ISessionContext, UAEventType, BaseNode, UAObject } from "node-opcua-address-space-base";
+import { DataType, Variant, VariantLike, VariantOptions } from "node-opcua-variant";
+import {
+    UAVariable,
+    INamespace,
+    ISessionContext,
+    UAEventType,
+    BaseNode,
+    UAObject,
+    InstantiateObjectOptions
+} from "node-opcua-address-space-base";
 import { UACondition_Base, UAConditionVariable, UACondition } from "node-opcua-nodeset-ua";
 
 import { ConditionInfoOptions } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
+import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
 import { AddressSpacePrivate } from "../address_space_private";
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
 import { UAObjectImpl } from "../ua_object_impl";
 import { UAVariableImpl } from "../ua_variable_impl";
 import { UAConditionType } from "../ua_condition_type";
-import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
 import { UABaseEventHelper, UABaseEventImpl } from "./ua_base_event_impl";
 import { ConditionSnapshot } from "./condition_snapshot";
 
@@ -680,6 +688,11 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
     }
 }
 
+export interface InstantiateConditionOptions extends InstantiateObjectOptions {
+    conditionOf?: UAObject | BaseNode | NodeId | null;
+    conditionClass?: UAObject | BaseNode | NodeId | null;
+    conditionName?: string;
+}
 /**
  * instantiate a Condition.
  * this will create the unique EventId and will set eventType
@@ -709,8 +722,8 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
 function UACondition_instantiate(
     namespace: INamespace,
     conditionTypeId: UAEventType | NodeId | string,
-    options: any,
-    data: any
+    options: InstantiateConditionOptions,
+    data?: Record<string, VariantOptions>
 ): UAConditionEx {
     /* eslint max-statements: ["error", 100] */
     const addressSpace = namespace.addressSpace as AddressSpacePrivate;
@@ -766,7 +779,7 @@ function UACondition_instantiate(
     }
     if (options.conditionOf) {
         assert(Object.prototype.hasOwnProperty.call(options, "conditionOf")); // must provide a conditionOf
-        options.conditionOf = addressSpace._coerceNode(options.conditionOf);
+        options.conditionOf = addressSpace._coerceNode(options.conditionOf)!;
 
         // HasCondition References can be used in the Type definition of an Object or a Variable.
         assert(options.conditionOf.nodeClass === NodeClass.Object || options.conditionOf.nodeClass === NodeClass.Variable);
@@ -826,11 +839,11 @@ function UACondition_instantiate(
     conditionNode.enabledState.setValue(true);
 
     // set properties to in initial values
-    Object.keys(data).forEach((key: string) => {
+    Object.entries(data).forEach(([key, value]) => {
         const varNode = _getCompositeKey(conditionNode, key);
         assert(varNode.nodeClass === NodeClass.Variable);
 
-        const variant = new Variant(data[key]);
+        const variant = new Variant(value);
 
         // check that Variant DataType is compatible with the UAVariable dataType
         // xx var nodeDataType = addressSpace.findNode(varNode.dataType).browseName;
@@ -839,10 +852,7 @@ function UACondition_instantiate(
         if (!varNode._validate_DataType(variant.dataType)) {
             throw new Error(" Invalid variant dataType " + variant + " " + varNode.browseName.toString());
         }
-
-        const value = new Variant(data[key]);
-
-        varNode.setValueFromSource(value);
+        varNode.setValueFromSource(variant);
     });
 
     // bind condition methods -
@@ -880,7 +890,7 @@ function UACondition_instantiate(
     //    with the motor.
 
     if (options.conditionSource) {
-        options.conditionSource = addressSpace._coerceNode(options.conditionSource);
+        options.conditionSource = addressSpace._coerceNode(options.conditionSource)!;
         if (options.conditionSource.nodeClass !== NodeClass.Object && options.conditionSource.nodeClass !== NodeClass.Variable) {
             // tslint:disable:no-console
             console.log(options.conditionSource);
@@ -960,6 +970,9 @@ function UACondition_instantiate(
     if (options.conditionClass) {
         if (typeof options.conditionClass === "string") {
             options.conditionClass = addressSpace.findObjectType(options.conditionClass);
+            if (!options.conditionClass) {
+                throw new Error("cannot find condition class " + options.conditionClass);
+            }
         }
         const conditionClassNode = addressSpace._coerceNode(options.conditionClass);
         if (!conditionClassNode) {

package/src/alarms_and_conditions/ua_discrete_alarm_impl.ts

@@ -4,8 +4,14 @@
 import { assert } from "node-opcua-assert";
 import { NodeId } from "node-opcua-nodeid";
 import { UADiscreteAlarm, UADiscreteAlarm_Base } from "node-opcua-nodeset-ua";
-import { INamespace, UAEventType } from "../../source";
-import { UAAlarmConditionEx, UAAlarmConditionHelper, UAAlarmConditionImpl } from "./ua_alarm_condition_impl";
+import { VariantOptions } from "node-opcua-variant";
+import { INamespace, UAEventType } from "node-opcua-address-space-base";
+import {
+    InstantiateAlarmConditionOptions,
+    UAAlarmConditionEx,
+    UAAlarmConditionHelper,
+    UAAlarmConditionImpl
+} from "./ua_alarm_condition_impl";
 
 export interface UADiscreteAlarmHelper extends UAAlarmConditionHelper {
     on(eventName: string, eventHandle: any): this;
@@ -59,8 +65,8 @@ export class UADiscreteAlarmImpl extends UAAlarmConditionImpl implements UADiscr
     public static instantiate(
         namespace: INamespace,
         discreteAlarmTypeId: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
     ): UADiscreteAlarmImpl {
         const addressSpace = namespace.addressSpace;
 

package/src/alarms_and_conditions/ua_exclusive_deviation_alarm_impl.ts

@@ -4,10 +4,9 @@
 import { assert } from "node-opcua-assert";
 import { DataValue } from "node-opcua-data-value";
 import { NodeId } from "node-opcua-nodeid";
-import { DataType } from "node-opcua-variant";
+import { DataType, VariantOptions } from "node-opcua-variant";
 import { UAExclusiveDeviationAlarm_Base } from "node-opcua-nodeset-ua";
-
-import { UAVariable, UAVariableT } from "../../source";
+import { UAVariable, UAVariableT } from "node-opcua-address-space-base";
 import { AddressSpace } from "../address_space";
 import { NamespacePrivate } from "../namespace_private";
 import {
@@ -20,7 +19,7 @@ import {
 } from "./deviation_alarm_helper";
 
 import { UAExclusiveLimitAlarmEx, UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
-import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+import { InstantiateLimitAlarmOptions, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
 
 export interface UAExclusiveDeviationAlarmEx
     extends Omit<
@@ -43,12 +42,14 @@ export declare interface UAExclusiveDeviationAlarmImpl extends UAExclusiveDeviat
     on(eventName: string, eventHandler: any): this;
     get addressSpace(): AddressSpace;
 }
+
+export interface InstantiateExclusiveLimitAlarmOptions extends InstantiateLimitAlarmOptions, InstallSetPointOptions {}
 export class UAExclusiveDeviationAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveDeviationAlarmEx {
     public static instantiate(
         namespace: NamespacePrivate,
         type: string | NodeId,
-        options: any,
-        data: any
+        options: InstantiateExclusiveLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UAExclusiveDeviationAlarmImpl {
         const addressSpace = namespace.addressSpace;
 

package/src/alarms_and_conditions/ua_exclusive_level_alarm_impl.ts

@@ -2,17 +2,19 @@
  * @module node-opcua-address-space.AlarmsAndConditions
  */
 import { NodeId } from "node-opcua-nodeid";
+import { VariantOptions } from "node-opcua-variant";
 import { NamespacePrivate } from "../namespace_private";
 import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
+import { InstantiateLimitAlarmOptions } from "./ua_limit_alarm_impl";
 
 export class UAExclusiveLevelAlarmImpl extends UAExclusiveLimitAlarmImpl {
     public static instantiate(
         namespace: NamespacePrivate,
         type: NodeId | string,
-        option: any,
-        data: any
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UAExclusiveLevelAlarmImpl {
         const addressSpace = namespace.addressSpace;
-        return UAExclusiveLimitAlarmImpl.instantiate(namespace, type, option, data) as UAExclusiveLevelAlarmImpl;
+        return UAExclusiveLimitAlarmImpl.instantiate(namespace, type, options, data) as UAExclusiveLevelAlarmImpl;
     }
 }

package/src/alarms_and_conditions/ua_exclusive_limit_alarm_impl.ts

@@ -4,14 +4,15 @@
 import { assert } from "node-opcua-assert";
 import { NodeId } from "node-opcua-nodeid";
 import { UAObject } from "node-opcua-address-space-base";
-import { UAExclusiveLimitAlarm, UAExclusiveLimitAlarm_Base } from "node-opcua-nodeset-ua";
-
-import { UAEventType, UAExclusiveLimitStateMachineEx } from "../../source";
+import { UAExclusiveLimitAlarm_Base } from "node-opcua-nodeset-ua";
+import { VariantOptions } from "node-opcua-variant";
+import { UAEventType } from "node-opcua-address-space-base";
 import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
 import { NamespacePrivate } from "../namespace_private";
 import { promoteToStateMachine } from "../state_machine/finite_state_machine";
 import { UAShelvedStateMachineEx } from "../state_machine/ua_shelving_state_machine_ex";
-import { UALimitAlarmEx, UALimitAlarmHelper, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+import { UAExclusiveLimitStateMachineEx } from "../../source/interfaces/state_machine/ua_exclusive_limit_state_machine_type_ex";
+import { InstantiateLimitAlarmOptions, UALimitAlarmEx, UALimitAlarmHelper, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
 
 const validState = ["HighHigh", "High", "Low", "LowLow", null];
 
@@ -49,8 +50,8 @@ export class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExc
     public static instantiate(
         namespace: NamespacePrivate,
         type: UAEventType | string | NodeId,
-        options: any,
-        data: any
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UAExclusiveLimitAlarmImpl {
         const addressSpace = namespace.addressSpace;
 

package/src/alarms_and_conditions/ua_exclusive_rate_of_change_alarm_impl.ts

@@ -1,7 +1,7 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { UAExclusiveRateOfChangeAlarm, UAExclusiveRateOfChangeAlarm_Base } from "node-opcua-nodeset-ua";
+import { UAExclusiveRateOfChangeAlarm_Base } from "node-opcua-nodeset-ua";
 import { UAExclusiveLimitAlarmEx, UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
 
 export interface UAExclusiveRateOfChangeAlarmEx

package/src/alarms_and_conditions/ua_limit_alarm_impl.ts

@@ -8,14 +8,18 @@ import { NodeClass } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
 import { make_warningLog } from "node-opcua-debug";
 import { NodeId } from "node-opcua-nodeid";
-import { UALimitAlarm_Base, UALimitAlarm } from "node-opcua-nodeset-ua";
+import { UALimitAlarm_Base } from "node-opcua-nodeset-ua";
 import { StatusCodes } from "node-opcua-status-code";
-import { DataType } from "node-opcua-variant";
+import { DataType, VariantOptions } from "node-opcua-variant";
 import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
-
 import { NamespacePrivate } from "../namespace_private";
 import { UAShelvedStateMachineEx } from "../state_machine/ua_shelving_state_machine_ex";
-import { UAAlarmConditionEx, UAAlarmConditionHelper, UAAlarmConditionImpl } from "./ua_alarm_condition_impl";
+import {
+    InstantiateAlarmConditionOptions,
+    UAAlarmConditionEx,
+    UAAlarmConditionHelper,
+    UAAlarmConditionImpl
+} from "./ua_alarm_condition_impl";
 
 const warningLog = make_warningLog("AlarmsAndConditions");
 export interface UALimitAlarmHelper extends UAAlarmConditionHelper {
@@ -57,6 +61,14 @@ const uaLimitAlarmInputSupportedDataType: DataType[] = [
     DataType.UInt32
 ];
 
+export interface InstantiateLimitAlarmOptions extends InstantiateAlarmConditionOptions {
+    highHighLimit: number;
+    highLimit: number;
+    lowLimit: number;
+    lowLowLimit: number;
+    inputNode: UAVariable;
+}
+
 export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAlarmEx {
     /**
      * @method (static)UALimitAlarm.instantiate
@@ -75,8 +87,8 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
     public static instantiate(
         namespace: NamespacePrivate,
         limitAlarmTypeId: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UALimitAlarmImpl {
         const addressSpace = namespace.addressSpace;
 
@@ -139,13 +151,11 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
         const dataType = addressSpace.findCorrespondingBasicDataType(options.inputNode.dataType);
 
         if (-1 === uaLimitAlarmInputSupportedDataType.indexOf(dataType)) {
-            const message =(
-                `UALimitAlarm.instantiate: inputNode must be of type ${uaLimitAlarmInputSupportedDataType
-                    .map((a) => DataType[a])
-                    .join("|")}, got ${DataType[dataType]}`
-            );
+            const message = `UALimitAlarm.instantiate: inputNode must be of type ${uaLimitAlarmInputSupportedDataType
+                .map((a) => DataType[a])
+                .join("|")}, got ${DataType[dataType]}`;
             warningLog(message);
-            throw(new Error(message));
+            throw new Error(message);
         }
 
         if (Object.prototype.hasOwnProperty.call(options, "highHighLimit")) {
@@ -265,7 +275,7 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
         this.lowLowLimit.setValueFromSource({ dataType: DataType.Double, value });
     }
 
-    public _onInputDataValueChange(dataValue: DataValue): void {
+    protected _onInputDataValueChange(dataValue: DataValue): void {
         assert(dataValue instanceof DataValue);
 
         if (

package/src/alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl.ts

@@ -6,10 +6,9 @@ import { assert } from "node-opcua-assert";
 
 import { DataValue } from "node-opcua-data-value";
 import { NodeId } from "node-opcua-nodeid";
-import { DataType } from "node-opcua-variant";
-import { UANonExclusiveDeviationAlarm_Base, UANonExclusiveLimitAlarm_Base } from "node-opcua-nodeset-ua";
-
-import { UAVariable, UAVariableT } from "../../source";
+import { DataType, VariantOptions } from "node-opcua-variant";
+import { UANonExclusiveDeviationAlarm_Base } from "node-opcua-nodeset-ua";
+import { UAVariable, UAVariableT } from "node-opcua-address-space-base";
 import { NamespacePrivate } from "../namespace_private";
 import { AddressSpace } from "../address_space";
 import {
@@ -19,7 +18,7 @@ import {
     DeviationAlarmHelper_onSetpointDataValueChange,
     DeviationStuff
 } from "./deviation_alarm_helper";
-import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+import { InstantiateLimitAlarmOptions, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
 import { UANonExclusiveLimitAlarmEx, UANonExclusiveLimitAlarmImpl } from "./ua_non_exclusive_limit_alarm_impl";
 
 export interface UANonExclusiveDeviationAlarmEx
@@ -56,8 +55,8 @@ export class UANonExclusiveDeviationAlarmImpl extends UANonExclusiveLimitAlarmIm
     public static instantiate(
         namespace: NamespacePrivate,
         type: string | NodeId,
-        options: any,
-        data: any
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UANonExclusiveDeviationAlarmImpl {
         const addressSpace = namespace.addressSpace;
 

package/src/alarms_and_conditions/ua_non_exclusive_limit_alarm_impl.ts

@@ -3,17 +3,16 @@
  * @module node-opcua-address-space.AlarmsAndConditions
  */
 import { assert } from "node-opcua-assert";
-import { LocalizedText } from "node-opcua-data-model";
 import { NodeId } from "node-opcua-nodeid";
-import { UANonExclusiveLimitAlarm_Base, UATwoStateVariable } from "node-opcua-nodeset-ua";
+import { UANonExclusiveLimitAlarm_Base } from "node-opcua-nodeset-ua";
 import { StatusCodes } from "node-opcua-status-code";
-
-import { UAEventType } from "../../source";
+import { VariantOptions } from "node-opcua-variant";
+import { UAEventType } from "node-opcua-address-space-base";
 import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
 import { NamespacePrivate } from "../namespace_private";
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
 import { ConditionInfo } from "./condition_info";
-import { UALimitAlarmEx, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+import { InstantiateLimitAlarmOptions, UALimitAlarmEx, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
 
 export interface UANonExclusiveLimitAlarmEx
     extends UALimitAlarmEx,
@@ -44,8 +43,8 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
     public static instantiate(
         namespace: NamespacePrivate,
         type: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UANonExclusiveLimitAlarmImpl {
         const addressSpace = namespace.addressSpace;
 

package/src/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -1,15 +1,17 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
+import { INamespace, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { DataValue } from "node-opcua-data-value";
-import { NodeId } from "node-opcua-nodeid";
+import { NodeId, NodeIdLike } from "node-opcua-nodeid";
 import { UAOffNormalAlarm_Base } from "node-opcua-nodeset-ua";
 import { StatusCodes } from "node-opcua-status-code";
 import * as utils from "node-opcua-utils";
-import { DataType } from "node-opcua-variant";
-import { INamespace, UAVariable } from "../../source";
+import { DataType, VariantOptions } from "node-opcua-variant";
+
 import { AddressSpacePrivate } from "../address_space_private";
+import { InstantiateAlarmConditionOptions } from "./ua_alarm_condition_impl";
 import { UADiscreteAlarmEx, UADiscreteAlarmImpl } from "./ua_discrete_alarm_impl";
 
 function isEqual(value1: any, value2: any) {
@@ -30,13 +32,16 @@ export declare interface UAOffNormalAlarmEx
             | "suppressedState"
         >,
         UADiscreteAlarmEx {
-    getNormalStateNode(): UAVariable;
+    getNormalStateNode(): UAVariable | null;
 
     getNormalStateValue(): any;
 
     setNormalStateValue(value: any): void;
 }
 
+export interface InstantiateOffNormalAlarmOptions extends InstantiateAlarmConditionOptions {
+    normalState: NodeIdLike;
+}
 export declare interface UAOffNormalAlarmImpl extends UAOffNormalAlarmEx, UADiscreteAlarmImpl {
     on(eventName: string, eventHandler: any): this;
 }
@@ -54,8 +59,8 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
     public static instantiate(
         namespace: INamespace,
         limitAlarmTypeId: string | NodeId,
-        options: any,
-        data: any
+        options: InstantiateOffNormalAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UAOffNormalAlarmImpl {
         const addressSpace = namespace.addressSpace as AddressSpacePrivate;
 
@@ -73,20 +78,36 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
         const alarmNode = UADiscreteAlarmImpl.instantiate(namespace, limitAlarmTypeId, options, data) as UAOffNormalAlarmImpl;
         Object.setPrototypeOf(alarmNode, UAOffNormalAlarmImpl.prototype);
 
-        const inputNode = addressSpace._coerceNode(options.inputNode);
-        //       assert(inputNode, "Expecting a valid input node");
-
-        const normalState = addressSpace._coerceNode(options.normalState)! as UAVariable;
-        //       assert(normalState, "Expecting a valid normalState node");
-
-        const normalStateNodeId = normalState ? normalState.nodeId : new NodeId();
-        alarmNode.normalState.setValueFromSource({ dataType: DataType.NodeId, value: normalStateNodeId });
+        /**
+         * The InputNode Property provides the NodeId of the Variable the Value of which is used as primary input in
+         * the calculation of the Alarm state.
+         *
+         * If this Variable is not in the AddressSpace, a NULL NodeId shall be provided.
+         *
+         * In some systems, an Alarm may be calculated based on multiple Variables Values;
+         * it is up to the system to determine which Variable’s NodeId is used.
+         */
+        const inputNode = addressSpace._coerceNode(options.inputNode) as UAVariable | null;
+        // note: alarmNode.inputNode.readValue() already set by DiscreteAlarmImpl.instantiate
 
         if (inputNode) {
             // install inputNode Node monitoring for change
             alarmNode.installInputNodeMonitoring(options.inputNode);
         }
 
+        /**
+         * The NormalState Property is a Property that points to a Variable which has a value that corresponds to one
+         * of the possible values of the Variable pointed to by the InputNode Property where the NormalState Property
+         * Variable value is the value that is considered to be the normal state of the Variable pointed to by the InputNode
+         * Property. When the value of the Variable referenced by the InputNode Property is not equal to the value of the
+         * NormalState Property the Alarm is Active.
+         *
+         * 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
@@ -100,7 +121,8 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
                 alarmNode._onNormalStateDataValueChange(newDataValue);
             });
         }
-        alarmNode._updateAlarmState();
+
+        alarmNode._mayBe_updateAlarmState();
 
         return alarmNode;
     }
@@ -114,18 +136,23 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
     // Property the Alarm is Active. If this Variable is not in the AddressSpace, a Null NodeId shall
     // be provided.
 
-    public getNormalStateNode(): UAVariable {
+    public getNormalStateNode(): UAVariable | null {
         const nodeId = this.normalState.readValue().value.value;
         const node = this.addressSpace.findNode(nodeId) as UAVariable;
-        assert(node, "getNormalStateNode ");
+        if (!node) {
+            return null;
+        }
         return node;
     }
 
     /**
      * @method getNormalStateValue
      */
-    public getNormalStateValue(): any {
+    public getNormalStateValue(): any | null {
         const normalStateNode = this.getNormalStateNode();
+        if (!normalStateNode) {
+            return null;
+        }
         return normalStateNode.readValue().value.value;
     }
 
@@ -138,24 +165,29 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
         throw new Error("Not Implemented yet");
     }
 
-    public _updateAlarmState(normalStateValue?: any, inputValue?: any): void {
-        if (utils.isNullOrUndefined(normalStateValue) || utils.isNullOrUndefined(inputValue)) {
-            this.activeState.setValue(false);
-            return;
-        }
-        const isActive = !isEqual(normalStateValue, inputValue);
-
+    public updateAlarmState(isActive: boolean, message: string) {
         if (isActive === this.activeState.getValue()) {
             // no change => ignore !
             return;
         }
-
         const stateName = isActive ? "Active" : "Inactive";
         // also raise the event
-        this._signalNewCondition(stateName, isActive, "");
+        this._signalNewCondition(stateName, isActive, message);
+        if (!isActive) {
+            this.currentBranch().setRetain(false);
+        }
+    }
+
+    private _mayBe_updateAlarmState(normalStateValue?: any, inputValue?: any): void {
+        if (utils.isNullOrUndefined(normalStateValue) || utils.isNullOrUndefined(inputValue)) {
+            this.activeState.setValue(false);
+            return;
+        }
+        const isActive = !isEqual(normalStateValue, inputValue);
+        this.updateAlarmState(isActive, "automatique update");
     }
 
-    public _onInputDataValueChange(dataValue: DataValue): void {
+    protected _onInputDataValueChange(dataValue: DataValue): void {
         if (dataValue.statusCode !== StatusCodes.Good) {
             // what shall we do ?
             return;
@@ -166,7 +198,7 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
         }
         const inputValue = dataValue.value.value;
         const normalStateValue = this.getNormalStateValue();
-        this._updateAlarmState(normalStateValue, inputValue);
+        this._mayBe_updateAlarmState(normalStateValue, inputValue);
     }
 
     protected _onNormalStateDataValueChange(dataValue: DataValue): void {
@@ -180,6 +212,6 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
         }
         const normalStateValue = dataValue.value.value;
         const inputValue = this.getInputNodeValue();
-        this._updateAlarmState(normalStateValue, inputValue);
+        this._mayBe_updateAlarmState(normalStateValue, inputValue);
     }
 }

package/src/alarms_and_conditions/ua_system_off_normal_alarm_impl.ts

@@ -1,10 +1,10 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
+import { INamespace } from "node-opcua-address-space-base";
 import { NodeId } from "node-opcua-nodeid";
-
-import { INamespace } from "../../source";
-import { UAOffNormalAlarmImpl } from "./ua_off_normal_alarm_impl";
+import { VariantOptions } from "node-opcua-variant";
+import { InstantiateOffNormalAlarmOptions, UAOffNormalAlarmImpl } from "./ua_off_normal_alarm_impl";
 
 /**
  *
@@ -17,8 +17,8 @@ export class UASystemOffNormalAlarmImpl extends UAOffNormalAlarmImpl {
     public static instantiate(
         namespace: INamespace,
         limitAlarmTypeId: string | NodeId,
-        options: any,
-        data: any
+        options: InstantiateOffNormalAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UASystemOffNormalAlarmImpl {
         return UAOffNormalAlarmImpl.instantiate(namespace, limitAlarmTypeId, options, data) as UASystemOffNormalAlarmImpl;
     }

package/src/ua_object_impl.ts

@@ -27,7 +27,8 @@ import {
     UAEventType,
     IEventData,
     defaultCloneFilter,
-    defaultCloneExtraInfo
+    defaultCloneExtraInfo,
+    EventNotifierFlags
 } from "node-opcua-address-space-base";
 
 import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
@@ -35,8 +36,11 @@ import { _clone, ToStringBuilder, UAObject_toString } from "./base_node_private"
 import { apply_condition_refresh, ConditionRefreshCache } from "./apply_condition_refresh";
 
 export class UAObjectImpl extends BaseNodeImpl implements UAObject {
+    private _eventNotifier: EventNotifierFlags;
     public readonly nodeClass = NodeClass.Object;
-    public readonly eventNotifier: number;
+    public get eventNotifier(): EventNotifierFlags {
+        return this._eventNotifier;
+    }
     public readonly symbolicName: string | null;
 
     get typeDefinitionObj(): UAObjectType {
@@ -45,7 +49,7 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
 
     constructor(options: InternalBaseNodeOptions & { eventNotifier?: number; symbolicName?: string | null }) {
         super(options);
-        this.eventNotifier = options.eventNotifier || 0;
+        this._eventNotifier = options.eventNotifier || EventNotifierFlags.None;
         assert(typeof this.eventNotifier === "number" && isValidByte(this.eventNotifier));
         this.symbolicName = options.symbolicName || null;
     }
@@ -111,6 +115,10 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         return super.getMethods();
     }
 
+    public setEventNotifier(eventNotifierFlags: EventNotifierFlags): void {
+        this._eventNotifier = eventNotifierFlags;
+    }
+
     /**
      * Raise a transient Event
      */