node-opcua-address-space 2.74.0 → 2.76.1

package/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.ts

@@ -2,10 +2,10 @@
  * @module node-opcua-address-space.AlarmsAndConditions
  */
 import { Certificate, exploreCertificate, makeSHA1Thumbprint } from "node-opcua-crypto";
-import { DateTime, minOPCUADate } from "node-opcua-basic-types";
+import { DateTime, minOPCUADate, StatusCodes } from "node-opcua-basic-types";
 import { make_warningLog } from "node-opcua-debug";
 import { NodeId } from "node-opcua-nodeid";
-import { DataType, VariantOptions } from "node-opcua-variant";
+import { DataType, Variant, VariantOptions } from "node-opcua-variant";
 import { INamespace, UAObject, UAProperty } from "node-opcua-address-space-base";
 import { ObjectTypeIds } from "node-opcua-constants";
 import { makeAccessLevelExFlag } from "node-opcua-data-model";
@@ -16,97 +16,136 @@ import { UASystemOffNormalAlarmImpl } from "./ua_system_off_normal_alarm_impl";
 
 const warningLog = make_warningLog("AlarmsAndConditions");
 
+const ellipsis = (arg0: string, arg1 = 4) => {
+    arg1 = Math.max(arg1, 4);
+    return arg0.length <= arg1 ? arg0 : arg0.slice(0, arg1 / 2) + "..." + arg0.slice(arg0.length - arg1 / 2);
+};
+const d = (d: Date) => {
+    return d.toISOString();
+};
 export function instantiateCertificateExpirationAlarm(
     namespace: INamespace,
     alarmType: "CertificateExpirationAlarmType",
-    options: InstantiateOffNormalAlarmOptions,
-    data?: Record<string, VariantOptions>
-
+    options: InstantiateOffNormalAlarmOptions
 ): UACertificateExpirationAlarmEx {
-    return UACertificateExpirationAlarmImpl.instantiate(namespace,alarmType, options, data);
+    return UACertificateExpirationAlarmImpl.instantiate(namespace, alarmType, options);
 }
 
-
 interface UACertificateExpirationAlarmImpl {
-    expirationDate: UAProperty<Date, /*z*/DataType.DateTime>;
-    expirationLimit?: UAProperty<number, /*z*/DataType.Double>;
-    certificateType: UAProperty<NodeId, /*z*/DataType.NodeId>;
-    certificate: UAProperty<Buffer, /*z*/DataType.ByteString>;
+    expirationDate: UAProperty<Date, /*z*/ DataType.DateTime>;
+    expirationLimit?: UAProperty<number, /*z*/ DataType.Double>;
+    certificateType: UAProperty<NodeId, /*z*/ DataType.NodeId>;
+    certificate: UAProperty<Buffer, /*z*/ DataType.ByteString>;
 }
+
+// This Simple DataType is a Double that defines an interval of time in milliseconds (fractions can be used to define sub-millisecond values).
+// Negative values are generally invalid but may have special meanings where the Duration is used.
+export const OneDayDuration = 1000 * 60 * 60 * 24;
+export const TwoWeeksDuration = OneDayDuration * 2 * 7;
+
 /**
  * This UACertificateExpirationAlarm (SystemOffNormalAlarmType) is raised by the Server when the Server’s
  * Certificate is within the ExpirationLimit
  * of expiration. This alarm automatically returns to normal when the certificate is updated.
  */
 class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implements UACertificateExpirationAlarmEx {
-
+    private timer: any;
 
     public static instantiate(
         namespace: INamespace,
         alarmType: "CertificateExpirationAlarmType",
-        options: InstantiateOffNormalAlarmOptions,
-        data?: Record<string, VariantOptions>
+        options: InstantiateOffNormalAlarmOptions
+        // data?: Record<string, VariantOptions>
     ): UACertificateExpirationAlarmImpl {
         const alarm = UASystemOffNormalAlarmImpl.instantiate(
             namespace,
             alarmType || "CertificateExpirationAlarmType",
-            options,
-            data
+            options
+            // data
         ) as UACertificateExpirationAlarmImpl;
-        Object.setPrototypeOf(alarm, UACertificateExpirationAlarmImpl.prototype);
-        alarm._post_initialize();
+        promoteToCertificateExpirationAlarm(alarm);
         return alarm;
     }
 
-    public getExpirationDate(): DateTime {
+    public getExpirationDate(): DateTime | null {
         return this.expirationDate.readValue().value.value;
     }
 
-    public setExpirationDate(expirationDate: Date): void {
-        this.expirationDate.setValueFromSource({
-            dataType: DataType.DateTime,
-            value: expirationDate
+    public updateAlarmState2(isActive: boolean, severity: number, message: string) {
+        //xx console.log(`${message} ${severity} ${d(new Date())}`);
+        isActive ? this.activateAlarm() : this.deactivateAlarm();
+
+        this.raiseNewCondition({
+            message,
+            quality: StatusCodes.Good,
+            retain: isActive ? true : false,
+            severity
         });
+    }
+
+    public update() {
+        this._updateAlarm();
+    }
+
+    private _updateAlarm() {
+        const expirationDate = this.getExpirationDate();
+
         const now = new Date();
+
         const expirationLimit = this.getExpirationLimit();
 
         const checkDate = new Date(now.getTime() + +expirationLimit);
 
-        const thumbprint = makeSHA1Thumbprint(this.getCertificate() || Buffer.alloc(0)).toString("hex");
+        const certificate = this.getCertificate();
 
-        if (expirationDate.getTime() <= checkDate.getTime()) {
-            if (!this.currentBranch().getActiveState()) {
-                warningLog(
-                    `CertificateExpirationAlarm:  becomes active, certificate ${thumbprint} endDate ${expirationDate.toUTCString()} checkDate=${checkDate.toUTCString()} expirationLimit=${expirationLimit}`
-                );
+        if (!expirationDate || (expirationDate === minOPCUADate && !certificate)) {
+            if (!this.currentBranch() || this.currentBranch().getActiveState()) {
+                this.updateAlarmState2(true, 255, "certificate is missing");
             }
+            return;
+        }
+
+        const thumbprint = ellipsis(makeSHA1Thumbprint(this.getCertificate() || Buffer.alloc(0)).toString("hex"), 10);
+        const info = `| end date: ${d(expirationDate)} | expirationLimit=${expirationLimit}|`;
+        //
+
+        if (expirationDate.getTime() <= checkDate.getTime()) {
             // also raise the event
             if (expirationDate.getTime() <= now.getTime()) {
-                this.updateAlarmState(
-                    true,
-                    `certificate ${thumbprint} has expired : end date is ${expirationDate.toUTCString()} checkDate=${checkDate.toUTCString()}  expirationLimit=${expirationLimit}`
-                );
+                this.updateAlarmState2(true, 250, `certificate ${thumbprint} has expired ${info}`);
             } else {
-                this.updateAlarmState(
-                    true,
-                    `certificate ${thumbprint} is about to expire : end date is ${expirationDate.toString()} checkDate=${checkDate.toUTCString()}  expirationLimit=${expirationLimit}`
-                );
+                //             check--------------------+
+                //       expiry---------------+         |
+                //       today-----+          |         |
+                //                 v          v         v
+                // ----------------+----------+---------+----------+
+                const t1 = checkDate.getTime() - now.getTime();
+                const t2 = checkDate.getTime() - expirationDate.getTime();
+                const severity = t1 === 0 ? 255 : Math.floor((t2 / t1) * 100) + 100;
+                this.updateAlarmState2(true, severity, `certificate ${thumbprint} is about to expire ${info}`);
             }
         } else {
-            if (this.currentBranch().getActiveState()) {
-                warningLog(
-                    `CertificateExpirationAlarm:  becomes desactivated, certificate ${thumbprint} endDate ${expirationDate.toUTCString()} expirationLimit=${expirationLimit}`
-                );
-            }
-            // also raise the event
-            this.updateAlarmState(
-                false,
-                `certificate ${thumbprint} end date is OK: ${expirationDate.toString()} , expirationLimit=${expirationLimit}`
-            );
+            this.updateAlarmState2(false, 0, `certificate ${thumbprint} is OK! ${info}`);
         }
     }
 
+    public setExpirationDate(expirationDate: Date): void {
+        this.expirationDate.setValueFromSource({
+            dataType: DataType.DateTime,
+            value: expirationDate
+        });
+        this._updateAlarm();
+    }
+
     public getExpirationLimit(): number {
+        // This shall be a positive number. If the property is not provided, a default of 2 weeks shall be used.
+        if (!this.expirationLimit) {
+            return TwoWeeksDuration;
+        }
+        const dataValue = this.expirationLimit!.readValue();
+        if ((dataValue as any).dataType === DataType.Null) {
+            return TwoWeeksDuration;
+        }
         return (this.expirationLimit?.readValue().value.value as number) || 0;
     }
 
@@ -115,13 +154,14 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
             dataType: DataType.Double,
             value
         });
+        this._updateAlarm();
     }
 
     public getCertificate(): Certificate | null {
         return (this.certificate.readValue().value.value as Certificate | null) || null;
     }
 
-    public setCertificate(certificate: Certificate | null): void {
+    private _extractAndSetExpiryDate(certificate: Certificate | null): void {
         if (certificate && certificate.length > 0) {
             const info = exploreCertificate(certificate);
             if (info.tbsCertificate.validity.notAfter instanceof Date) {
@@ -132,12 +172,22 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
         } else {
             this.setExpirationDate(minOPCUADate);
         }
+    }
+
+    public setCertificate(certificate: Certificate | null): void {
         this.certificate.setValueFromSource({
             dataType: DataType.ByteString,
             value: certificate
         });
+        this._extractAndSetExpiryDate(certificate);
     }
 
+    stopTimer() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
     _post_initialize() {
         if (this.expirationLimit) {
             this.expirationLimit.accessLevel = makeAccessLevelExFlag("CurrentRead | CurrentWrite");
@@ -148,6 +198,13 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
                 this.setCertificate(certificate);
             });
         }
+        const certificate = this.getCertificate();
+        this._extractAndSetExpiryDate(certificate);
+
+        this.addressSpace.registerShutdownTask(() => {
+            this.stopTimer();
+        });
+        this.timer = setInterval(() => this.update(), OneDayDuration / 48);
     }
 }
 
@@ -160,4 +217,4 @@ export function promoteToCertificateExpirationAlarm(node: UAObject): UACertifica
     _node._post_initialize();
     return _node;
 }
-registerNodePromoter(ObjectTypeIds.CertificateExpirationAlarmType, promoteToCertificateExpirationAlarm);
+registerNodePromoter(ObjectTypeIds.CertificateExpirationAlarmType, promoteToCertificateExpirationAlarm, true);

package/src/alarms_and_conditions/ua_condition_impl.ts

@@ -18,7 +18,7 @@ import {
     QualifiedName
 } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
-import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
+import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { minDate } from "node-opcua-basic-types";
 import { coerceNodeId, makeNodeId, NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
@@ -52,6 +52,7 @@ import { ConditionSnapshotImpl } from "./condition_snapshot_impl";
 const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
 const doDebug = checkDebugFlag(__filename);
+const warningLog = make_warningLog(__filename);
 
 export declare interface UAConditionImpl extends UAConditionEx, UABaseEventImpl {
     on(eventName: string, eventHandler: any): this;
@@ -450,6 +451,8 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
                     node._bubble_up_event(eventData);
                 }
             }
+        } else {
+            warningLog("Condition ", this.nodeId.toString(), "is not linked to a Object with a IsConditionOf(reversed(HasCondition))");
         }
         // xx console.log("MMMMMMMM%%%%%%%%%%%%%%%%%%%%% branch  " +
         // branch.getBranchId().toString() + " eventId = " + branch.getEventId().toString("hex"));
@@ -1123,11 +1126,11 @@ function _add_comment_method(
     callback: CallbackT<CallMethodResultOptions>
 ) {
     //
-    // The AddComment Method is used to apply a comment to a specific state of a Condition
-    // instance. Normally, the NodeId of the object instance as the ObjectId is passed to the Call
-    // Service. However, some Servers do not expose Condition instances in the AddressSpace.
-    // Therefore all Servers shall also allow Clients to call the AddComment Method by specifying
-    // ConditionId as the ObjectId. The Method cannot be called with an ObjectId of the
+    // The AddComment Method is used to apply a comment to a specific state of a Condition 
+    // instance. Normally, the NodeId of the Object instance is passed as the ObjectId to the Call 
+    // Service. However, some Servers do not expose Condition instances in the AddressSpace. 
+    // Therefore, all Servers shall also allow Clients to call the AddComment Method by specifying 
+    // ConditionId as the ObjectId. The Method cannot be called with an ObjectId of the 
     // ConditionType Node.
     // Signature
     //   - EventId EventId identifying a particular Event Notification where a state was reported for a

package/src/alarms_and_conditions/ua_exclusive_deviation_alarm_impl.ts

@@ -5,13 +5,12 @@ import { assert } from "node-opcua-assert";
 import { DataValue } from "node-opcua-data-value";
 import { NodeId } from "node-opcua-nodeid";
 import { DataType, VariantOptions } from "node-opcua-variant";
-import { UAExclusiveDeviationAlarm_Base } from "node-opcua-nodeset-ua";
 import { UAVariable, UAVariableT } from "node-opcua-address-space-base";
 import { AddressSpace } from "../address_space";
 import { NamespacePrivate } from "../namespace_private";
 import { UAExclusiveDeviationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
 import { InstantiateExclusiveLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
-import { InstallSetPointOptions } from "../../source/interfaces/alarms_and_conditions/install_setpoint_options";
+import { InstallSetPointOptions, SetPointSupport } from "../../source/interfaces/alarms_and_conditions/install_setpoint_options";
 import {
     DeviationAlarmHelper_getSetpointNodeNode,
     DeviationAlarmHelper_getSetpointValue,
@@ -30,6 +29,8 @@ export declare interface UAExclusiveDeviationAlarmImpl extends UAExclusiveDeviat
 }
 
 export class UAExclusiveDeviationAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveDeviationAlarmEx {
+
+
     public static instantiate(
         namespace: NamespacePrivate,
         type: string | NodeId,
@@ -57,7 +58,7 @@ export class UAExclusiveDeviationAlarmImpl extends UAExclusiveLimitAlarmImpl imp
         return alarm;
     }
 
-    public getSetpointNodeNode(): UAVariable {
+    public getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined  {
         return DeviationAlarmHelper_getSetpointNodeNode.call(this);
     }
 
@@ -83,9 +84,7 @@ export class UAExclusiveDeviationAlarmImpl extends UAExclusiveLimitAlarmImpl imp
         UAExclusiveLimitAlarmImpl.prototype._setStateBasedOnInputValue.call(this, value - setpointValue);
     }
 }
-export interface UAExclusiveDeviationAlarmHelper {
-    setpointNode: UAVariableT<NodeId, DataType.NodeId>;
-    setpointNodeNode: UAVariable;
+export interface UAExclusiveDeviationAlarmHelper  extends SetPointSupport{
 }
 
 /*

package/src/alarms_and_conditions/ua_exclusive_limit_alarm_impl.ts

@@ -104,7 +104,7 @@ export class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExc
         }
 
         if (state !== oldState) {
-            this._signalNewCondition(state, isActive, value.toString());
+            this._signalNewCondition(state, isActive, value.toFixed(3));
         }
     }
 }

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_non_exclusive_limit_alarm_impl.ts

@@ -106,7 +106,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
     }
 
     public _calculateConditionInfo(
-        states: string | null,
+        state: string | null,
         isActive: boolean,
         value: string,
         oldConditionInfo: ConditionInfo
@@ -120,7 +120,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
             });
         } else {
             return new ConditionInfoImpl({
-                message: "Condition value is " + value + " and state is " + states,
+                message: "Condition is " + value + " and state is " + state,
                 quality: StatusCodes.Good,
                 retain: true,
                 severity: 150
@@ -196,7 +196,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
         });
 
         if (count > 0) {
-            this._signalNewCondition2(states, isActive, value.toString());
+            this._signalNewCondition2(states, isActive, value.toFixed(3));
         }
     }
 }

package/src/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -1,18 +1,20 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { INamespace, UAVariable } from "node-opcua-address-space-base";
+import { INamespace, UAVariable, UAVariableT } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { DataValue } from "node-opcua-data-value";
 import { NodeId, NodeIdLike } from "node-opcua-nodeid";
+
 import { UAOffNormalAlarm_Base } from "node-opcua-nodeset-ua";
+import { NumericalRangeInvalid } from "node-opcua-numeric-range";
 import { StatusCodes } from "node-opcua-status-code";
 import * as utils from "node-opcua-utils";
 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;
@@ -32,14 +34,13 @@ export declare interface UAOffNormalAlarmEx
             | "suppressedState"
         >,
         UADiscreteAlarmEx {
-    getNormalStateNode(): UAVariable | null;
+    getNormalStateNode(): UAVariableT<NodeId, DataType.NodeId> | null;
 
-    getNormalStateValue(): any;
+    getNormalStateValue(): NodeId | null;
 
-    setNormalStateValue(value: any): void;
+    setNormalStateValue(value: NodeIdLike): void;
 }
 
-
 export declare interface UAOffNormalAlarmImpl extends UAOffNormalAlarmEx, UADiscreteAlarmImpl {
     on(eventName: string, eventHandler: any): this;
 }
@@ -54,7 +55,7 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
      * When the value of inputNode doesn't match the normalState node value, then the alarm is raised.
      *
      */
-    public static instantiate(
+    public static instantiate<T, DT extends DataType>(
         namespace: INamespace,
         limitAlarmTypeId: string | NodeId,
         options: InstantiateOffNormalAlarmOptions,
@@ -103,21 +104,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();
@@ -134,9 +138,9 @@ 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 | null {
+    public getNormalStateNode(): UAVariableT<NodeId, DataType.NodeId> | null {
         const nodeId = this.normalState.readValue().value.value;
-        const node = this.addressSpace.findNode(nodeId) as UAVariable;
+        const node = this.addressSpace.findNode(nodeId) as UAVariableT<NodeId, DataType.NodeId>;
         if (!node) {
             return null;
         }
@@ -146,19 +150,19 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
     /**
      * @method getNormalStateValue
      */
-    public getNormalStateValue(): any | null {
+    public getNormalStateValue(): NodeId | null {
         const normalStateNode = this.getNormalStateNode();
         if (!normalStateNode) {
             return null;
         }
-        return normalStateNode.readValue().value.value;
+        return normalStateNode.readValue().value.value as NodeId;
     }
 
     /**
      * @method setNormalStateValue
      * @param value
      */
-    public setNormalStateValue(value: any): void {
+    public setNormalStateValue(value: NodeIdLike): void {
         const normalStateNode = this.getNormalStateNode();
         throw new Error("Not Implemented yet");
     }

package/src/alarms_and_conditions/ua_system_off_normal_alarm_impl.ts

@@ -3,7 +3,7 @@
  */
 import { INamespace } from "node-opcua-address-space-base";
 import { NodeId } from "node-opcua-nodeid";
-import { VariantOptions } from "node-opcua-variant";
+import { DataType, VariantOptions } from "node-opcua-variant";
 import { InstantiateOffNormalAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
 import { UAOffNormalAlarmImpl } from "./ua_off_normal_alarm_impl";