node-opcua-address-space 2.169.0 → 2.172.0

package/src/check_value_rank_compatibility.ts

@@ -1,6 +1,3 @@
-
-
-
 /**
  * This valueRank indicates whether the Value attribute of the Variable is an array and how many dimensions the array has.
  * It may have the following values:
@@ -13,7 +10,10 @@
  *   * All DataTypes are considered to be scalar, even if they have array-like semantics like ByteString and String.
  */
 
-export function checkValueRankCompatibility(actualValueRank: number, baseTypeValueRank: number): { result: boolean, errorMessage?: string } {
+export function checkValueRankCompatibility(
+    actualValueRank: number,
+    baseTypeValueRank: number
+): { result: boolean; errorMessage?: string } {
     const ScalarOrOneDimension = -3;
     const OneOrMoreDimensions = 0;
     const AnyDimension = -2;
@@ -21,17 +21,22 @@ export function checkValueRankCompatibility(actualValueRank: number, baseTypeVal
     const Scalar = -1;
     const t = (valueRank: number): string => {
         switch (valueRank) {
-            case ScalarOrOneDimension: return `ScalarOrOneDimension(${valueRank})`;
-            case OneOrMoreDimensions: return `OneOrMoreDimensions(${valueRank})`;
-            case AnyDimension: return `AnyDimension(${valueRank})`;
-            case OneDimension: return `OneDimension(${valueRank})`;
-            case Scalar: return `Scalar(${valueRank})`;
+            case ScalarOrOneDimension:
+                return `ScalarOrOneDimension(${valueRank})`;
+            case OneOrMoreDimensions:
+                return `OneOrMoreDimensions(${valueRank})`;
+            case AnyDimension:
+                return `AnyDimension(${valueRank})`;
+            case OneDimension:
+                return `OneDimension(${valueRank})`;
+            case Scalar:
+                return `Scalar(${valueRank})`;
         }
         if (valueRank < 0) {
             return `InvalidValueRank(${valueRank})`;
         }
-        return "" + valueRank;
-    }
+        return `${valueRank}`;
+    };
     if (actualValueRank < 0) {
         if (actualValueRank !== Scalar && actualValueRank !== AnyDimension && actualValueRank !== ScalarOrOneDimension) {
             return {
@@ -46,7 +51,7 @@ export function checkValueRankCompatibility(actualValueRank: number, baseTypeVal
     if (baseTypeValueRank === OneDimension || baseTypeValueRank > 1) {
         if (actualValueRank === baseTypeValueRank) {
             return { result: true };
-        };
+        }
         return {
             result: false,
             errorMessage: `Invalid valueRank: ${t(actualValueRank)}:  valueRank can only be identical to base type ${t(baseTypeValueRank)}`
@@ -67,7 +72,8 @@ export function checkValueRankCompatibility(actualValueRank: number, baseTypeVal
         };
     }
     if (baseTypeValueRank === ScalarOrOneDimension) {
-        if (actualValueRank === OneDimension || actualValueRank === Scalar || actualValueRank === ScalarOrOneDimension) return { result: true };
+        if (actualValueRank === OneDimension || actualValueRank === Scalar || actualValueRank === ScalarOrOneDimension)
+            return { result: true };
         return {
             result: false,
             errorMessage: `Invalid valueRank: ${t(actualValueRank)}: valueRank can only be identical to base type ${t(ScalarOrOneDimension)} , ${t(Scalar)} or ${t(OneDimension)}.`
@@ -75,5 +81,3 @@ export function checkValueRankCompatibility(actualValueRank: number, baseTypeVal
     }
     return { result: false };
 }
-
-

package/src/data_access/add_dataItem_stuff.ts

@@ -27,11 +27,10 @@
 //     a  Client  may encounter cases where the value read back from a  Server  differs from the value that it
 //     wrote to the Server. This   difference shall be no more than the difference suggested by this  Property
 
+import type { ModellingRuleType, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { DataType, Variant } from "node-opcua-variant";
 
-import { UAVariable, ModellingRuleType } from "node-opcua-address-space-base";
-
 const definition_Description =
     "Definition  is a vendor - specific," + " human readable string that specifies how the value of this  DataItem  is calculated.";
 const valuePrecision_Description = "";
@@ -45,7 +44,7 @@ export function add_dataItem_stuff(variable: UAVariable, options: add_dataItem_s
     const addressSpace = variable.addressSpace;
     const namespace = addressSpace.getNamespace(variable.nodeId.namespace);
 
-    if (Object.prototype.hasOwnProperty.call(options, "definition") && options.definition !== undefined) {
+    if (Object.hasOwn(options, "definition") && options.definition !== undefined) {
         namespace.addVariable({
             browseName: { name: "Definition", namespaceIndex: 0 },
             dataType: "String",
@@ -58,7 +57,7 @@ export function add_dataItem_stuff(variable: UAVariable, options: add_dataItem_s
         });
     }
 
-    if (Object.prototype.hasOwnProperty.call(options, "valuePrecision") && options.valuePrecision !== undefined) {
+    if (Object.hasOwn(options, "valuePrecision") && options.valuePrecision !== undefined) {
         assert(typeof options.valuePrecision === "number");
 
         namespace.addVariable({

package/src/data_access/adjust_datavalue_status_code.ts

@@ -1,14 +1,14 @@
 /**
  * @module node-opcua-address-space.DataAccess
  */
-import { StatusCodes } from "node-opcua-status-code";
-import { StatusCode } from "node-opcua-status-code";
-import { Range } from "node-opcua-types";
-import { UAVariable } from "node-opcua-address-space-base";
+
+import type { UAVariable } from "node-opcua-address-space-base";
 import { NodeClass } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
-import { Variant } from "node-opcua-variant";
-import { UAVariableImpl } from "../ua_variable_impl";
+import type { DataValue } from "node-opcua-data-value";
+import { type StatusCode, StatusCodes } from "node-opcua-status-code";
+import type { Range } from "node-opcua-types";
+import type { Variant } from "node-opcua-variant";
+import type { UAVariableImpl } from "../ua_variable_impl";
 
 function validate_value_range(range: Range, variant: Variant) {
     if (variant.value < range.low || variant.value > range.high) {

package/src/data_access/ua_multistate_discrete_impl.ts

@@ -1,19 +1,25 @@
 /**
  * @module node-opcua-address-space.DataAccess
  */
+
+import type {
+    BindVariableOptions,
+    CloneExtraInfo,
+    CloneFilter,
+    CloneOptions,
+    INamespace,
+    UAVariable
+} from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { VariableTypeIds } from "node-opcua-constants";
-import { coerceLocalizedText, LocalizedText } from "node-opcua-data-model";
-import { StatusCode, StatusCodes } from "node-opcua-status-code";
-import { DataType, VariantArrayType, Variant } from "node-opcua-variant";
-import { BindVariableOptions, INamespace, UAVariable, UAProperty } from "node-opcua-address-space-base";
-
-import { UAMultiStateDiscrete, UAMultiStateDiscrete_Base } from "node-opcua-nodeset-ua";
+import { coerceLocalizedText, type LocalizedText } from "node-opcua-data-model";
+import type { UAMultiStateDiscrete_Base } from "node-opcua-nodeset-ua";
+import { type StatusCode, StatusCodes } from "node-opcua-status-code";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+import type { AddMultiStateDiscreteOptions } from "../../source/address_space_ts";
+import type { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
 import { registerNodePromoter } from "../../source/loader/register_node_promoter";
 import { UAVariableImpl } from "../ua_variable_impl";
-import { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
-
-import { AddMultiStateDiscreteOptions } from "../../source/address_space_ts";
 import { add_dataItem_stuff } from "./add_dataItem_stuff";
 
 export { UAMultiStateDiscrete } from "node-opcua-nodeset-ua";
@@ -27,26 +33,26 @@ export interface UAMultiStateDiscreteEx<T, DT extends DataType> extends UAMultiS
     checkVariantCompatibility(value: Variant): StatusCode;
 }
 
-export interface UAMultiStateDiscreteImpl<T, DT extends DataType> {
-    enumStrings: UAProperty<LocalizedText[], DataType.LocalizedText>;
-}
 /**
  * @class UAMultiStateDiscrete
  */
-export class UAMultiStateDiscreteImpl<T, DT extends DataType> extends UAVariableImpl implements UAMultiStateDiscreteEx<T, DT> {
+export class UAMultiStateDiscreteImplBase<T, DT extends DataType> extends UAVariableImpl {
+    private get $7(): UAMultiStateDiscreteEx<T, DT> {
+        return this as unknown as UAMultiStateDiscreteEx<T, DT>;
+    }
     public getValue(): number {
         return this.readValue().value.value;
     }
 
     public getValueAsString(): string {
         const index = this.getValue();
-        const arr = this.enumStrings.readValue().value.value;
+        const arr = this.$7.enumStrings.readValue().value.value;
         assert(Array.isArray(arr));
-        return arr[index].text ? arr[index].text!.toString() : "????";
+        return arr[index].text ? arr[index].text?.toString() : "????";
     }
 
     public getIndex(value: string): number {
-        const arr = this.enumStrings.readValue().value.value;
+        const arr = this.$7.enumStrings.readValue().value.value;
         assert(Array.isArray(arr));
         const index = arr.findIndex((a: LocalizedText) => a.text === value);
         return index;
@@ -56,24 +62,25 @@ export class UAMultiStateDiscreteImpl<T, DT extends DataType> extends UAVariable
         if (typeof value === "string") {
             const index = this.getIndex(value);
             if (index < 0) {
-                throw new Error("UAMultiStateDiscrete#setValue invalid multi state value provided : " + value);
+                throw new Error(`UAMultiStateDiscrete#setValue invalid multi state value provided : ${value}`);
             }
-            return this.setValue(index, options);
+            this.setValue(index, options);
+            return;
         }
-        const arrayEnumStrings = this.enumStrings.readValue().value.value;
+        const arrayEnumStrings = this.$7.enumStrings.readValue().value.value;
         if (value >= arrayEnumStrings.length) {
-            throw new Error("UAMultiStateDiscrete#setValue BadOutOfRange " + value);
+            throw new Error(`UAMultiStateDiscrete#setValue BadOutOfRange ${value}`);
         }
-        assert(isFinite(value));
-        return this.setValueFromSource(new Variant({ dataType: DataType.UInt32, value }));
+        assert(Number.isFinite(value));
+        this.setValueFromSource(new Variant({ dataType: DataType.UInt32, value }));
     }
 
     public checkVariantCompatibility(value: Variant): StatusCode {
         if (!this._validate_DataType(value.dataType)) {
             return StatusCodes.BadTypeMismatch;
         }
-        if (this.enumStrings) {
-            const arrayEnumStrings = this.enumStrings.readValue().value.value;
+        if (this.$7.enumStrings) {
+            const arrayEnumStrings = this.$7.enumStrings.readValue().value.value;
             // MultiStateDiscreteType
             assert(value.dataType === DataType.UInt32);
             if (value.value >= arrayEnumStrings.length) {
@@ -87,11 +94,20 @@ export class UAMultiStateDiscreteImpl<T, DT extends DataType> extends UAVariable
         /* empty */
     }
 
-    public clone<T, DT extends DataType>(options1: any, optionalFilter: any, extraInfo: any): UAMultiStateDiscreteImpl<T, DT> {
+    public clone(
+        options1: CloneOptions,
+        optionalFilter?: CloneFilter,
+        extraInfo?: CloneExtraInfo
+    ): UAMultiStateDiscreteImpl<T, DT> {
         const variable1 = UAVariableImpl.prototype.clone.call(this, options1, optionalFilter, extraInfo);
         return promoteToMultiStateDiscrete(variable1);
     }
 }
+export type UAMultiStateDiscreteImpl<T, DT extends DataType> = UAMultiStateDiscreteImplBase<T, DT> & UAMultiStateDiscreteEx<T, DT>;
+export const UAMultiStateDiscreteImpl = UAMultiStateDiscreteImplBase as unknown as new <
+    T,
+    DT extends DataType
+>() => UAMultiStateDiscreteImpl<T, DT>;
 
 export function promoteToMultiStateDiscrete<T, DT extends DataType>(node: UAVariable): UAMultiStateDiscreteImpl<T, DT> {
     if (node instanceof UAMultiStateDiscreteImpl) {
@@ -116,8 +132,8 @@ export function _addMultiStateDiscrete<T, DT extends DataType>(
     options: AddMultiStateDiscreteOptions
 ): UAMultiStateDiscreteImpl<T, DT> {
     const addressSpace = namespace.addressSpace;
-    assert(Object.prototype.hasOwnProperty.call(options, "enumStrings"));
-    assert(!Object.prototype.hasOwnProperty.call(options, "ValuePrecision"));
+    assert(Object.hasOwn(options, "enumStrings"));
+    assert(!Object.hasOwn(options, "ValuePrecision"));
 
     const multiStateDiscreteType = addressSpace.findVariableType("MultiStateDiscreteType");
     if (!multiStateDiscreteType) {
@@ -153,7 +169,7 @@ export function _addMultiStateDiscrete<T, DT extends DataType>(
         return coerceLocalizedText(value);
     });
 
-    const enumStringsNode = namespace.addVariable({
+    const _enumStringsNode = namespace.addVariable({
         accessLevel: "CurrentRead", // | CurrentWrite",
         browseName: { name: "EnumStrings", namespaceIndex: 0 },
         dataType: "LocalizedText",

package/src/data_access/ua_multistate_value_discrete_impl.ts

@@ -1,29 +1,39 @@
-/**
- * @module node-opcua-address-space.DataAccess
- */
+import type {
+    BindVariableOptions,
+    CloneExtraInfo,
+    CloneFilter,
+    CloneOptions,
+    INamespace,
+    UAVariable
+} from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
-import { coerceInt32, coerceInt64toInt32, coerceUInt64, coerceUInt64toInt32, Int32, Int64, isValidInt64, isValidUInt64 } from "node-opcua-basic-types";
-import { coerceLocalizedText, LocalizedText, QualifiedNameLike } from "node-opcua-data-model";
-import { DataValue, DataValueT } from "node-opcua-data-value";
-import { StatusCodes } from "node-opcua-status-code";
-import { StatusCode } from "node-opcua-status-code";
-import { NumericRange } from "node-opcua-numeric-range";
-import { DTEnumValue } from "node-opcua-nodeset-ua";
-import { BindVariableOptions, INamespace, UAVariable, UAProperty, ISessionContext } from "node-opcua-address-space-base";
+import {
+    coerceInt32,
+    coerceInt64toInt32,
+    coerceUInt64,
+    coerceUInt64toInt32,
+    type Int32,
+    type Int64,
+    isValidInt64,
+    isValidUInt64,
+    type UInt64
+} from "node-opcua-basic-types";
 import { VariableTypeIds } from "node-opcua-constants";
-import { _getBasicDataType, _getBasicDataTypeFromDataTypeNodeId } from "../get_basic_datatype";
-
-import { registerNodePromoter } from "../../source/loader/register_node_promoter";
+import { coerceLocalizedText } from "node-opcua-data-model";
+import type { DataValue } from "node-opcua-data-value";
+import type { DTEnumValue } from "node-opcua-nodeset-ua";
+import { type StatusCode, StatusCodes } from "node-opcua-status-code";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+import type { AddMultiStateValueDiscreteOptions } from "../../source/address_space_ts";
 import { coerceEnumValues } from "../../source/helpers/coerce_enum_value";
-import { UAMultiStateValueDiscreteEx } from "../../source/interfaces/data_access/ua_multistate_value_discrete_ex";
-import { AddMultiStateValueDiscreteOptions } from "../../source/address_space_ts";
-import { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
+import type { UAMultiStateValueDiscreteEx } from "../../source/interfaces/data_access/ua_multistate_value_discrete_ex";
+import type { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
+import { registerNodePromoter } from "../../source/loader/register_node_promoter";
+import { _getBasicDataTypeFromDataTypeNodeId } from "../get_basic_datatype";
 import { UAVariableImpl } from "../ua_variable_impl";
-
 import { add_dataItem_stuff } from "./add_dataItem_stuff";
 
-function convertToArray<T>(array: any): T[] {
+function convertToArray<T>(array: ArrayLike<T> | T[]): T[] {
     if (Array.isArray(array)) return array;
     const result: T[] = [];
     for (let i = 0; i < array.length; i++) {
@@ -42,18 +52,19 @@ const getCoerceToInt32 = (dataType: DataType) => {
     }
 };
 
-function install_synchronization<T extends number | Int64 | Int64, DT extends DataType>(
-    variable: UAMultiStateValueDiscreteEx<T, DT>
+type Number = number | Int64 | UInt64;
+
+function install_synchronization<T extends Number, DT extends DataType>(
+    _variable: UAVariableImpl & UAMultiStateValueDiscreteEx<T, DT>
 ) {
-    const _variable = variable as UAMultiStateValueDiscreteEx<T, DT>;
     _variable.on("value_changed", (dataValue: DataValue) => {
-        const valueAsTextNode = variable.valueAsText || (_variable.getComponentByName("ValueAsText") as UAVariable);
+        const valueAsTextNode = _variable.valueAsText || (_variable.getComponentByName("ValueAsText") as UAVariable);
         if (!valueAsTextNode) {
             return;
         }
         if (dataValue.value.arrayType === VariantArrayType.Array || dataValue.value.arrayType === VariantArrayType.Matrix) {
             //
-            const coerce = getCoerceToInt32(_variable.getBasicDataType());
+            const _coerce = getCoerceToInt32(_variable.getBasicDataType());
 
             const values: number[] = convertToArray<Int32>(dataValue.value.value).map((a) => coerceInt32(a));
             const variantArray: Variant[] = values.map((a) => _variable.findValueAsText(a));
@@ -76,50 +87,38 @@ function install_synchronization<T extends number | Int64 | Int64, DT extends Da
     _variable.emit("value_changed", dataValue);
 }
 
-export interface UAMultiStateValueDiscreteImpl<T, DT extends DataType> {
-    enumValues: UAProperty<DTEnumValue[], DataType.ExtensionObject>;
-    valueAsText: UAProperty<LocalizedText, DataType.LocalizedText>;
-
-    readValue(
-        context?: ISessionContext | null,
-        indexRange?: NumericRange,
-        dataEncoding?: QualifiedNameLike | null
-    ): DataValueT<T, DT>;
-
-    readValueAsync(context: ISessionContext | null, callback?: any): any;
-}
-export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
-    extends UAVariableImpl
-    implements UAMultiStateValueDiscreteEx<T, DT>
-{
+export class UAMultiStateValueDiscreteImplBase<T extends Number, DT extends DataType> extends UAVariableImpl {
+    private get $6(): UAMultiStateValueDiscreteEx<T, DT> {
+        return this as unknown as UAMultiStateValueDiscreteEx<T, DT>;
+    }
     public setValue(value: string | number | Int64, options?: ISetStateOptions): void {
         if (typeof value === "string") {
-            const enumValues = this.enumValues.readValue().value.value;
-            const selected = enumValues.filter((a: any) => a.displayName.text === value)[0];
+            const enumValues = this.$6.enumValues.readValue().value.value;
+            const selected = enumValues.filter((a) => a.displayName.text === value)[0];
             if (selected) {
                 this._setValue(selected.value);
             } else {
-                throw new Error("cannot find enum string " + value + " in " + enumValues.toString());
+                throw new Error(`cannot find enum string ${value} in ${enumValues.toString()}`);
             }
         } else {
             this._setValue(coerceUInt64(value), options);
         }
     }
 
-    public getValueAsString(): any {
-        const v = this.valueAsText.readValue().value.value;
+    public getValueAsString(): string | string[] {
+        const v = this.$6.valueAsText.readValue().value.value;
         if (Array.isArray(v)) {
             return v.map((a) => a.text);
         }
         return v.text || "";
     }
 
-    public getValueAsNumber(): any {
+    public getValueAsNumber(): number {
         return this.readValue().value.value;
     }
 
     public checkVariantCompatibility(value: Variant): StatusCode {
-        if (this.enumValues) {
+        if (this.$6.enumValues) {
             if (!this._isValueInRange(coerceInt32(value.value))) {
                 return StatusCodes.BadOutOfRange;
             }
@@ -127,7 +126,11 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
         return StatusCodes.Good;
     }
 
-    public clone<T, DT extends DataType>(options1: any, optionalFilter: any, extraInfo: any): UAMultiStateValueDiscreteImpl<T, DT> {
+    public clone(
+        options1: CloneOptions,
+        optionalFilter?: CloneFilter,
+        extraInfo?: CloneExtraInfo
+    ): UAMultiStateValueDiscreteImpl<T, DT> {
         const variable1 = UAVariableImpl.prototype.clone.call(this, options1, optionalFilter, extraInfo);
         return promoteToMultiStateValueDiscrete(variable1);
     }
@@ -137,7 +140,7 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
      */
     public _isValueInRange(value: number): boolean {
         // MultiStateValueDiscreteType
-        const enumValues = this.enumValues.readValue().value.value as DTEnumValue[];
+        const enumValues = this.$6.enumValues.readValue().value.value as DTEnumValue[];
         const e = enumValues.findIndex((x: DTEnumValue) => coerceInt64toInt32(x.value) === value);
         return !(e === -1);
     }
@@ -147,9 +150,9 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
      */
     public _enumValueIndex(): Record<Int32, DTEnumValue> {
         // construct an index to quickly find a EnumValue from a value
-        const enumValues: DTEnumValue[] = this.enumValues.readValue().value.value;
+        const enumValues: DTEnumValue[] = this.$6.enumValues.readValue().value.value;
         const enumValueIndex: Record<Int32, DTEnumValue> = Object.create(null);
-        if (!enumValues || !enumValues.forEach) {
+        if (!enumValues?.forEach) {
             return enumValueIndex;
         }
         enumValues.forEach((e: DTEnumValue) => {
@@ -163,11 +166,11 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
      *
      * @private
      */
-    public _setValue(value: Int64, options?: ISetStateOptions): void {
+    public _setValue(value: Int64, _options?: ISetStateOptions): void {
         const int32Value = coerceInt64toInt32(value);
         // check that value is in bound
         if (!this._isValueInRange(int32Value)) {
-            throw new Error("UAMultiStateValueDiscrete#_setValue out of range " + value);
+            throw new Error(`UAMultiStateValueDiscrete#_setValue out of range ${value}`);
         }
 
         const dataType = this._getDataType();
@@ -205,7 +208,7 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
             return DataType.UInt32;
         }
         const dataTypeStr = DataType[this.dataType.value as number] as string;
-        return (DataType as any)[dataTypeStr] as DataType;
+        return DataType[dataTypeStr as keyof typeof DataType];
     }
 
     /**
@@ -220,11 +223,19 @@ export class UAMultiStateValueDiscreteImpl<T, DT extends DataType>
         validateIsNumericDataType(this.dataType.value);
 
         // find the enum value type
-        install_synchronization(this);
+        install_synchronization(this as unknown as UAVariableImpl & UAMultiStateValueDiscreteEx<T, DT>);
     }
 }
-
-export function promoteToMultiStateValueDiscrete<T, DT extends DataType>(node: UAVariable): UAMultiStateValueDiscreteImpl<T, DT> {
+export type UAMultiStateValueDiscreteImpl<T extends Number, DT extends DataType> = UAMultiStateValueDiscreteImplBase<T, DT> &
+    UAMultiStateValueDiscreteEx<T, DT>;
+export const UAMultiStateValueDiscreteImpl = UAMultiStateValueDiscreteImplBase as unknown as new <
+    T extends Number,
+    DT extends DataType
+>() => UAMultiStateValueDiscreteImpl<T, DT>;
+
+export function promoteToMultiStateValueDiscrete<T extends Number, DT extends DataType>(
+    node: UAVariable
+): UAMultiStateValueDiscreteImpl<T, DT> {
     if (node instanceof UAMultiStateValueDiscreteImpl) {
         return node; // already promoted
     }
@@ -240,8 +251,8 @@ export function _addMultiStateValueDiscrete<T, DT extends DataType>(
     namespace: INamespace,
     options: AddMultiStateValueDiscreteOptions
 ): UAMultiStateValueDiscreteEx<T, DT> {
-    assert(Object.prototype.hasOwnProperty.call(options, "enumValues"));
-    assert(!Object.prototype.hasOwnProperty.call(options, "ValuePrecision"));
+    assert(Object.hasOwn(options, "enumValues"));
+    assert(!Object.hasOwn(options, "ValuePrecision"));
 
     const addressSpace = namespace.addressSpace;
 
@@ -275,7 +286,7 @@ export function _addMultiStateValueDiscrete<T, DT extends DataType>(
             value: options.value
         });
     } else {
-        value = options.value as any;
+        value = options.value as BindVariableOptions;
     }
 
     const cloned_options = {
@@ -344,13 +355,13 @@ const validBasicNumericDataTypes = [
     DataType.Byte,
     DataType.Byte,
     DataType.SByte,
-    26, /* Number  (abstract)*/
-    27, /* Integer  (abstract)*/
-    28  /* UInteger (abstract)*/
+    26 /* Number  (abstract)*/,
+    27 /* Integer  (abstract)*/,
+    28 /* UInteger (abstract)*/
 ];
-export function validateIsNumericDataType(dataTypeValue: any): void {
+export function validateIsNumericDataType(dataTypeValue: unknown): void {
     if (typeof dataTypeValue !== "number" || validBasicNumericDataTypes.indexOf(dataTypeValue) < 0) {
-        throw new Error(`Invalid DataType in UAMultiStateValueDiscrete => ${dataTypeValue.toString()}`);
+        throw new Error(`Invalid DataType in UAMultiStateValueDiscrete => ${dataTypeValue}`);
     }
 }
 

package/src/data_access/ua_two_state_discrete_impl.ts

@@ -1,33 +1,26 @@
+import type {
+    BindVariableOptions,
+    CloneExtraInfo,
+    CloneFilter,
+    CloneOptions,
+    INamespace,
+    UAVariable
+} from "node-opcua-address-space-base";
 import assert from "node-opcua-assert";
-import { coerceLocalizedText, LocalizedText, LocalizedTextLike, QualifiedNameLike } from "node-opcua-data-model";
-import { DataType, Variant, VariantLike } from "node-opcua-variant";
 import { VariableTypeIds } from "node-opcua-constants";
-import { INamespace, UAVariable, BindVariableOptions, UAProperty, ISessionContext } from "node-opcua-address-space-base";
-import { DataValueT } from "node-opcua-data-value";
-import { NumericRange } from "node-opcua-numeric-range";
-
-import { UAVariableImpl } from "../ua_variable_impl";
+import { coerceLocalizedText, type LocalizedText, type LocalizedTextLike } from "node-opcua-data-model";
+import { DataType, Variant } from "node-opcua-variant";
+import type { AddTwoStateDiscreteOptions } from "../../source/address_space_ts";
+import type { UATwoStateDiscreteEx } from "../../source/interfaces/data_access/ua_two_state_discrete_ex";
+import type { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
 import { registerNodePromoter } from "../../source/loader/register_node_promoter";
-import { AddTwoStateDiscreteOptions } from "../../source/address_space_ts";
-import { UATwoStateDiscreteEx } from "../../source/interfaces/data_access/ua_two_state_discrete_ex";
-import { ISetStateOptions } from "../../source/interfaces/i_set_state_options";
-
+import { UAVariableImpl } from "../ua_variable_impl";
 import { add_dataItem_stuff } from "./add_dataItem_stuff";
 
-
-export interface UATwoStateDiscreteImpl {
-    falseState: UAProperty<LocalizedText, /*c*/ DataType.LocalizedText>;
-    trueState: UAProperty<LocalizedText, /*c*/ DataType.LocalizedText>;
-
-    readValue(
-        context?: ISessionContext | null,
-        indexRange?: NumericRange,
-        dataEncoding?: QualifiedNameLike | null
-    ): DataValueT<boolean, DataType.Boolean>;
-
-    readValueAsync(context: ISessionContext | null, callback?: any): any;
-}
-export class UATwoStateDiscreteImpl extends UAVariableImpl implements UATwoStateDiscreteEx {
+export class UATwoStateDiscreteImplBase extends UAVariableImpl {
+    private get $5(): UATwoStateDiscreteEx {
+        return this as unknown as UATwoStateDiscreteEx;
+    }
     /*
      * @private
      */
@@ -40,9 +33,8 @@ export class UATwoStateDiscreteImpl extends UAVariableImpl implements UATwoState
         const falseState = this.getPropertyByName("FalseState");
         if (falseState) {
             falseState.on("value_changed", handler);
-        }
-        /* c8 ignore next */
-        else {
+        } else {
+            /* c8 ignore next */
             console.warn(
                 "warning: UATwoStateDiscrete -> a FalseState property is mandatory ",
                 this.browseName.toString(),
@@ -52,9 +44,8 @@ export class UATwoStateDiscreteImpl extends UAVariableImpl implements UATwoState
         const trueState = this.getPropertyByName("TrueState");
         if (trueState) {
             trueState.on("value_changed", handler);
-        }
-        /* c8 ignore next */
-        else {
+        } else {
+            /* c8 ignore next */
             console.warn(
                 "waring: UATwoStateDiscrete -> a TrueState property is mandatory",
                 this.browseName.toString(),
@@ -72,7 +63,7 @@ export class UATwoStateDiscreteImpl extends UAVariableImpl implements UATwoState
             } else if (text === this.getFalseStateAsString()) {
                 this.setValue(false, options);
             } else {
-                throw new Error("setValue invalid value " + value);
+                throw new Error(`setValue invalid value ${value}`);
             }
         }
     }
@@ -87,18 +78,20 @@ export class UATwoStateDiscreteImpl extends UAVariableImpl implements UATwoState
         }
     }
     getTrueStateAsString(): string {
-        return (this.trueState.readValue().value.value as LocalizedText).text || "";
+        return (this.$5.trueState.readValue().value.value as LocalizedText).text || "";
     }
     getFalseStateAsString(): string {
-        return (this.falseState.readValue().value.value as LocalizedText).text || "";
+        return (this.$5.falseState.readValue().value.value as LocalizedText).text || "";
     }
 
-    public clone(options1: any, optionalFilter: any, extraInfo: any): UAVariable {
+    public clone(options1: CloneOptions, optionalFilter?: CloneFilter, extraInfo?: CloneExtraInfo): UAVariable {
         const variable1 = UAVariableImpl.prototype.clone.call(this, options1, optionalFilter, extraInfo);
         promoteToTwoStateDiscrete(variable1);
         return variable1;
     }
 }
+export type UATwoStateDiscreteImpl = UATwoStateDiscreteImplBase & UATwoStateDiscreteEx;
+export const UATwoStateDiscreteImpl = UATwoStateDiscreteImplBase as unknown as new () => UATwoStateDiscreteImpl;
 
 export function promoteToTwoStateDiscrete(node: UAVariable): UATwoStateDiscreteEx {
     if (node instanceof UATwoStateDiscreteImpl) {
@@ -115,7 +108,7 @@ registerNodePromoter(VariableTypeIds.TwoStateDiscreteType, promoteToTwoStateDisc
 export function _addTwoStateDiscrete(namespace: INamespace, options: AddTwoStateDiscreteOptions): UATwoStateDiscreteEx {
     const addressSpace = namespace.addressSpace;
 
-    assert(!Object.prototype.hasOwnProperty.call(options, "ValuePrecision"));
+    assert(!Object.hasOwn(options, "ValuePrecision"));
 
     const twoStateDiscreteType = addressSpace.findVariableType("TwoStateDiscreteType");
     if (!twoStateDiscreteType) {