node-opcua-address-space 2.169.0 → 2.172.0

package/src/state_machine/finite_state_machine.ts

@@ -2,43 +2,44 @@
  * @module node-opcua-address-space
  */
 import chalk from "chalk";
-import { UAState, UAStateVariable, UATransition, UATransition_Base, UATransitionVariable } from "node-opcua-nodeset-ua";
+import type { BaseNode, UAMethod, UAObject, UAObjectType, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { ObjectTypeIds } from "node-opcua-constants";
 import {
+    AttributeIds,
     BrowseDirection,
     coerceLocalizedText,
     coerceQualifiedName,
-    LocalizedText,
     NodeClass,
-    QualifiedName
+    type QualifiedName
 } from "node-opcua-data-model";
-import { AttributeIds } from "node-opcua-data-model";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { NodeId, sameNodeId } from "node-opcua-nodeid";
+import type { UAState, UATransition } from "node-opcua-nodeset-ua";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
-import { UAString } from "node-opcua-basic-types";
-import { BaseNode, UAMethod, UAObject, UAObjectType, UAProperty, UAVariable, UAVariableT } from "node-opcua-address-space-base";
-import { registerNodePromoter } from "../../source/loader/register_node_promoter";
-
-import {
-    UAStateMachineEx,
+import type {
     TransitionSelector,
+    UAStateMachineEx,
     UAStateMachineTypeHelper
 } from "../../source/interfaces/state_machine/ua_state_machine_type";
-import { UAObjectImpl } from "../ua_object_impl";
-import { UATransitionEx } from "../../source/interfaces/state_machine/ua_transition_ex";
+import type { UATransitionEx } from "../../source/interfaces/state_machine/ua_transition_ex";
+import { registerNodePromoter } from "../../source/loader/register_node_promoter";
 import { BaseNodeImpl } from "../base_node_impl";
+import { UAObjectImpl } from "../ua_object_impl";
 import { UAObjectTypeImpl } from "../ua_object_type_impl";
 
 const warningLog = make_warningLog(__filename);
 
 const doDebug = false;
-const debugLog = make_debugLog(__filename);
+const debugLog = make_debugLog(__filename); 
+
+export class UATransitionImplBase extends BaseNodeImpl {
+    /* intentionnaly empty */
+}
+export type UATransitionImpl = UATransitionImplBase & UATransitionEx;
+export const  UATransitionImpl = UATransitionImplBase as unknown as new () => UATransitionImpl;
 
-export declare interface UATransitionImpl extends UATransition, UATransitionEx {}
-export class UATransitionImpl implements UATransition, UATransitionEx {}
 
 function getComponentOfType(typeDef: UAObjectType, typedefinition: UAObjectType): UAObject[] {
     const get = (typeDef: UAObjectType) =>
@@ -61,13 +62,7 @@ function getComponentOfType(typeDef: UAObjectType, typedefinition: UAObjectType)
     return components_parts as UAObject[];
 }
 
-export interface UAStateMachineImpl {
-    currentState: UAStateVariable<LocalizedText>;
-    lastTransition?: UATransitionVariable<LocalizedText>;
 
-    // Extra
-    _currentStateNode: UAState | null;
-}
 
 const defaultPredicate = (transitions: UATransition[], fromState: UAState, toState: UAState) => {
     if (transitions.length === 0) {
@@ -123,19 +118,20 @@ export function getFiniteStateMachineTypeTransitions(uaFiniteStateMachineType: U
 
 export function getFiniteStateMachineTypeStateByName(uaFiniteStateMachineType: UAObjectType, stateName: string): UAState | null {
     let states = getFiniteStateMachineTypeStates(uaFiniteStateMachineType);
-    states = states.filter((s: any) => {
+    states = states.filter((s) => {
         return s.browseName.name === stateName;
     });
     assert(states.length <= 1);
-    return states.length === 1 ? (states[0] as any as UAState) : null;
+    return states.length === 1 ? (states[0]) : null;
 }
 
+const $ = (uaObject: UAStateMachineImplBase) =>  uaObject as  unknown as UAStateMachineEx;
 /*
  *
  * @class StateMachine
  *
  */
-export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx {
+export class UAStateMachineImplBase extends UAObjectImpl {
     public getStates(): UAState[] {
         const typeDef = this.typeDefinitionObj;
         return getFiniteStateMachineTypeStates(typeDef);
@@ -169,7 +165,8 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
     get initialState(): UAState | null {
         const addressSpace = this.addressSpace;
 
-        const initialStateType = addressSpace.findObjectType("InitialStateType")!;
+        const initialStateType = addressSpace.findObjectType("InitialStateType");
+        if (!initialStateType) throw new Error("cannot find InitialStateType");
         const typeDef = this.typeDefinitionObj;
 
         const comp = getComponentOfType(typeDef, initialStateType);
@@ -190,9 +187,9 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
             return node;
         } else if (node instanceof NodeId) {
             const addressSpace = this.addressSpace;
-            return addressSpace.findNode(node) as BaseNode;
+            return addressSpace.findNode(node);
         } else if (typeof node === "string") {
-            return this.getStateByName(node) as any as BaseNode;
+            return this.getStateByName(node);
         }
         return null;
     }
@@ -204,7 +201,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
         if (!this.currentStateNode) {
             return true;
         }
-        const n = this.currentState.readValue();
+        const _n = $(this).currentState.readValue();
 
         // to be executed there must be a transition from currentState to toState
         const transition = this.findTransitionNode(this.currentStateNode, toStateNode, predicate);
@@ -247,18 +244,18 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
         }
 
         const stateType = addressSpace.findObjectType("StateType");
-        
+
         // c8 ignore next
         if (!stateType) {
             throw new Error("Cannot find StateType");
         }
-        assert((_fromStateNode.typeDefinitionObj as any).isSubtypeOf(stateType));
-        assert((_toStateNode.typeDefinitionObj as any).isSubtypeOf(stateType));
+        assert(_fromStateNode.typeDefinitionObj.isSubtypeOf(stateType));
+        assert(_toStateNode.typeDefinitionObj.isSubtypeOf(stateType));
 
         let transitions = _fromStateNode.findReferencesAsObject("FromState", false) as UATransitionImpl[];
 
-        transitions = transitions.filter((transition: any) => {
-            assert(transition.toStateNode.nodeClass === NodeClass.Object);
+        transitions = transitions.filter((transition) => {
+            assert(transition.toStateNode?.nodeClass === NodeClass.Object);
             return transition.toStateNode === _toStateNode;
         });
         if (transitions.length === 0) {
@@ -278,7 +275,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
     }
 
     public get currentStateNode(): UAState | null {
-        return this._currentStateNode;
+        return $(this)._currentStateNode;
     }
 
     /**
@@ -286,7 +283,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
      * @type BaseNode
      */
     public set currentStateNode(value: UAState | null) {
-        this._currentStateNode = value;
+        $(this)._currentStateNode = value;
     }
 
     /**
@@ -305,7 +302,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
     public setState(toStateNode: string | UAState | null, predicate?: TransitionSelector): void {
         if (!toStateNode) {
             this.currentStateNode = null;
-            this.currentState.setValueFromSource({ dataType: DataType.LocalizedText, value: null }, StatusCodes.BadStateNotActive);
+            $(this).currentState.setValueFromSource({ dataType: DataType.LocalizedText, value: null }, StatusCodes.BadStateNotActive);
             return;
         }
 
@@ -313,19 +310,19 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
             const state = this.getStateByName(toStateNode);
             // c8 ignore next
             if (!state) {
-                throw new Error("Cannot find state with name " + toStateNode);
+                throw new Error(`Cannot find state with name ${toStateNode}`);
             }
             toStateNode = state;
         }
         const fromStateNode = this.currentStateNode;
 
-        toStateNode = this._coerceNode(toStateNode) as any as UAState;
+        toStateNode = this._coerceNode(toStateNode) as UAState;
         assert(toStateNode.nodeClass === NodeClass.Object);
 
-        this.currentState.setValueFromSource(
+        $(this).currentState.setValueFromSource(
             {
                 dataType: DataType.LocalizedText,
-                value: coerceLocalizedText(toStateNode.displayName[0] || toStateNode.browseName.name!)
+                value: coerceLocalizedText(toStateNode.displayName[0] || toStateNode.browseName.name  || "")
             },
             StatusCodes.Good
         );
@@ -333,7 +330,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
         this.currentStateNode = toStateNode;
 
         const applyCurrentStateOptionalProps = () => {
-            const uaId = this.currentState.getPropertyByName("Id")! as UAVariable;
+            const uaId = $(this).currentState.getPropertyByName("Id") as UAVariable;
             if (uaId) {
                 uaId.setValueFromSource({
                     dataType: DataType.NodeId,
@@ -341,7 +338,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                 });
             }
 
-            const uaName = this.currentState.getPropertyByName("Name")! as UAVariable;
+            const uaName = $(this).currentState.getPropertyByName("Name") as UAVariable;
             if (uaName) {
                 uaName.setValueFromSource({
                     dataType: DataType.QualifiedName,
@@ -349,22 +346,22 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                 });
             }
 
-            const uaNumber = this.currentState.getPropertyByName("Number")! as UAVariable;
+            const uaNumber = $(this).currentState.getPropertyByName("Number") as UAVariable;
             if (uaNumber) {
                 if (!this.currentStateNode) {
-                    const n = uaNumber.setValueFromSource({
+                    const _n = uaNumber.setValueFromSource({
                         dataType: DataType.UInt32,
                         value: 0 // may be wrong !
                     });
                 } else {
-                    const n = uaNumber.setValueFromSource({
+                    const _n = uaNumber.setValueFromSource({
                         dataType: DataType.UInt32,
                         value: this.currentStateNode.stateNumber.readValue().value.value
                     });
                 }
             }
 
-            const uaEffectiveDisplayName = this.currentState.getPropertyByName("EffectiveDisplayName")! as UAVariable;
+            const uaEffectiveDisplayName = $(this).currentState.getPropertyByName("EffectiveDisplayName") as UAVariable;
             if (uaEffectiveDisplayName) {
                 uaEffectiveDisplayName.setValueFromSource({
                     dataType: DataType.LocalizedText,
@@ -404,13 +401,15 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                 | null;
             if (!ms) return;
             if (ms.nodeClass !== NodeClass.Object) return;
-            const stateMachineType = this.addressSpace.findObjectType("StateMachineType")!;
+            const stateMachineType = this.addressSpace.findObjectType("StateMachineType");
+            if (!stateMachineType) throw new Error("cannot find StateMachineType");
+
             if (!ms.typeDefinitionObj.isSubtypeOf(stateMachineType)) return;
 
             const find = (node: UAObjectType, browseName: QualifiedName): UAObject | UAVariable | null => {
                 const r = node
                     .getAggregates()
-                    .filter((x) => x.browseName.name! === browseName.name && x.namespaceIndex === browseName.namespaceIndex);
+                    .filter((x) => x.browseName.name === browseName.name && x.namespaceIndex === browseName.namespaceIndex);
                 if (r.length === 0) {
                     // look in subType
                     const subType = node.subtypeOfObj;
@@ -442,7 +441,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                 if (uaLastTransitionMain) {
                     const uaEffectiveTransitionTimeMain = uaLastTransitionMain.getPropertyByName(
                         "EffectiveTransitionTime"
-                    )! as UAVariable;
+                    ) as UAVariable;
                     if (uaEffectiveTransitionTimeMain) {
                         uaEffectiveTransitionTimeMain.setValueFromSource({
                             dataType: DataType.DateTime,
@@ -462,13 +461,13 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                     uaLastTransition.setValueFromSource(
                         {
                             dataType: DataType.LocalizedText,
-                            value: transitionNode.displayName[0] || transitionNode.browseName.name!
+                            value: transitionNode.displayName[0] || transitionNode.browseName.name || ""
                         },
                         StatusCodes.Good,
                         transitionTime
                     );
 
-                    const uaId = uaLastTransition.getPropertyByName("Id")! as UAVariable;
+                    const uaId = uaLastTransition.getPropertyByName("Id") as UAVariable;
                     if (uaId) {
                         uaId.setValueFromSource({
                             dataType: DataType.NodeId,
@@ -476,7 +475,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                         });
                     }
 
-                    const uaLastTransitionTime = uaLastTransition.getPropertyByName("TransitionTime")! as UAVariable;
+                    const uaLastTransitionTime = uaLastTransition.getPropertyByName("TransitionTime") as UAVariable;
                     if (uaLastTransitionTime) {
                         uaLastTransitionTime.setValueFromSource({
                             dataType: DataType.DateTime,
@@ -489,7 +488,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                      * SubA and SubB, then the TransitionTime stays at the point in time where StateA became active whereas the *
                      * EffectiveTransitionTime changes with each change of a sub-state.
                      */
-                    const uaEffectiveTransitionTime = uaLastTransition.getPropertyByName("EffectiveTransitionTime")! as UAVariable;
+                    const uaEffectiveTransitionTime = uaLastTransition.getPropertyByName("EffectiveTransitionTime") as UAVariable;
                     if (uaEffectiveTransitionTime) {
                         uaEffectiveTransitionTime.setValueFromSource({
                             dataType: DataType.DateTime,
@@ -497,14 +496,14 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                         });
                     }
                     //
-                    const uaName = uaLastTransition.getPropertyByName("Name")! as UAVariable;
+                    const uaName = uaLastTransition.getPropertyByName("Name") as UAVariable;
                     if (uaName) {
                         uaName.setValueFromSource({
                             dataType: DataType.QualifiedName,
                             value: transitionNode.browseName
                         });
                     }
-                    const uaNumber = uaLastTransition.getPropertyByName("Number")! as UAVariable;
+                    const uaNumber = uaLastTransition.getPropertyByName("Number") as UAVariable;
                     if (uaNumber) {
                         uaNumber.setValueFromSource({
                             dataType: DataType.UInt32,
@@ -557,7 +556,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                 if (doDebug) {
                     const f = fromStateNode.browseName.toString();
                     const t = toStateNode.browseName.toString();
-                    warningLog(chalk.red("Warning"), " cannot raise event :  transition " + f + " to " + t + " is missing");
+                    warningLog(chalk.red("Warning"), ` cannot raise event :  transition ${f} to ${t} is missing`);
                 }
             }
         }
@@ -575,7 +574,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
     public _post_initialize(): void {
         const addressSpace = this.addressSpace;
         const finiteStateMachineType = addressSpace.findObjectType("FiniteStateMachineType");
-       
+
         // c8 ignore next
         if (!finiteStateMachineType) {
             throw new Error("cannot find FiniteStateMachineType");
@@ -585,13 +584,12 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
         // xx assert(!this.typeDefinitionObj || this.typeDefinitionObj.isSubtypeOf(finiteStateMachineType));
         // get current Status
 
-        const d = this.currentState.readValue();
+        const d = $(this).currentState.readValue();
 
         if (d.statusCode.isNotGood()) {
             this.setState(null);
         } else {
-            const txt =
-                d.value && d.value.value ? (d.value.value.text ? d.value.value.text.toString() : d.value.value.toString()) : "";
+            const txt = d.value?.value ? (d.value.value.text ? d.value.value.text.toString() : d.value.value.toString()) : "";
             this.currentStateNode = this.getStateByName(txt);
         }
 
@@ -628,7 +626,8 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
         }
     }
 }
-
+export type UAStateMachineImpl = UAStateMachineImplBase & UAStateMachineEx;
+export const UAStateMachineImpl = UAStateMachineImplBase as unknown as new () => UAStateMachineImpl;
 export function promoteToStateMachine(node: UAObject): UAStateMachineEx {
     if (node instanceof UAStateMachineImpl) {
         return node; // already promoted

package/src/state_machine/ua_shelving_state_machine_ex.ts

@@ -6,19 +6,17 @@
 // ShelvingStateMachine
 // --------------------------------------------------------------------------------------------------
 
+import type { ISessionContext, UAMethod, UAObject, UAProperty } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { CallbackT, StatusCodes } from "node-opcua-status-code";
-import { DataType, Variant, VariantLike } from "node-opcua-variant";
-
-import { UAProperty, ISessionContext, UAMethod, UAObject } from "node-opcua-address-space-base";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
-import { UAState, UATransition } from "node-opcua-nodeset-ua";
-import { CallMethodResultOptions } from "node-opcua-service-call";
 import { DataValue } from "node-opcua-data-value";
-
-import { UAAlarmConditionImpl } from "../alarms_and_conditions/ua_alarm_condition_impl";
-import { UAShelvedStateMachineEx } from "../../source/interfaces/state_machine/ua_shelved_state_machine_ex";
-import { UATransitionEx } from "../../source/interfaces/state_machine/ua_transition_ex";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import type { UAState } from "node-opcua-nodeset-ua";
+import type { CallMethodResultOptions } from "node-opcua-service-call";
+import { type CallbackT, StatusCodes } from "node-opcua-status-code";
+import { DataType, Variant, type VariantLike } from "node-opcua-variant";
+import type { UAShelvedStateMachineEx } from "../../source/interfaces/state_machine/ua_shelved_state_machine_ex";
+import type { UATransitionEx } from "../../source/interfaces/state_machine/ua_transition_ex";
+import { UAAlarmConditionImpl, UAAlarmConditionImplBase } from "../alarms_and_conditions/ua_alarm_condition_impl";
 
 import { promoteToStateMachine, UAStateMachineImpl } from "./finite_state_machine";
 
@@ -32,8 +30,8 @@ export interface UAShelvedStateMachineHelper {
     _duration: number;
 }
 
-export interface UAShelvedStateMachineExImpl extends UAShelvedStateMachineHelper {
-        unshelveTime: UAProperty<number, /*z*/ DataType.Double>;
+export interface UAShelvedStateMachineHelper2 extends UAShelvedStateMachineHelper {
+    unshelveTime: UAProperty<number, /*z*/ DataType.Double>;
     unshelved: UAState;
     timedShelved: UAState;
     oneShotShelved: UAState;
@@ -51,7 +49,7 @@ export interface UAShelvedStateMachineExImpl extends UAShelvedStateMachineHelper
     oneShotShelve2?: UAMethod;
 }
 
-export class UAShelvedStateMachineExImpl extends UAStateMachineImpl implements UAShelvedStateMachineEx {
+export class UAShelvedStateMachineExImplBase extends UAStateMachineImpl {
     public static promote(object: UAObject): UAShelvedStateMachineEx {
         const shelvingState = object as UAShelvedStateMachineExImpl;
         promoteToStateMachine(shelvingState);
@@ -83,6 +81,8 @@ export class UAShelvedStateMachineExImpl extends UAStateMachineImpl implements U
         return shelvingState;
     }
 }
+export type UAShelvedStateMachineExImpl = UAShelvedStateMachineExImplBase & UAShelvedStateMachineEx;
+export const  UAShelvedStateMachineExImpl = UAShelvedStateMachineExImplBase as unknown as new () => UAShelvedStateMachineExImpl;
 
 // The Unshelve Method sets the AlarmCondition to the Unshelved state. Normally, the MethodId found
 // the Shelving child of the Condition instance and the NodeId of the Shelving object as the ObjectId
@@ -102,7 +102,7 @@ function _unshelve_method(inputArguments: VariantLike[], context: ISessionContex
     //     return callback(null, {statusCode: StatusCodes.BadConditionDisabled});
     // }
 
-    const shelvingState = context.object! as UAShelvedStateMachineExImpl;
+    const shelvingState = context.object as UAShelvedStateMachineExImpl;
     promoteToStateMachine(shelvingState);
 
     if (shelvingState.getCurrentState() === "Unshelved") {
@@ -149,8 +149,8 @@ function _automatically_unshelve(shelvingState: UAShelvedStateMachineExImpl) {
 }
 
 function _start_timer_for_automatic_unshelve(shelvingState: UAShelvedStateMachineExImpl, duration: number) {
-    if (duration < 10 || duration >= Math.pow(2, 31)) {
-        throw new Error(" Invalid maxTimeShelved duration: " + duration + "  must be [10,2**31] ");
+    if (duration < 10 || duration >= 2 ** 31) {
+        throw new Error(` Invalid maxTimeShelved duration: ${duration}  must be [10,2**31] `);
     }
     assert(!shelvingState._timer);
 
@@ -162,7 +162,7 @@ function _start_timer_for_automatic_unshelve(shelvingState: UAShelvedStateMachin
         debugLog("shelvingState._duration", shelvingState._duration);
     }
 
-    if (duration !== UAAlarmConditionImpl.MaxDuration) {
+    if (duration !== UAAlarmConditionImplBase.MaxDuration) {
         assert(!shelvingState._timer);
         shelvingState._timer = setTimeout(_automatically_unshelve.bind(null, shelvingState), shelvingState._duration);
     }
@@ -213,7 +213,7 @@ function _timedShelve_method(
         });
     }
     const maxTimeShelved = alarmNode.getMaxTimeShelved();
-    assert(isFinite(maxTimeShelved));
+    assert(Number.isFinite(maxTimeShelved));
 
     assert(inputArguments[0].dataType === DataType.Double); // Duration
     assert(inputArguments[0] instanceof Variant);
@@ -271,8 +271,8 @@ function _oneShotShelve_method(
     }
 
     const maxTimeShelved = alarmNode.getMaxTimeShelved();
-    assert(isFinite(maxTimeShelved));
-    assert(maxTimeShelved !== UAAlarmConditionImpl.MaxDuration);
+    assert(Number.isFinite(maxTimeShelved));
+    assert(maxTimeShelved !== UAAlarmConditionImplBase.MaxDuration);
 
     // set automatic un-shelving timer
     _clear_timer_if_any(shelvingState);
@@ -305,12 +305,12 @@ function _unShelveTimeFunc(shelvingState: UAShelvedStateMachineExImpl): DataValu
             value: { dataType: DataType.Double, value: 0 }
         });
     }
-    if (shelvingState.getCurrentState() === "OneShotShelved" && shelvingState._duration === UAAlarmConditionImpl.MaxDuration) {
+    if (shelvingState.getCurrentState() === "OneShotShelved" && shelvingState._duration === UAAlarmConditionImplBase.MaxDuration) {
         return new DataValue({
             statusCode: StatusCodes.Good,
             value: {
                 dataType: DataType.Double,
-                value: UAAlarmConditionImpl.MaxDuration
+                value: UAAlarmConditionImplBase.MaxDuration
             }
         });
     }

package/src/state_machine/ua_two_state_variable.ts

@@ -1,28 +1,36 @@
-    /**
+/**
  * @module node-opcua-address-space
  */
-import { assert } from "node-opcua-assert";
 
+import type {
+    BaseNode,
+    BindVariableOptions,
+    INamespace,
+    ISessionContext,
+    UAReference,
+    UAVariable
+} from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
 import { VariableTypeIds } from "node-opcua-constants";
-import { BrowseDirection, coerceLocalizedText, LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
-import { DataValueT } from "node-opcua-data-value";
-import { NodeId, resolveNodeId } from "node-opcua-nodeid";
-import { sameNodeId } from "node-opcua-nodeid";
-import { StatusCodes, StatusCode, StatusCodeCallback } from "node-opcua-status-code";
-import { Variant, VariantLike, VariantT } from "node-opcua-variant";
-import { DataType } from "node-opcua-variant";
-import { BaseNode, BindVariableOptions, INamespace, UAReference, UAVariable, ISessionContext } from "node-opcua-address-space-base";
-import { NumericRange } from "node-opcua-numeric-range";
-import { QualifiedNameLike } from "node-opcua-data-model";
-
+import {
+    BrowseDirection,
+    coerceLocalizedText,
+    type LocalizedText,
+    type LocalizedTextLike,
+    type QualifiedNameLike
+} from "node-opcua-data-model";
+import type { DataValueT } from "node-opcua-data-value";
+import { type NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import type { NumericRange } from "node-opcua-numeric-range";
+import { type StatusCode, type StatusCodeCallback, StatusCodes } from "node-opcua-status-code";
+import { DataType, Variant, type VariantLike, type VariantT } from "node-opcua-variant";
+import type { AddTwoStateVariableOptions } from "../../source/address_space_ts";
+import type { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
 // public interfaces
 import { registerNodePromoter } from "../../source/loader/register_node_promoter";
-import { AddTwoStateVariableOptions } from "../../source/address_space_ts";
-import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
+import type { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
 // private types
 import { UAVariableImpl, UAVariableImplT } from "../ua_variable_impl";
-import { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
-
 
 const hasTrueSubState_ReferenceTypeNodeId = resolveNodeId("HasTrueSubState");
 const hasFalseSubState_ReferenceTypeNodeId = resolveNodeId("HasFalseSubState");
@@ -64,9 +72,8 @@ function _updateTransitionTime(node: UATwoStateVariableEx, _subState?: UAVariabl
     }
 }
 
-function _updateEffectiveTransitionTime(node: UATwoStateVariableImpl,options?: ISetStateOptions) {
+function _updateEffectiveTransitionTime(node: UATwoStateVariableImpl, options?: ISetStateOptions) {
     if (node.effectiveTransitionTime) {
-        
         const effectiveTransitionTime = options?.effectiveTransitionTime || new Date();
 
         // because subStateNode ",subStateNode.browseName.toString());
@@ -77,7 +84,7 @@ function _updateEffectiveTransitionTime(node: UATwoStateVariableImpl,options?: I
     }
 }
 
-function _getEffectiveDisplayName<T, DT extends DataType>(
+function _getEffectiveDisplayName<_T, _DT extends DataType>(
     node: UATwoStateVariableImpl
 ): DataValueT<LocalizedText, DataType.LocalizedText> {
     const humanReadableString = _getHumanReadableString(node);
@@ -92,7 +99,7 @@ function _getEffectiveDisplayName<T, DT extends DataType>(
     } else {
         subStateNodes = node.findReferencesExAsObject("HasFalseSubState", BrowseDirection.Forward);
     }
-    const states = subStateNodes.forEach((n: any) => {
+    const _states = subStateNodes.forEach((_n: any) => {
         // todo happen
     });
 
@@ -133,7 +140,7 @@ export function _install_TwoStateVariable_machinery(
     assert(node.minimumSamplingInterval === 0);
     assert(node.typeDefinitionObj.browseName.toString() === "TwoStateVariableType");
     assert(node.dataTypeObj.browseName.toString() === "LocalizedText");
-    assert(Object.prototype.hasOwnProperty.call(node, "valueRank") && (node.valueRank === -1 || node.valueRank === 0));
+    assert(Object.hasOwn(node, "valueRank") && (node.valueRank === -1 || node.valueRank === 0));
 
     // promote node into a UATwoStateVariable
     const _node = promoteToTwoStateVariable(node);
@@ -196,10 +203,6 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
     private _trueState?: string;
     private _falseState?: string;
 
-    public constructor(opts: any) {
-        super(opts);
-    }
-
     get isFalseSubStateOf(): UATwoStateVariableEx {
         return super.isFalseSubStateOf as UATwoStateVariableEx;
     }
@@ -219,7 +222,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
                     value: coerceLocalizedText(options.falseState)
                 });
             } else {
-                this._trueState = coerceLocalizedText(options.trueState)!.text!;
+                this._trueState = coerceLocalizedText(options.trueState)?.text!;
             }
             if (this.trueState) {
                 this.trueState.setValueFromSource({
@@ -227,7 +230,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
                     value: coerceLocalizedText(options.trueState)
                 });
             } else {
-                this._falseState = coerceLocalizedText(options.falseState)!.text!;
+                this._falseState = coerceLocalizedText(options.falseState)?.text!;
             }
         }
 
@@ -264,7 +267,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
                 },
                 StatusCodes.Good
             );
-        } else if (Object.prototype.hasOwnProperty.call(options.value, "dataType")) {
+        } else if (Object.hasOwn(options.value, "dataType")) {
             assert((options.value as VariantLike).dataType === DataType.Boolean);
             this.id.setValueFromSource(options.value as VariantLike, StatusCodes.Good);
         } else {
@@ -312,7 +315,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
      */
     public setValue(boolValue: boolean, options?: ISetStateOptions): void {
         assert(typeof boolValue === "boolean");
-        const dataValue = this.id!.readValue();
+        const dataValue = this.id?.readValue();
         const oldValue = dataValue.value.value;
         if (dataValue.statusCode.isGood() && boolValue === oldValue) {
             return; // nothing to do
@@ -326,7 +329,7 @@ export class UATwoStateVariableImpl extends UAVariableImplT<LocalizedText, DataT
     /**
      */
     public getValue(): boolean {
-        const dataValue = this.id!.readValue();
+        const dataValue = this.id?.readValue();
         assert(dataValue.statusCode.isGood());
         assert(dataValue.value.dataType === DataType.Boolean);
         return dataValue.value.value;