node-opcua-address-space 2.71.0 → 2.72.0

package/src/alarms_and_conditions/ua_acknowledgeable_condition_impl.ts

@@ -6,7 +6,7 @@ import { assert } from "node-opcua-assert";
 import { LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
 import { NodeId } from "node-opcua-nodeid";
 import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
-import { DataType, VariantLike } from "node-opcua-variant";
+import { DataType, VariantLike, VariantOptions } from "node-opcua-variant";
 import { INamespace, RaiseEventData, ISessionContext, UAEventType, UAMethod } from "node-opcua-address-space-base";
 import { CallMethodResultOptions } from "node-opcua-service-call";
 
@@ -16,6 +16,7 @@ import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_sta
 import { _setAckedState } from "./condition";
 import { ConditionSnapshot } from "./condition_snapshot";
 import { UAConditionHelper, UAConditionImpl, UAConditionEx } from "./ua_condition_impl";
+import { InstantiateAlarmConditionOptions } from "./ua_alarm_condition_impl";
 
 export interface UAAcknowledgeableConditionHelper extends UAConditionHelper {
     ///
@@ -53,8 +54,8 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
     public static instantiate(
         namespace: INamespace,
         conditionTypeId: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
     ): UAAcknowledgeableConditionImpl {
         const conditionNode = UAConditionImpl.instantiate(
             namespace,
@@ -107,7 +108,9 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
     }
 
     public static install_method_handle_on_type(addressSpace: AddressSpacePrivate): void {
-        const acknowledgeableConditionType = addressSpace.findEventType("AcknowledgeableConditionType") as unknown as UAAcknowledgeableCondition_Base;
+        const acknowledgeableConditionType = addressSpace.findEventType(
+            "AcknowledgeableConditionType"
+        ) as unknown as UAAcknowledgeableCondition_Base;
         assert(acknowledgeableConditionType !== null);
         acknowledgeableConditionType.acknowledge.bindMethod(_acknowledge_method);
         acknowledgeableConditionType.confirm?.bindMethod(_confirm_method);
@@ -297,7 +300,11 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
     }
 }
 
-function _acknowledge_method(inputArguments: VariantLike[], context: ISessionContext, callback: CallbackT<CallMethodResultOptions>) {
+function _acknowledge_method(
+    inputArguments: VariantLike[],
+    context: ISessionContext,
+    callback: CallbackT<CallMethodResultOptions>
+) {
     UAConditionImpl.with_condition_method(
         inputArguments,
         context,
@@ -322,7 +329,7 @@ function _acknowledge_method(inputArguments: VariantLike[], context: ISessionCon
  *
  * @private
  */
-function _confirm_method(inputArguments: VariantLike[], context: ISessionContext,  callback: CallbackT<CallMethodResultOptions>) {
+function _confirm_method(inputArguments: VariantLike[], context: ISessionContext, callback: CallbackT<CallMethodResultOptions>) {
     UAConditionImpl.with_condition_method(
         inputArguments,
         context,

package/src/alarms_and_conditions/ua_alarm_condition_impl.ts

@@ -8,10 +8,10 @@ import { NodeClass } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
 import { NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import { DataType } from "node-opcua-variant";
+import { DataType, VariantOptions } from "node-opcua-variant";
 import { UAAlarmCondition_Base } from "node-opcua-nodeset-ua";
+import { BaseNode, INamespace, UAEventType, UAVariable } from "node-opcua-address-space-base";
 
-import { BaseNode, INamespace, UAEventType, UAVariable } from "../../source";
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
 import { UAShelvedStateMachineEx, _clear_timer_if_any } from "../state_machine/ua_shelving_state_machine_ex";
 import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
@@ -23,6 +23,7 @@ import {
     UAAcknowledgeableConditionHelper,
     UAAcknowledgeableConditionImpl
 } from "./ua_acknowledgeable_condition_impl";
+import { InstantiateConditionOptions } from "./ua_condition_impl";
 
 function _update_suppressedOrShelved(alarmNode: UAAlarmConditionImpl) {
     alarmNode.suppressedOrShelved.setValueFromSource({
@@ -32,7 +33,7 @@ function _update_suppressedOrShelved(alarmNode: UAAlarmConditionImpl) {
 }
 export interface UAAlarmConditionHelper extends UAAcknowledgeableConditionHelper {
     activateAlarm(): void;
-    deactivateAlarm(): void;
+    deactivateAlarm(retain?: boolean): void;
     isSuppressedOrShelved(): boolean;
     getSuppressedOrShelved(): boolean;
     setMaxTimeShelved(duration: number): void;
@@ -65,14 +66,18 @@ export declare interface UAAlarmConditionImpl extends UAAlarmConditionEx, UAAckn
     on(eventName: string, eventHandler: any): this;
 }
 
+export interface InstantiateAlarmConditionOptions extends InstantiateConditionOptions {
+    maxTimeShelved?: number;
+    inputNode: BaseNode | NodeId;
+}
 export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl implements UAAlarmConditionEx {
     public static MaxDuration = Math.pow(2, 31);
 
     public static instantiate(
         namespace: INamespace,
         alarmConditionTypeId: UAEventType | string | NodeId,
-        options: any,
-        data: any
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
     ): UAAlarmConditionImpl {
         const addressSpace = namespace.addressSpace;
         // xx assert(Object.prototype.hasOwnProperty.call(options,"conditionOf")); // must provide a conditionOf
@@ -93,7 +98,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         options.optionals = options.optionals || [];
         if (Object.prototype.hasOwnProperty.call(options, "maxTimeShelved")) {
             options.optionals.push("MaxTimeShelved");
-            assert(isFinite(options.maxTimeShelved));
+            assert(isFinite(options.maxTimeShelved!));
         }
 
         assert(alarmConditionTypeBase === alarmConditionType || alarmConditionType.isSupertypeOf(alarmConditionTypeBase));
@@ -229,16 +234,16 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         branch.setAckedState(false);
     }
 
-    public deactivateAlarm(): void {
+    public deactivateAlarm(retain?: boolean): void {
         const branch = this.currentBranch();
-        branch.setRetain(true);
+        branch.setRetain(retain === undefined ? true : retain);
         branch.setActiveState(false);
     }
 
     /**
      * @deprecated use deactivateAlarm instead (with no s after de-activate)
      */
-    public desactivateAlarm(): void {
+    protected desactivateAlarm(): void {
         this.deactivateAlarm();
     }
 
@@ -325,7 +330,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         this._onInputDataValueChange(dataValue);
     }
 
-    public _onInputDataValueChange(newValue: DataValue): void {
+    protected _onInputDataValueChange(newValue: DataValue): void {
         // xx console.log("class=",this.constructor.name,this.browseName.toString());
         // xx throw new Error("_onInputDataValueChange must be overridden");
     }

package/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.ts

@@ -1,12 +1,20 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { DateTime } from "node-opcua-basic-types";
-import { DataType } from "node-opcua-variant";
-import { UACertificateExpirationAlarm, UACertificateExpirationAlarm_Base } from "node-opcua-nodeset-ua";
-import { INamespace } from "node-opcua-address-space-base";
+import { Certificate, exploreCertificate, makeSHA1Thumbprint } from "node-opcua-crypto";
+import { DateTime, minOPCUADate } from "node-opcua-basic-types";
+import { make_warningLog } from "node-opcua-debug";
+import { DataType, VariantOptions } from "node-opcua-variant";
+import { UACertificateExpirationAlarm_Base } from "node-opcua-nodeset-ua";
+import { INamespace, UAObject } from "node-opcua-address-space-base";
+import { ObjectTypeIds } from "node-opcua-constants";
+import { AccessRestrictionsFlag, makeAccessLevelExFlag } from "node-opcua-data-model";
+import { registerNodePromoter } from "../../source/loader/register_node_promoter";
+import { InstantiateOffNormalAlarmOptions, UAOffNormalAlarmImpl } from "./ua_off_normal_alarm_impl";
 import { UASystemOffNormalAlarmImpl } from "./ua_system_off_normal_alarm_impl";
 
+const warningLog = make_warningLog("AlarmsAndConditions");
+
 export interface UACertificateExpirationAlarmEx
     extends Omit<
         UACertificateExpirationAlarm_Base,
@@ -20,7 +28,15 @@ export interface UACertificateExpirationAlarmEx
         | "shelvingState"
         | "silenceState"
         | "suppressedState"
-    > {}
+    > {
+    getExpirationDate(): DateTime;
+    setExpirationDate(value: Date): void;
+    getExpirationLimit(): number;
+    setExpirationLimit(value: number): void;
+    setCertificate(certificate: Certificate | null): void;
+    getCertificate(): Certificate | null;
+}
+
 export declare interface UACertificateExpirationAlarmImpl extends UACertificateExpirationAlarmEx, UASystemOffNormalAlarmImpl {}
 /**
  * This UACertificateExpirationAlarm (SystemOffNormalAlarmType) is raised by the Server when the Server’s
@@ -28,23 +44,123 @@ export declare interface UACertificateExpirationAlarmImpl extends UACertificateE
  * of expiration. This alarm automatically returns to normal when the certificate is updated.
  */
 export class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implements UACertificateExpirationAlarmEx {
-    public static instantiate(namespace: INamespace, options: any, data: any): UACertificateExpirationAlarmImpl {
-        return UASystemOffNormalAlarmImpl.instantiate(
+    public static instantiate(
+        namespace: INamespace,
+        alarmType: "CertificateExpirationAlarmType",
+        options: InstantiateOffNormalAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UACertificateExpirationAlarmImpl {
+        const alarm = UASystemOffNormalAlarmImpl.instantiate(
             namespace,
-            "CertificateExpirationAlarmType",
+            alarmType || "CertificateExpirationAlarmType",
             options,
             data
         ) as UACertificateExpirationAlarmImpl;
+        Object.setPrototypeOf(alarm, UACertificateExpirationAlarmImpl.prototype);
+        alarm._post_initialize();
+        return alarm;
     }
 
     public getExpirationDate(): DateTime {
         return this.expirationDate.readValue().value.value;
     }
 
-    public setExpirationDate(value: Date): void {
-        return this.expirationDate.setValueFromSource({
+    public setExpirationDate(expirationDate: Date): void {
+        this.expirationDate.setValueFromSource({
             dataType: DataType.DateTime,
+            value: expirationDate
+        });
+        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");
+
+        if (expirationDate.getTime() <= checkDate.getTime()) {
+            if (!this.currentBranch().getActiveState()) {
+                warningLog(
+                    `CertificateExpirationAlarm:  becomes active, certificate ${thumbprint} endDate ${expirationDate.toUTCString()} checkDate=${checkDate.toUTCString()} expirationLimit=${expirationLimit}`
+                );
+            }
+            // 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}`
+                );
+            } else {
+                this.updateAlarmState(
+                    true,
+                    `certificate ${thumbprint} is about to expire : end date is ${expirationDate.toString()} checkDate=${checkDate.toUTCString()}  expirationLimit=${expirationLimit}`
+                );
+            }
+        } 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}`
+            );
+        }
+    }
+
+    public getExpirationLimit(): number {
+        return (this.expirationLimit?.readValue().value.value as number) || 0;
+    }
+
+    public setExpirationLimit(value: number): void {
+        this.expirationLimit?.setValueFromSource({
+            dataType: DataType.Double,
             value
         });
     }
+
+    public getCertificate(): Certificate | null {
+        return (this.certificate.readValue().value.value as Certificate | null) || null;
+    }
+
+    public setCertificate(certificate: Certificate | null): void {
+        if (certificate && certificate.length > 0) {
+            const info = exploreCertificate(certificate);
+            if (info.tbsCertificate.validity.notAfter instanceof Date) {
+                this.setExpirationDate(info.tbsCertificate.validity.notAfter);
+            } else {
+                this.setExpirationDate(minOPCUADate);
+            }
+        } else {
+            this.setExpirationDate(minOPCUADate);
+        }
+        this.certificate.setValueFromSource({
+            dataType: DataType.ByteString,
+            value: certificate
+        });
+    }
+
+    _post_initialize() {
+        if (this.expirationLimit) {
+            this.expirationLimit.accessLevel = makeAccessLevelExFlag("CurrentRead | CurrentWrite");
+            this.expirationLimit.userAccessLevel = makeAccessLevelExFlag("CurrentRead | CurrentWrite");
+            this.expirationLimit.on("value_changed", (dataValue) => {
+                // make sure we re-evaluate the certificfate
+                const certificate = this.getCertificate();
+                this.setCertificate(certificate);
+            });
+        }
+    }
+}
+
+export function promoteToCertificateExpirationAlarm(node: UAObject): UACertificateExpirationAlarmImpl {
+    if (node instanceof UACertificateExpirationAlarmImpl) {
+        return node; // already promoted
+    }
+    Object.setPrototypeOf(node, UACertificateExpirationAlarmImpl.prototype);
+    const _node = node as unknown as UACertificateExpirationAlarmImpl;
+    _node._post_initialize();
+    return _node;
 }
+registerNodePromoter(ObjectTypeIds.CertificateExpirationAlarmType, promoteToCertificateExpirationAlarm);

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 (