node-opcua-address-space 2.170.1 → 2.172.0

package/src/alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl.ts

@@ -2,16 +2,15 @@
  * @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 { NamespacePrivate } from "../namespace_private";
-import { AddressSpace } from "../address_space";
-import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
-import { UANonExclusiveDeviationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
+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 { InstallSetPointOptions } from "../../source/interfaces/alarms_and_conditions/install_setpoint_options";
+import type { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import type { UANonExclusiveDeviationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
+import type { NamespacePrivate } from "../namespace_private";
 import {
     DeviationAlarmHelper_getSetpointNodeNode,
     DeviationAlarmHelper_getSetpointValue,
@@ -19,20 +18,13 @@ import {
     DeviationAlarmHelper_onSetpointDataValueChange
 } 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;
-    once(eventName: string, eventHandler: any): this;
-    get addressSpace(): AddressSpace;
-}
+import { UANonExclusiveLimitAlarmImpl, UANonExclusiveLimitAlarmImplBase } from "./ua_non_exclusive_limit_alarm_impl";
 
-export class UANonExclusiveDeviationAlarmImpl extends UANonExclusiveLimitAlarmImpl implements UANonExclusiveDeviationAlarmEx {
+export class UANonExclusiveDeviationAlarmImplBase extends UANonExclusiveLimitAlarmImplBase {
     public static instantiate(
         namespace: NamespacePrivate,
         type: string | NodeId,
-        options: InstantiateLimitAlarmOptions,
+        options: InstantiateLimitAlarmOptions & InstallSetPointOptions,
         data?: Record<string, VariantOptions>
     ): UANonExclusiveDeviationAlarmImpl {
         const addressSpace = namespace.addressSpace;
@@ -44,7 +36,12 @@ export class UANonExclusiveDeviationAlarmImpl extends UANonExclusiveLimitAlarmIm
         }
         assert(type === nonExclusiveDeviationAlarmType.browseName.toString());
 
-        const alarm = UANonExclusiveLimitAlarmImpl.instantiate(namespace, type, options, data) as UANonExclusiveDeviationAlarmImpl;
+        const alarm = UANonExclusiveLimitAlarmImplBase.instantiate(
+            namespace,
+            type,
+            options,
+            data
+        ) as UANonExclusiveDeviationAlarmImpl;
         Object.setPrototypeOf(alarm, UANonExclusiveDeviationAlarmImpl.prototype);
 
         assert(alarm instanceof UANonExclusiveDeviationAlarmImpl);
@@ -56,29 +53,36 @@ export class UANonExclusiveDeviationAlarmImpl extends UANonExclusiveLimitAlarmIm
         return alarm;
     }
 
+    private get $13() {
+        return this as unknown as UANonExclusiveDeviationAlarmEx;
+    }
     public _setStateBasedOnInputValue(value: number): void {
         const setpointValue = this.getSetpointValue();
         if (setpointValue === null) {
             throw new Error("Cannot access setpoint Value");
         }
-        assert(isFinite(setpointValue), "expecting a valid setpoint value");
+        assert(Number.isFinite(setpointValue), "expecting a valid setpoint value");
         // call base class implementation
         super._setStateBasedOnInputValue(value - setpointValue);
     }
 
-    public getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined  {
-        return DeviationAlarmHelper_getSetpointNodeNode.call(this);
+    public getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined {
+        return DeviationAlarmHelper_getSetpointNodeNode.call(this.$13);
     }
 
     public getSetpointValue(): number | null {
-        return DeviationAlarmHelper_getSetpointValue.call(this);
+        return DeviationAlarmHelper_getSetpointValue.call(this.$13);
     }
 
     public _onSetpointDataValueChange(dataValue: DataValue): void {
-        DeviationAlarmHelper_onSetpointDataValueChange.call(this, dataValue);
+        DeviationAlarmHelper_onSetpointDataValueChange.call(this.$13, dataValue);
     }
 
-    public _install_setpoint(options: any): any {
-        return DeviationAlarmHelper_install_setpoint.call(this, options);
+    public _install_setpoint(options: InstallSetPointOptions): void {
+        DeviationAlarmHelper_install_setpoint.call(this.$13, options);
     }
 }
+
+export type UANonExclusiveDeviationAlarmImpl = UANonExclusiveDeviationAlarmImplBase & UANonExclusiveDeviationAlarmEx;
+export const UANonExclusiveDeviationAlarmImpl =
+    UANonExclusiveDeviationAlarmImplBase as unknown as new () => UANonExclusiveDeviationAlarmImpl;

package/src/alarms_and_conditions/ua_non_exclusive_limit_alarm_impl.ts

@@ -2,24 +2,29 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
+
+import type { BaseNode, UAEventType, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { NodeId } from "node-opcua-nodeid";
+import { NodeClass } from "node-opcua-data-model";
+import type { NodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import { VariantOptions } from "node-opcua-variant";
-import { UAEventType } from "node-opcua-address-space-base";
-import { NamespacePrivate } from "../namespace_private";
+import type { VariantOptions } from "node-opcua-variant";
+import type { ConditionInfo } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
+import type { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import type { UANonExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex";
+import type { NamespacePrivate } from "../namespace_private";
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
-import { UANonExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex";
-import { ConditionInfo } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
-import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
 import { ConditionInfoImpl } from "./condition_info_impl";
-import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+import { UALimitAlarmImpl, UALimitAlarmImplBase } from "./ua_limit_alarm_impl";
 
-export declare interface UANonExclusiveLimitAlarmImpl extends UANonExclusiveLimitAlarmEx, UALimitAlarmImpl {
-    on(eventName: string, eventHandler: any): this;
-    once(eventName: string, eventHandler: any): this;
+interface IState {
+    highHigh: boolean | "unset";
+    high: boolean | "unset";
+    low: boolean | "unset";
+    lowLow: boolean | "unset";
 }
-export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UANonExclusiveLimitAlarmEx {
+
+export class UANonExclusiveLimitAlarmImplBase extends UALimitAlarmImpl implements UANonExclusiveLimitAlarmEx {
     public static instantiate(
         namespace: NamespacePrivate,
         type: UAEventType | NodeId | string,
@@ -30,19 +35,19 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
 
         options.optionals = options.optionals || [];
 
-        if (Object.prototype.hasOwnProperty.call(options, "lowLowLimit")) {
+        if (Object.hasOwn(options, "lowLowLimit")) {
             options.optionals.push("LowLowLimit");
             options.optionals.push("LowLowState");
         }
-        if (Object.prototype.hasOwnProperty.call(options, "lowLimit")) {
+        if (Object.hasOwn(options, "lowLimit")) {
             options.optionals.push("LowLimit");
             options.optionals.push("LowState");
         }
-        if (Object.prototype.hasOwnProperty.call(options, "highLimit")) {
+        if (Object.hasOwn(options, "highLimit")) {
             options.optionals.push("HighLimit");
             options.optionals.push("HighState");
         }
-        if (Object.prototype.hasOwnProperty.call(options, "highHighLimit")) {
+        if (Object.hasOwn(options, "highHighLimit")) {
             options.optionals.push("HighHighLimit");
             options.optionals.push("HighHighState");
         }
@@ -50,7 +55,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
 
         /* c8 ignore next */
         if (!nonExclusiveAlarmType) {
-            throw new Error(" cannot find Alarm Condition Type for " + type);
+            throw new Error(` cannot find Alarm Condition Type for ${type}`);
         }
 
         const nonExclusiveLimitAlarmType = addressSpace.findEventType("NonExclusiveLimitAlarmType");
@@ -60,7 +65,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
         }
         // assert(type nonExclusiveLimitAlarmType.browseName.toString());
 
-        const alarm = UALimitAlarmImpl.instantiate(namespace, type, options, data) as UANonExclusiveLimitAlarmImpl;
+        const alarm = UALimitAlarmImplBase.instantiate(namespace, type, options, data) as UANonExclusiveLimitAlarmImpl;
         Object.setPrototypeOf(alarm, UANonExclusiveLimitAlarmImpl.prototype);
         assert(alarm instanceof UALimitAlarmImpl);
         assert(alarm instanceof UANonExclusiveLimitAlarmImpl);
@@ -72,7 +77,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
                 trueState: "LowLow active"
             });
             alarm.lowLowState.setValue(false);
-            assert(Object.prototype.hasOwnProperty.call(alarm, "lowLowLimit"));
+            assert(Object.hasOwn(alarm, "lowLowLimit"));
         }
         if (alarm.lowState) {
             _install_TwoStateVariable_machinery(alarm.lowState, {
@@ -80,7 +85,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
                 trueState: "Low active"
             });
             alarm.lowState.setValue(false);
-            assert(Object.prototype.hasOwnProperty.call(alarm, "lowLimit"));
+            assert(Object.hasOwn(alarm, "lowLimit"));
         }
         if (alarm.highState) {
             _install_TwoStateVariable_machinery(alarm.highState, {
@@ -88,7 +93,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
                 trueState: "High active"
             });
             alarm.highState.setValue(false);
-            assert(Object.prototype.hasOwnProperty.call(alarm, "highLimit"));
+            assert(Object.hasOwn(alarm, "highLimit"));
         }
         if (alarm.highHighState) {
             _install_TwoStateVariable_machinery(alarm.highHighState, {
@@ -96,7 +101,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
                 trueState: "HighHigh active"
             });
             alarm.highHighState.setValue(false);
-            assert(Object.prototype.hasOwnProperty.call(alarm, "highHighLimit"));
+            assert(Object.hasOwn(alarm, "highHighLimit"));
         }
 
         alarm.activeState.setValue(false);
@@ -110,7 +115,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
         state: string | null,
         isActive: boolean,
         value: string,
-        oldConditionInfo: ConditionInfo
+        _oldConditionInfo: ConditionInfo
     ): ConditionInfo {
         if (!isActive) {
             return new ConditionInfoImpl({
@@ -121,7 +126,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
             });
         } else {
             return new ConditionInfoImpl({
-                message: "Condition is " + value + " and state is " + state,
+                message: `Condition is ${value} and state is ${state}`,
                 quality: StatusCodes.Good,
                 retain: true,
                 severity: 150
@@ -129,16 +134,26 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
         }
     }
 
-    public _signalNewCondition2(states: { [key: string]: string }, isActive: boolean, value: string): void {
-        const alarm = this as any;
+    public _signalNewCondition2(states: IState, isActive: boolean, value: string): void {
+        const alarm = this as BaseNode;
 
         if (typeof states === "string") {
             return;
         }
 
-        function _install(name: string) {
+        function _install(name: keyof IState) {
             if (states[name] !== "unset") {
-                alarm[name + "State"].setValue(states[name]);
+                // browseName is PascalCase (e.g. HighHighState) while the IState key is camelCase
+                const browseName = `${name[0].toUpperCase()}${name.slice(1)}State`;
+                const state = alarm.getChildByName(browseName) as
+                    | (UAVariable & {
+                          setValue(value: boolean): void;
+                      })
+                    | null;
+                if (!state || state.nodeClass !== NodeClass.Variable || !state.setValue) {
+                    throw new Error(`expecting a ${browseName} component`);
+                }
+                state.setValue(states[name]);
             }
         }
 
@@ -149,7 +164,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
 
         // build-up state string
         let state_str = Object.keys(states)
-            .map((s: string) => (states[s] ? s : null))
+            .map((s) => (states[s as keyof IState] ? s : null))
             .filter((a) => a !== null)
             .join(";"); //
 
@@ -158,21 +173,24 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
         UALimitAlarmImpl.prototype._signalNewCondition.call(this, state_str, isActive, value);
     }
 
+    private get $12() {
+        return this as unknown as UANonExclusiveLimitAlarmEx;
+    }
     protected _setStateBasedOnInputValue(value: number): void {
-        assert(isFinite(value), "expecting a valid value here");
+        assert(Number.isFinite(value), "expecting a valid value here");
 
         let isActive = false;
 
-        const states: any = {
-            highHigh: this.highHighState ? this.highHighState.getValue() : "unset",
-            high: this.highState ? this.highState.getValue() : "unset",
-            low: this.lowState ? this.lowState.getValue() : "unset",
-            lowLow: this.lowLowState ? this.lowLowState.getValue() : "unset"
+        const states: IState = {
+            highHigh: this.$12.highHighState ? this.$12.highHighState.getValue() : "unset",
+            high: this.$12.highState ? this.$12.highState.getValue() : "unset",
+            low: this.$12.lowState ? this.$12.lowState.getValue() : "unset",
+            lowLow: this.$12.lowLowState ? this.$12.lowLowState.getValue() : "unset"
         };
 
         let count = 0;
 
-        function ___p(stateName: string, func_value: () => boolean) {
+        function ___p(stateName: keyof typeof states, func_value: () => boolean) {
             if (states[stateName] !== "unset") {
                 const val = func_value();
                 isActive = isActive || val;
@@ -201,3 +219,6 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
         }
     }
 }
+
+export type UANonExclusiveLimitAlarmImpl = UANonExclusiveLimitAlarmImplBase & UANonExclusiveLimitAlarmEx;
+export const UANonExclusiveLimitAlarmImpl = UANonExclusiveLimitAlarmImplBase as unknown as new () => UANonExclusiveLimitAlarmImpl;

package/src/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -1,20 +1,20 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { INamespace, UAVariable, UAVariableT } from "node-opcua-address-space-base";
+import type { 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 type { DataValue } from "node-opcua-data-value";
+import { NodeId, type NodeIdLike } from "node-opcua-nodeid";
 
-import { UAOffNormalAlarm_Base } from "node-opcua-nodeset-ua";
+import type { UAOffNormalAlarm_Base } from "node-opcua-nodeset-ua";
 import { isNullOrUndefined } 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 { DataType, type VariantOptions } from "node-opcua-variant";
+import type { InstantiateOffNormalAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
+import type { UADiscreteAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
+import type { AddressSpacePrivate } from "../address_space_private";
+import { UADiscreteAlarmImplBase } from "./ua_discrete_alarm_impl";
 
-function isEqual(value1: any, value2: any) {
+function isEqual(value1: unknown, value2: unknown): boolean {
     return value1 === value2;
 }
 
@@ -39,22 +39,20 @@ export declare interface UAOffNormalAlarmEx
     setNormalStateValue(value: NodeIdLike): void;
 }
 
-export declare interface UAOffNormalAlarmImpl extends UAOffNormalAlarmEx, UADiscreteAlarmImpl {
-    on(eventName: string, eventHandler: any): this;
-    once(eventName: string, eventHandler: any): this;
-}
+
+const $ = (instance: UAOffNormalAlarmImplBase): UAOffNormalAlarmEx => instance as unknown as UAOffNormalAlarmEx;
 /**
  * The OffNormalAlarmType is a specialization of the DiscreteAlarmType intended to represent a
  * discrete Condition that is considered to be not normal.
  * This sub type is usually used to indicate that a discrete value is in an Alarm state, it is active as
  * long as a non-normal value is present.
  */
-export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNormalAlarmEx {
+export class UAOffNormalAlarmImplBase extends UADiscreteAlarmImplBase {
     /**
      * When the value of inputNode doesn't match the normalState node value, then the alarm is raised.
      *
      */
-    public static instantiate<T, DT extends DataType>(
+    public static instantiate<_T, _DT extends DataType>(
         namespace: INamespace,
         limitAlarmTypeId: string | NodeId,
         options: InstantiateOffNormalAlarmOptions,
@@ -68,12 +66,12 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
             throw new Error("cannot find offNormalAlarmType");
         }
 
-        assert(Object.prototype.hasOwnProperty.call(options, "inputNode"), "must provide inputNode"); // must provide a inputNode
-        assert(Object.prototype.hasOwnProperty.call(options, "normalState"), "must provide a normalState Node"); // must provide a inputNode
+        assert(Object.hasOwn(options, "inputNode"), "must provide inputNode"); // must provide a inputNode
+        assert(Object.hasOwn(options, "normalState"), "must provide a normalState Node"); // must provide a inputNode
         options.optionals = options.optionals || [];
 
-        assert(Object.prototype.hasOwnProperty.call(options, "inputNode"), "must provide inputNode"); // must provide a inputNode
-        const alarmNode = UADiscreteAlarmImpl.instantiate(namespace, limitAlarmTypeId, options, data) as UAOffNormalAlarmImpl;
+        assert(Object.hasOwn(options, "inputNode"), "must provide inputNode"); // must provide a inputNode
+        const alarmNode = UADiscreteAlarmImplBase.instantiate(namespace, limitAlarmTypeId, options, data) as UAOffNormalAlarmImpl;
         Object.setPrototypeOf(alarmNode, UAOffNormalAlarmImpl.prototype);
 
         /**
@@ -107,7 +105,7 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
             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*/) => {
+            alarmNode.normalState.on("value_changed", (_newDataValue, _indexRange) => {
                 // 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
@@ -137,8 +135,11 @@ 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.
 
+    private get $4(): UAOffNormalAlarmEx {
+        return this as unknown as UAOffNormalAlarmEx;
+    }
     public getNormalStateNode(): UAVariableT<NodeId, DataType.NodeId> | null {
-        const nodeId = this.normalState.readValue().value.value;
+        const nodeId = this.$4.normalState.readValue().value.value;
         const node = this.addressSpace.findNode(nodeId) as UAVariableT<NodeId, DataType.NodeId>;
         if (!node) {
             return null;
@@ -158,13 +159,13 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
 
     /**
      */
-    public setNormalStateValue(value: NodeIdLike): void {
-        const normalStateNode = this.getNormalStateNode();
+    public setNormalStateValue(_value: NodeIdLike): void {
+        const _normalStateNode = this.getNormalStateNode();
         throw new Error("Not Implemented yet");
     }
 
     public updateAlarmState(isActive: boolean, message: string) {
-        if (isActive === this.activeState.getValue()) {
+        if (isActive === $(this).activeState.getValue()) {
             // no change => ignore !
             return;
         }
@@ -176,9 +177,9 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
         }
     }
 
-    private _mayBe_updateAlarmState(normalStateValue?: any, inputValue?: any): void {
+    _mayBe_updateAlarmState(normalStateValue?: NodeId | null, inputValue?: unknown): void {
         if (isNullOrUndefined(normalStateValue) || isNullOrUndefined(inputValue)) {
-            this.activeState.setValue(false);
+            $(this).activeState.setValue(false);
             return;
         }
         const isActive = !isEqual(normalStateValue, inputValue);
@@ -213,3 +214,6 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
         this._mayBe_updateAlarmState(normalStateValue, inputValue);
     }
 }
+
+export type UAOffNormalAlarmImpl = UAOffNormalAlarmImplBase & UAOffNormalAlarmEx;
+export const UAOffNormalAlarmImpl = UAOffNormalAlarmImplBase as unknown as new () => UAOffNormalAlarmImpl;

package/src/alarms_and_conditions/ua_system_off_normal_alarm_impl.ts

@@ -1,11 +1,11 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { INamespace } from "node-opcua-address-space-base";
-import { NodeId } from "node-opcua-nodeid";
-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";
+import type { INamespace } from "node-opcua-address-space-base";
+import type { NodeId } from "node-opcua-nodeid";
+import type { VariantOptions } from "node-opcua-variant";
+import type { InstantiateOffNormalAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
+import { UAOffNormalAlarmImpl, UAOffNormalAlarmImplBase } from "./ua_off_normal_alarm_impl";
 
 /**
  *
@@ -21,6 +21,6 @@ export class UASystemOffNormalAlarmImpl extends UAOffNormalAlarmImpl {
         options: InstantiateOffNormalAlarmOptions,
         data?: Record<string, VariantOptions>
     ): UASystemOffNormalAlarmImpl {
-        return UAOffNormalAlarmImpl.instantiate(namespace, limitAlarmTypeId, options, data) as UASystemOffNormalAlarmImpl;
+        return UAOffNormalAlarmImplBase.instantiate(namespace, limitAlarmTypeId, options, data) as UASystemOffNormalAlarmImpl;
     }
 }

package/src/apply_condition_refresh.ts

@@ -1,27 +1,26 @@
-import { BaseNode, UAObject } from "node-opcua-address-space-base";
+import type { UAObject, UAVariable } from "../source";
 import { UAConditionImpl } from "./alarms_and_conditions/ua_condition_impl";
-import { BaseNodeImpl } from "./base_node_impl";
-import { UAObjectImpl } from "./ua_object_impl";
+import type { UAObjectImpl } from "./ua_object_impl";
 
-export type ConditionRefreshCache = Map<string,UAObject>;
-export function apply_condition_refresh(this: BaseNodeImpl, cache?: ConditionRefreshCache): void {
+export type ConditionRefreshCache = Map<string, UAObjectImpl>;
+export function apply_condition_refresh(this: UAObject | UAVariable, cache?: ConditionRefreshCache): void {
     // visit all notifiers recursively
     cache = cache || new Map();
     const notifiers = this.getNotifiers();
     const eventSources = this.getEventSources();
-
+    
     const conditions = this.findReferencesAsObject("HasCondition", true);
     for (const condition of conditions) {
         if (condition instanceof UAConditionImpl) {
             condition._resend_conditionEvents();
         }
     }
-    const arr = ([] as UAObjectImpl[]).concat(notifiers as UAObjectImpl[], eventSources as UAObjectImpl[]);
+    const arr = [...notifiers, ...eventSources] as UAObjectImpl[];
 
     for (const notifier of arr) {
         const key = notifier.nodeId.toString();
         if (!cache.has(key)) {
-            cache.set(key,notifier);
+            cache.set(key, notifier);
             if (notifier._conditionRefresh) {
                 notifier._conditionRefresh(cache);
             }