node-opcua-address-space 2.169.0 → 2.172.0

package/src/alarms_and_conditions/ua_discrete_alarm_impl.ts

@@ -1,20 +1,21 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
+
+import type { INamespace, UAEventType } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { NodeId } from "node-opcua-nodeid";
-import { UADiscreteAlarm, UADiscreteAlarm_Base } from "node-opcua-nodeset-ua";
-import { VariantOptions } from "node-opcua-variant";
-import { INamespace, UAEventType } from "node-opcua-address-space-base";
-import { UADiscreteAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
-import { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
-import { UAAlarmConditionImpl } from "./ua_alarm_condition_impl";
+import type { NodeId } from "node-opcua-nodeid";
+import type { UADiscreteAlarm } from "node-opcua-nodeset-ua";
+import type { VariantOptions } from "node-opcua-variant";
+import type { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options.js";
+import type { UADiscreteAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_discrete_alarm_ex.js";
+import { UAAlarmConditionImplBase } from "./ua_alarm_condition_impl.js";
 /**
  * The DiscreteAlarmType is used to classify Types into Alarm Conditions where the input for the
  * Alarm may take on only a certain number of possible values (e.g. true/false,
  * running/stopped/terminating).
  */
-export class UADiscreteAlarmImpl extends UAAlarmConditionImpl implements UADiscreteAlarmEx {
+export class UADiscreteAlarmImplBase extends UAAlarmConditionImplBase  {
     public static instantiate(
         namespace: INamespace,
         discreteAlarmTypeId: UAEventType | NodeId | string,
@@ -26,7 +27,7 @@ export class UADiscreteAlarmImpl extends UAAlarmConditionImpl implements UADiscr
         const discreteAlarmType = addressSpace.findEventType(discreteAlarmTypeId);
         /* c8 ignore next */
         if (!discreteAlarmType) {
-            throw new Error(" cannot find Condition Type for " + discreteAlarmType);
+            throw new Error(` cannot find Condition Type for ${discreteAlarmType}`);
         }
 
         const discreteAlarmTypeBase = addressSpace.findObjectType("DiscreteAlarmType");
@@ -38,9 +39,16 @@ export class UADiscreteAlarmImpl extends UAAlarmConditionImpl implements UADiscr
             throw new Error("UADiscreteAlarm.instantiate : event found is not subType of DiscreteAlarmType");
         }
 
-        const alarmNode = UAAlarmConditionImpl.instantiate(namespace, discreteAlarmType.nodeId, options, data) as UADiscreteAlarm;
-        Object.setPrototypeOf(alarmNode, UADiscreteAlarmImpl.prototype);
+        const alarmNode = UAAlarmConditionImplBase.instantiate(
+            namespace,
+            discreteAlarmType.nodeId,
+            options,
+            data
+        ) as  unknown as UADiscreteAlarm;
+        Object.setPrototypeOf(alarmNode, UADiscreteAlarmImplBase.prototype);
 
-        return alarmNode as UADiscreteAlarmImpl;
+        return alarmNode as unknown as  UADiscreteAlarmImpl;
     }
 }
+export type UADiscreteAlarmImpl = UADiscreteAlarmImplBase & UADiscreteAlarmEx;
+export const UADiscreteAlarmImpl = UADiscreteAlarmImplBase as unknown as UADiscreteAlarmImpl;

package/src/alarms_and_conditions/ua_exclusive_deviation_alarm_impl.ts

@@ -1,42 +1,36 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
+
+import type { UAVariableT } 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 { DataType, VariantOptions } from "node-opcua-variant";
-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, SetPointSupport } from "../../source/interfaces/alarms_and_conditions/install_setpoint_options";
+import type { DataValue } from "node-opcua-data-value";
+import type { NodeId } from "node-opcua-nodeid";
+import type { DataType, VariantOptions } from "node-opcua-variant";
+import type { DeviationStuff } from "../../source/interfaces/alarms_and_conditions/deviation_stuff";
+import type {
+    InstallSetPointOptions,
+    SetPointSupport
+} from "../../source/interfaces/alarms_and_conditions/install_setpoint_options";
+import type { InstantiateExclusiveLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
+import type { UAExclusiveDeviationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
+
+import type { NamespacePrivate } from "../namespace_private";
 import {
     DeviationAlarmHelper_getSetpointNodeNode,
     DeviationAlarmHelper_getSetpointValue,
     DeviationAlarmHelper_install_setpoint,
-    DeviationAlarmHelper_onSetpointDataValueChange,
+    DeviationAlarmHelper_onSetpointDataValueChange
 } from "./deviation_alarm_helper";
 
-import {  UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
-import {  UALimitAlarmImpl } from "./ua_limit_alarm_impl";
-
-
-
-export declare interface UAExclusiveDeviationAlarmImpl extends UAExclusiveDeviationAlarmEx, UAExclusiveLimitAlarmImpl {
-    on(eventName: string, eventHandler: any): this;
-    once(eventName: string, eventHandler: any): this;
-
-    get addressSpace(): AddressSpace;
-}
-
-export class UAExclusiveDeviationAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveDeviationAlarmEx {
-
+import { UAExclusiveLimitAlarmImpl, UAExclusiveLimitAlarmImplBase } from "./ua_exclusive_limit_alarm_impl";
+import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
 
+export class UAExclusiveDeviationAlarmImplBase extends UAExclusiveLimitAlarmImplBase {
     public static instantiate(
         namespace: NamespacePrivate,
         type: string | NodeId,
-        options: InstantiateExclusiveLimitAlarmOptions,
+        options: InstantiateExclusiveLimitAlarmOptions & InstallSetPointOptions,
         data?: Record<string, VariantOptions>
     ): UAExclusiveDeviationAlarmImpl {
         const addressSpace = namespace.addressSpace;
@@ -49,7 +43,12 @@ export class UAExclusiveDeviationAlarmImpl extends UAExclusiveLimitAlarmImpl imp
 
         assert(type === exclusiveDeviationAlarmType.browseName.toString());
 
-        const alarm = UAExclusiveLimitAlarmImpl.instantiate(namespace, type, options, data) as UAExclusiveDeviationAlarmImpl;
+        const alarm = UAExclusiveLimitAlarmImplBase.instantiate(
+            namespace,
+            type,
+            options,
+            data
+        ) as unknown as UAExclusiveDeviationAlarmImplBase;
         Object.setPrototypeOf(alarm, UAExclusiveDeviationAlarmImpl.prototype);
         assert(alarm instanceof UAExclusiveDeviationAlarmImpl);
         assert(alarm instanceof UAExclusiveLimitAlarmImpl);
@@ -57,23 +56,26 @@ export class UAExclusiveDeviationAlarmImpl extends UAExclusiveLimitAlarmImpl imp
 
         alarm._install_setpoint(options);
 
-        return alarm;
+        return alarm as UAExclusiveDeviationAlarmImpl;
     }
 
-    public getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined  {
-        return DeviationAlarmHelper_getSetpointNodeNode.call(this);
+    private get $16() {
+        return this as unknown as UAExclusiveDeviationAlarmEx & DeviationStuff;
+    }
+    public getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined {
+        return DeviationAlarmHelper_getSetpointNodeNode.call(this.$16);
     }
 
     public getSetpointValue(): number | null {
-        return DeviationAlarmHelper_getSetpointValue.call(this);
+        return DeviationAlarmHelper_getSetpointValue.call(this.$16);
     }
 
     public _onSetpointDataValueChange(dataValue: DataValue): void {
-        DeviationAlarmHelper_onSetpointDataValueChange.call(this, dataValue);
+        DeviationAlarmHelper_onSetpointDataValueChange.call(this.$16, dataValue);
     }
 
-    public _install_setpoint(options: InstallSetPointOptions): any {
-        return DeviationAlarmHelper_install_setpoint.call(this, options);
+    public _install_setpoint(options: InstallSetPointOptions): void {
+        DeviationAlarmHelper_install_setpoint.call(this.$16, options);
     }
 
     public _setStateBasedOnInputValue(value: number): void {
@@ -81,17 +83,12 @@ export class UAExclusiveDeviationAlarmImpl extends UAExclusiveLimitAlarmImpl imp
         if (setpointValue === null) {
             return;
         }
-        assert(isFinite(setpointValue));
+        assert(Number.isFinite(setpointValue));
         // call base class implementation
         UAExclusiveLimitAlarmImpl.prototype._setStateBasedOnInputValue.call(this, value - setpointValue);
     }
 }
-export interface UAExclusiveDeviationAlarmHelper  extends SetPointSupport{
-}
-
-/*
-UAExclusiveDeviationAlarm.prototype.getSetpointNodeNode = DeviationAlarmHelper.getSetpointNodeNode;
-UAExclusiveDeviationAlarm.prototype.getSetpointValue = DeviationAlarmHelper.getSetpointValue;
-UAExclusiveDeviationAlarm.prototype._onSetpointDataValueChange = DeviationAlarmHelper._onSetpointDataValueChange;
-UAExclusiveDeviationAlarm.prototype._install_setpoint = DeviationAlarmHelper._install_setpoint;
- */
+export type UAExclusiveDeviationAlarmImpl = UAExclusiveDeviationAlarmImplBase & UAExclusiveDeviationAlarmEx;
+export const UAExclusiveDeviationAlarmImpl =
+    UAExclusiveDeviationAlarmImplBase as unknown as new () => UAExclusiveDeviationAlarmImpl;
+export interface UAExclusiveDeviationAlarmHelper extends SetPointSupport {}

package/src/alarms_and_conditions/ua_exclusive_level_alarm_impl.ts

@@ -1,11 +1,11 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { NodeId } from "node-opcua-nodeid";
-import { VariantOptions } from "node-opcua-variant";
-import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
-import { NamespacePrivate } from "../namespace_private";
-import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
+import type { NodeId } from "node-opcua-nodeid";
+import type { VariantOptions } from "node-opcua-variant";
+import type { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import type { NamespacePrivate } from "../namespace_private";
+import { UAExclusiveLimitAlarmImpl, UAExclusiveLimitAlarmImplBase } from "./ua_exclusive_limit_alarm_impl";
 
 export class UAExclusiveLevelAlarmImpl extends UAExclusiveLimitAlarmImpl {
     public static instantiate(
@@ -14,7 +14,7 @@ export class UAExclusiveLevelAlarmImpl extends UAExclusiveLimitAlarmImpl {
         options: InstantiateLimitAlarmOptions,
         data?: Record<string, VariantOptions>
     ): UAExclusiveLevelAlarmImpl {
-        const addressSpace = namespace.addressSpace;
-        return UAExclusiveLimitAlarmImpl.instantiate(namespace, type, options, data) as UAExclusiveLevelAlarmImpl;
+        const _addressSpace = namespace.addressSpace;
+        return UAExclusiveLimitAlarmImplBase.instantiate(namespace, type, options, data) as UAExclusiveLevelAlarmImpl;
     }
 }

package/src/alarms_and_conditions/ua_exclusive_limit_alarm_impl.ts

@@ -1,24 +1,16 @@
-/**
- * @module node-opcua-address-space.AlarmsAndConditions
- */
+import type { UAEventType, UAObject } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { NodeId } from "node-opcua-nodeid";
-import { UAObject } from "node-opcua-address-space-base";
-import { VariantOptions } from "node-opcua-variant";
-import { UAEventType } from "node-opcua-address-space-base";
-import { NamespacePrivate } from "../namespace_private";
+import type { NodeId } from "node-opcua-nodeid";
+import type { VariantOptions } from "node-opcua-variant";
+import type { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import type { UAExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
+import type { NamespacePrivate } from "../namespace_private";
 import { promoteToStateMachine } from "../state_machine/finite_state_machine";
-import { UAExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
-import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
-import {  UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+import { UALimitAlarmImpl, UALimitAlarmImplBase } from "./ua_limit_alarm_impl";
 
 const validState = ["HighHigh", "High", "Low", "LowLow", null];
 
-export declare interface UAExclusiveLimitAlarmImpl extends UAExclusiveLimitAlarmEx {
-    /** empty interface */
-}
-
-export class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExclusiveLimitAlarmEx {
+export class UAExclusiveLimitAlarmImplBase extends UALimitAlarmImpl {
     /***
      *
      * @param namespace {INamespace}
@@ -39,7 +31,7 @@ export class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExc
 
         /* c8 ignore next */
         if (!exclusiveAlarmType) {
-            throw new Error(" cannot find Alarm Condition Type for " + type);
+            throw new Error(` cannot find Alarm Condition Type for ${type}`);
         }
 
         const exclusiveLimitAlarmType = addressSpace.findEventType("ExclusiveLimitAlarmType");
@@ -48,47 +40,50 @@ export class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExc
             throw new Error("cannot find ExclusiveLimitAlarmType");
         }
 
-        const node = UALimitAlarmImpl.instantiate(namespace, type, options, data);
-        Object.setPrototypeOf(node, UAExclusiveLimitAlarmImpl.prototype);
-        const alarm = node as any as UAExclusiveLimitAlarmImpl;
+        const node = UALimitAlarmImplBase.instantiate(namespace, type, options, data);
+        Object.setPrototypeOf(node, UAExclusiveLimitAlarmImplBase.prototype);
+        const alarm = node as unknown as UAExclusiveLimitAlarmImplBase;
         assert(alarm instanceof UAExclusiveLimitAlarmImpl);
         assert(alarm instanceof UALimitAlarmImpl);
 
         // ---------------- install LimitState StateMachine
-        assert(alarm.limitState, "limitState is mandatory");
-        promoteToStateMachine(alarm.limitState as unknown as UAObject);
+        assert(alarm.$10.limitState, "limitState is mandatory");
+        promoteToStateMachine(alarm.$10.limitState as unknown as UAObject);
 
         // start with a inactive state
         alarm.activeState.setValue(false);
 
         alarm.updateState();
 
-        return alarm;
+        return alarm as UAExclusiveLimitAlarmImpl;
     }
 
+    private get $10() {
+        return this as unknown as UAExclusiveLimitAlarmEx;
+    }
     public _signalNewCondition(stateName: string | null, isActive: boolean, value: string): void {
         assert(stateName === null || typeof isActive === "boolean");
-        assert(validState.indexOf(stateName) >= 0, "must have a valid state : " + stateName);
+        assert(validState.indexOf(stateName) >= 0, `must have a valid state : ${stateName}`);
 
-        const oldState = this.limitState.getCurrentState();
-        const oldActive = this.activeState.getValue();
+        const _oldState = this.$10.limitState.getCurrentState();
+        const _oldActive = this.activeState.getValue();
 
         if (stateName) {
-            this.limitState.setState(stateName);
+            this.$10.limitState.setState(stateName);
         } else {
             assert(stateName === null);
-            this.limitState.setState(stateName);
+            this.$10.limitState.setState(stateName);
         }
         super._signalNewCondition(stateName, isActive, value);
     }
 
     public _setStateBasedOnInputValue(value: number): void {
-        assert(isFinite(value));
+        assert(Number.isFinite(value));
         let isActive = false;
 
         let state = null;
 
-        const oldState = this.limitState.getCurrentState();
+        const oldState = this.$10.limitState.getCurrentState();
 
         if (this.highHighLimit && this.getHighHighLimit() < value) {
             state = "HighHigh";
@@ -109,3 +104,6 @@ export class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExc
         }
     }
 }
+
+export type UAExclusiveLimitAlarmImpl = UAExclusiveLimitAlarmImplBase & UAExclusiveLimitAlarmEx;
+export const UAExclusiveLimitAlarmImpl = UAExclusiveLimitAlarmImplBase as unknown as new () => UAExclusiveLimitAlarmImpl;

package/src/alarms_and_conditions/ua_exclusive_rate_of_change_alarm_impl.ts

@@ -1,8 +1,8 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { UAExclusiveRateOfChangeAlarm_Base } from "node-opcua-nodeset-ua";
-import { UAExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
+import type { UAExclusiveRateOfChangeAlarm_Base } from "node-opcua-nodeset-ua";
+import type { UAExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
 import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
 
 export interface UAExclusiveRateOfChangeAlarmEx
@@ -19,10 +19,7 @@ export interface UAExclusiveRateOfChangeAlarmEx
             | "silenceState"
             | "suppressedState"
         >,
-        UAExclusiveLimitAlarmEx {
-    on(eventName: string, eventHandler: any): this;
-    once(eventName: string, eventHandler: any): this;
-}
+        UAExclusiveLimitAlarmEx {}
 export class UAExclusiveRateOfChangeAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveRateOfChangeAlarmEx {
     /** empty interface */
 }

package/src/alarms_and_conditions/ua_limit_alarm_impl.ts

@@ -1,28 +1,18 @@
-/* eslint-disable max-statements */
-/**
- * @module node-opcua-address-space.AlarmsAndConditions
- */
-import { UAEventType, UAVariable } from "node-opcua-address-space-base";
+import type { UAEventType, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 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 { StatusCode, StatusCodes } from "node-opcua-status-code";
-import { DataType, VariantOptions } from "node-opcua-variant";
-import { UAShelvedStateMachineEx } from "../../source/interfaces/state_machine/ua_shelved_state_machine_ex";
-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 type { NodeId } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
+import { DataType, type VariantOptions } from "node-opcua-variant";
+import type { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import type { UALimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_limit_alarm_ex";
+import type { NamespacePrivate } from "../namespace_private";
+import { UAAlarmConditionImplBase } from "./ua_alarm_condition_impl";
 
 const warningLog = make_warningLog("AlarmsAndConditions");
 
-export declare interface UALimitAlarmImpl extends UALimitAlarmEx, UAAlarmConditionImpl {
-    on(eventName: string, eventHandler: any): this;
-    once(eventName: string, eventHandler: any): this;
-}
-
 const uaLimitAlarmInputSupportedDataType: DataType[] = [
     DataType.Double,
     DataType.Float,
@@ -34,12 +24,7 @@ const uaLimitAlarmInputSupportedDataType: DataType[] = [
     DataType.UInt32
 ];
 
-export interface UALimitAlarmImpl extends UALimitAlarmEx {
-    shelvingState?: UAShelvedStateMachineEx;
-}
-export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAlarmEx {
-    /**
-     */
+export class UALimitAlarmImplBase extends UAAlarmConditionImplBase {
     public static instantiate(
         namespace: NamespacePrivate,
         limitAlarmTypeId: UAEventType | NodeId | string,
@@ -50,36 +35,33 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
 
         // must provide a inputNode
         // xx assert(Object.prototype.hasOwnProperty.call(options,"conditionOf")); // must provide a conditionOf
-        assert(
-            Object.prototype.hasOwnProperty.call(options, "inputNode"),
-            "UALimitAlarm.instantiate: options must provide the inputNode"
-        );
+        assert(Object.hasOwn(options, "inputNode"), "UALimitAlarm.instantiate: options must provide the inputNode");
 
         options.optionals = options.optionals || [];
         let count = 0;
-        if (Object.prototype.hasOwnProperty.call(options, "highHighLimit")) {
+        if (Object.hasOwn(options, "highHighLimit")) {
             options.optionals.push("HighHighLimit");
             options.optionals.push("HighHighState");
             count++;
         }
-        if (Object.prototype.hasOwnProperty.call(options, "highLimit")) {
+        if (Object.hasOwn(options, "highLimit")) {
             options.optionals.push("HighLimit");
             options.optionals.push("HighState");
             count++;
         }
-        if (Object.prototype.hasOwnProperty.call(options, "lowLimit")) {
+        if (Object.hasOwn(options, "lowLimit")) {
             options.optionals.push("LowLimit");
             options.optionals.push("LowState");
             count++;
         }
-        if (Object.prototype.hasOwnProperty.call(options, "lowLowLimit")) {
+        if (Object.hasOwn(options, "lowLowLimit")) {
             options.optionals.push("LowLowLimit");
             options.optionals.push("LowLowState");
             count++;
         }
 
         // xx assert(options.optionals,"must provide an optionals");
-        const alarmNode = UAAlarmConditionImpl.instantiate(namespace, limitAlarmTypeId, options, data) as UALimitAlarmImpl;
+        const alarmNode = UAAlarmConditionImplBase.instantiate(namespace, limitAlarmTypeId, options, data) as UALimitAlarmImpl;
         Object.setPrototypeOf(alarmNode, UALimitAlarmImpl.prototype);
 
         assert(alarmNode.conditionOfNode() !== null);
@@ -104,7 +86,7 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
             throw new Error("at least one limit is required");
         }
 
-        const dataType = addressSpace.findCorrespondingBasicDataType(options.inputNode.dataType);
+        const dataType = addressSpace.findCorrespondingBasicDataType(inputNode.dataType);
 
         if (-1 === uaLimitAlarmInputSupportedDataType.indexOf(dataType)) {
             const message = `UALimitAlarm.instantiate: inputNode must be of type ${uaLimitAlarmInputSupportedDataType
@@ -114,16 +96,16 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
             throw new Error(message);
         }
 
-        if (Object.prototype.hasOwnProperty.call(options, "highHighLimit") && options.highHighLimit !== undefined) {
-            alarmNode.setHighHighLimit(options.highHighLimit!);
+        if (Object.hasOwn(options, "highHighLimit") && options.highHighLimit !== undefined) {
+            alarmNode.setHighHighLimit(options.highHighLimit);
         }
-        if (Object.prototype.hasOwnProperty.call(options, "highLimit")) {
+        if (Object.hasOwn(options, "highLimit")) {
             alarmNode.setHighLimit(options.highLimit);
         }
-        if (Object.prototype.hasOwnProperty.call(options, "lowLimit")) {
+        if (Object.hasOwn(options, "lowLimit")) {
             alarmNode.setLowLimit(options.lowLimit);
         }
-        if (Object.prototype.hasOwnProperty.call(options, "lowLowLimit") && options.lowLowLimit != undefined) {
+        if (Object.hasOwn(options, "lowLowLimit") && options.lowLowLimit !== undefined) {
             alarmNode.setLowLowLimit(options.lowLowLimit);
         }
 
@@ -143,103 +125,87 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
         return alarmNode;
     }
 
-    /**
-     */
+    private get $8() {
+        return this as unknown as UALimitAlarmEx;
+    }
+
     public getHighHighLimit(): number {
-        if (!this.highHighLimit) {
+        if (!this.$8.highHighLimit) {
             throw new Error("Alarm do not expose highHighLimit");
         }
-        return this.highHighLimit.readValue().value.value;
+        return this.$8.highHighLimit.readValue().value.value;
     }
 
-    /**
-     */
     public getHighLimit(): number {
-        if (!this.highLimit) {
+        if (!this.$8.highLimit) {
             throw new Error("Alarm do not expose highLimit");
         }
-        return this.highLimit.readValue().value.value;
+        return this.$8.highLimit.readValue().value.value;
     }
 
-    /**
-     */
     public getLowLimit(): number {
-        if (!this.lowLimit) {
+        if (!this.$8.lowLimit) {
             throw new Error("Alarm do not expose lowLimit");
         }
-        return this.lowLimit.readValue().value.value;
+        return this.$8.lowLimit.readValue().value.value;
     }
 
-    /**
-     */
     public getLowLowLimit(): number {
-        if (!this.lowLowLimit) {
+        if (!this.$8.lowLowLimit) {
             throw new Error("Alarm do not expose lowLowLimit");
         }
-        return this.lowLowLimit.readValue().value.value;
+        return this.$8.lowLowLimit.readValue().value.value;
     }
 
-    /**
-     */
     public setHighHighLimit(value: number): void {
-        if (!this.highHighLimit) {
+        if (!this.$8.highHighLimit) {
             throw new Error("LimitAlarm instance must expose the optional HighHighLimit property");
         }
-        this.highHighLimit.setValueFromSource({ dataType: DataType.Double, value });
+        this.$8.highHighLimit.setValueFromSource({ dataType: DataType.Double, value });
     }
 
-    /**
-     */
     public setHighLimit(value: number): void {
-        if (!this.highLimit) {
+        if (!this.$8.highLimit) {
             throw new Error("LimitAlarm instance must expose the optional HighLimit property");
         }
-        this.highLimit.setValueFromSource({ dataType: DataType.Double, value });
+        this.$8.highLimit.setValueFromSource({ dataType: DataType.Double, value });
     }
 
-    /**
-     */
     public setLowLimit(value: number): void {
-        if (!this.lowLimit) {
+        if (!this.$8.lowLimit) {
             throw new Error("LimitAlarm instance must expose the optional LowLimit property");
         }
-        this.lowLimit.setValueFromSource({ dataType: DataType.Double, value });
+        this.$8.lowLimit.setValueFromSource({ dataType: DataType.Double, value });
     }
-
-    /**
-     */
     public setLowLowLimit(value: number): void {
-        if (!this.lowLowLimit) {
+        if (!this.$8.lowLowLimit) {
             throw new Error("LimitAlarm instance must expose the optional LowLowLimit property");
         }
-        this.lowLowLimit.setValueFromSource({ dataType: DataType.Double, value });
+        this.$8.lowLowLimit.setValueFromSource({ dataType: DataType.Double, value });
     }
 
     protected _onInputDataValueChange(dataValue: DataValue): void {
         assert(dataValue instanceof DataValue);
 
-        if (
-            dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData) &&
-            dataValue.statusCode.equals(StatusCodes.UncertainInitialValue)
-        ) {
+        if (dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData)) {
             // we are not ready yet to use the input node value
             return;
         }
-        if (dataValue.statusCode.isNotGood()) {
-            // what shall we do ?
-            this._signalNewCondition(null);
+        if (dataValue.statusCode.isNotGood() && !dataValue.statusCode.equals(StatusCodes.UncertainInitialValue)) {
+            // genuinely bad status (not the initial uncertain state) → no specific limit state, alarm inactive
+            this._signalNewCondition(null, false, "Input node value is not good");
             return;
         }
         if (dataValue.value.dataType === DataType.Null) {
-            // what shall we do ?
-            this._signalNewCondition(null);
+            // input not yet set → no specific limit state, alarm inactive
+            this._signalNewCondition(null, false, "Input node value is null");
             return;
         }
         const value = dataValue.value.value;
         this._setStateBasedOnInputValue(value);
     }
 
-    protected _setStateBasedOnInputValue(value: number): void {
+    protected _setStateBasedOnInputValue(_value: number): void {
         throw new Error("_setStateBasedOnInputValue must be overriden");
     }
 
@@ -248,17 +214,17 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
         /// Installing Limits monitored
         const _updateState = () => this.updateState();
 
-        if (this.highHighLimit) {
-            this.highHighLimit.on("value_changed", _updateState);
+        if (this.$8.highHighLimit) {
+            this.$8.highHighLimit.on("value_changed", _updateState);
         }
-        if (this.highLimit) {
-            this.highLimit.on("value_changed", _updateState);
+        if (this.$8.highLimit) {
+            this.$8.highLimit.on("value_changed", _updateState);
         }
-        if (this.lowLimit) {
-            this.lowLimit.on("value_changed", _updateState);
+        if (this.$8.lowLimit) {
+            this.$8.lowLimit.on("value_changed", _updateState);
         }
-        if (this.lowLowLimit) {
-            this.lowLowLimit.on("value_changed", _updateState);
+        if (this.$8.lowLowLimit) {
+            this.$8.lowLowLimit.on("value_changed", _updateState);
         }
     }
 
@@ -273,3 +239,6 @@ export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAla
         this._onInputDataValueChange(dataValue);
     }
 }
+
+export const UALimitAlarmImpl = UALimitAlarmImplBase as unknown as new () => UALimitAlarmImpl;
+export type UALimitAlarmImpl = UALimitAlarmImplBase & UALimitAlarmEx;