node-opcua-address-space 2.170.1 → 2.173.0

package/src/base_node_impl.ts

@@ -3,25 +3,27 @@
  */
 
 import { isDeepStrictEqual as isEqual } from "node:util";
-import { EventEmitter } from "node:events";
 import chalk from "chalk";
-
-import type {
-    AddReferenceOpts,
-    BaseNode,
-    BrowseDescriptionOptions2,
-    IAddressSpace,
-    INamespace,
-    ISessionContext,
-    ModellingRuleType,
-    UAMethod,
-    UAObject,
-    UAObjectType,
-    UAProperty,
-    UAReference,
-    UAReferenceType,
-    UAVariable,
-    UAVariableType
+import {
+    type AddReferenceOpts,
+    type AttributeEventName,
+    type BaseNode, 
+    type BaseNodeEvents,
+    type BrowseDescriptionOptions2,
+    type IAddressSpace,
+    type INamespace,
+    type ISessionContext,
+    type ListenerSignature,
+    type ModellingRuleType,
+    TypedEventEmitter,
+    type UAMethod,
+    type UAObject,
+    type UAObjectType,
+    type UAProperty,
+    type UAReference,
+    type UAReferenceType,
+    type UAVariable,
+    type UAVariableType 
 } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import type { UAString } from "node-opcua-basic-types";
@@ -131,10 +133,9 @@ function _is_valid_BrowseDirection(browseDirection: BrowseDirection) {
         browseDirection === BrowseDirection.Both
     );
 }
-
-export function makeAttributeEventName(attributeId: AttributeIds): string {
+export function makeAttributeEventName(attributeId: AttributeIds): AttributeEventName {
     const attributeName = attributeNameById[attributeId];
-    return `${attributeName}_changed`;
+    return `${attributeName}_changed` as AttributeEventName;
 }
 
 /**
@@ -154,15 +155,17 @@ export function makeAttributeEventName(attributeId: AttributeIds): string {
  *
  *
  */
-export class BaseNodeImpl extends EventEmitter implements BaseNode {
-    public static makeAttributeEventName(attributeId: AttributeIds): string {
+
+export abstract class BaseNodeImpl<T extends BaseNodeEvents & ListenerSignature<T> = BaseNodeEvents> 
+extends TypedEventEmitter<T> implements BaseNode<T> {
+    public static makeAttributeEventName(attributeId: AttributeIds): AttributeEventName {
         return makeAttributeEventName(attributeId);
     }
 
     private _accessRestrictions?: AccessRestrictionsFlag;
     private _rolePermissions?: RolePermissionType[];
 
-    public onFirstBrowseAction?: (this: BaseNode) => Promise<void>;
+    // public onFirstBrowseAction?: (this: BaseNode<T>) => Promise<void>;
 
     public get addressSpace(): IAddressSpace {
         const _private = BaseNode_getPrivate(this);
@@ -611,7 +614,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         const methods = this.getMethods();
         const select = _filter_by_browse_name(methods, methodName, namespaceIndex);
         assert(select.length <= 1, "BaseNode#getMethodByName found duplicated reference");
-        return select.length === 1 ? select[0] : null;
+        return select.length === 1 ? select[0]  as UAMethod: null;
     }
 
     public getWriteMask(): number {
@@ -1165,7 +1168,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
      * @private
      */
     public dispose(): void {
-        this.emit("dispose");
+        (this as BaseNode).emit("dispose");
 
         this.removeAllListeners();
         this._clear_caches();
@@ -1330,7 +1333,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
 
     private _notifyAttributeChange(attributeId: AttributeIds): void {
         const event_name = BaseNodeImpl.makeAttributeEventName(attributeId);
-        this.emit(event_name, this.readAttribute(SessionContext.defaultContext, attributeId));
+        (this as BaseNode).emit(event_name, this.readAttribute(SessionContext.defaultContext, attributeId));
     }
 
     private _clear_caches() {
@@ -1342,15 +1345,15 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         // Historizing or RolePermissions Attribute
         if (!context) return true;
         if (attributeId === AttributeIds.Historizing) {
-            return context.checkPermission(this, PermissionType.WriteHistorizing);
+            return context.checkPermission(this as BaseNode, PermissionType.WriteHistorizing);
         }
         if (attributeId === AttributeIds.RolePermissions) {
-            return context.checkPermission(this, PermissionType.WriteRolePermissions);
+            return context.checkPermission(this as BaseNode, PermissionType.WriteRolePermissions);
         }
         if (attributeId === AttributeIds.Value) {
-            return context.checkPermission(this, PermissionType.Write);
+            return context.checkPermission(this as BaseNode, PermissionType.Write);
         }
-        return context.checkPermission(this, PermissionType.WriteAttribute);
+        return context.checkPermission(this as BaseNode, PermissionType.WriteAttribute);
     }
 
     private _readAccessRestrictions(_context: ISessionContext | null): DataValue {
@@ -1371,7 +1374,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         // https://reference.opcfoundation.org/v104/Core/docs/Part3/4.8.3/
 
         // to do check that current user can read permission
-        if (context && !context.checkPermission(this, PermissionType.ReadRolePermissions)) {
+        if (context && !context.checkPermission(this as BaseNode, PermissionType.ReadRolePermissions)) {
             return new DataValue({
                 statusCode: StatusCodes.BadSecurityModeInsufficient
             });
@@ -1405,7 +1408,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         const allUserCanSeeTheirOwnRolePermissions = true;
         if (!allUserCanSeeTheirOwnRolePermissions) {
             // to do check that current user can read permission
-            if (context && !context.checkPermission(this, PermissionType.ReadRolePermissions)) {
+            if (context && !context.checkPermission(this as BaseNode, PermissionType.ReadRolePermissions)) {
                 return new DataValue({
                     statusCode: StatusCodes.BadSecurityModeInsufficient
                 });
@@ -1536,8 +1539,8 @@ function toObject(addressSpace: IAddressSpace, reference: UAReference): BaseNode
     if (doDebug && !obj) {
         debugLog(
             chalk.red(" Warning :  object with nodeId ") +
-            chalk.cyan(reference.nodeId.toString()) +
-            chalk.red(" cannot be found in the address space !")
+                chalk.cyan(reference.nodeId.toString()) +
+                chalk.red(" cannot be found in the address space !")
         );
     }
     return obj;
@@ -1579,10 +1582,10 @@ function _select_by_browse_name(map: HierarchicalIndexMap, browseName: Qualified
     return [];
 }
 
-function _filter_by_browse_name<T extends BaseNode>(components: T[], browseName: QualifiedNameLike, namespaceIndex?: number): T[] {
-    let select: T[] = [];
+function _filter_by_browse_name(components: BaseNode[], browseName: QualifiedNameLike, namespaceIndex?: number): BaseNode[] {
+    let select: BaseNode[] = [];
     if ((namespaceIndex === null || namespaceIndex === undefined) && typeof browseName === "string") {
-        select = components.filter((c: T) => c.browseName.name === browseName);
+        select = components.filter((c: BaseNode) => c.browseName.name === browseName);
         if (select && select.length > 1) {
             warningLog("Multiple children exist with name ", browseName, " please specify a namespace index");
         }
@@ -1592,7 +1595,7 @@ function _filter_by_browse_name<T extends BaseNode>(components: T[], browseName:
             return [];
         }
         select = components.filter(
-            (c: T) => c.browseName.name === _browseName.name && c.browseName.namespaceIndex === _browseName.namespaceIndex
+            (c: BaseNode) => c.browseName.name === _browseName.name && c.browseName.namespaceIndex === _browseName.namespaceIndex
         );
     }
     return select;
@@ -1605,7 +1608,11 @@ function _is_massively_used_reference(referenceType: UAReferenceType): boolean {
     return name === "HasTypeDefinition" || name === "HasModellingRule";
 }
 
-function _propagate_ref(this: BaseNode, addressSpace: MinimalistAddressSpace, reference: UAReference): void {
+function _propagate_ref(
+    this: BaseNode,
+    addressSpace: MinimalistAddressSpace,
+    reference: UAReference
+): void {
     // filter out non  Hierarchical References
     const referenceType = ReferenceImpl.resolveReferenceType(addressSpace, reference);
 
@@ -1645,7 +1652,7 @@ function _propagate_ref(this: BaseNode, addressSpace: MinimalistAddressSpace, re
             new ReferenceImpl({
                 _referenceType: getReferenceType(reference),
                 isForward: !reference.isForward,
-                node: this,
+                node: this as BaseNode,
                 nodeId: this.nodeId,
                 referenceType: reference.referenceType
             })
@@ -1757,12 +1764,20 @@ function _filter_by_context(node: BaseNode, references: Reference[], context: Se
     return [];
 }
 */
-function _filter_by_context(node: BaseNode, references: UAReference[], context: ISessionContext): UAReference[] {
+function _filter_by_context(
+    node: BaseNode,
+    references: UAReference[],
+    context: ISessionContext
+): UAReference[] {
     const addressSpace = node.addressSpace;
     return references.filter((reference) => !context.isBrowseAccessRestricted(resolveReferenceNode(addressSpace, reference)));
 }
 
-function _filter_by_nodeClass(this: BaseNode, references: UAReference[], nodeClassMask: number): UAReference[] {
+function _filter_by_nodeClass(
+    this: BaseNode,
+    references: UAReference[],
+    nodeClassMask: number
+): UAReference[] {
     assert(Number.isFinite(nodeClassMask));
     if (nodeClassMask === 0) {
         return references;
@@ -1782,7 +1797,11 @@ function _filter_by_nodeClass(this: BaseNode, references: UAReference[], nodeCla
     });
 }
 
-function _filter_by_userFilter(this: BaseNode, references: UAReference[], context?: ISessionContext): UAReference[] {
+function _filter_by_userFilter(
+    this: BaseNode,
+    references: UAReference[],
+    context?: ISessionContext
+): UAReference[] {
     const addressSpace = this.addressSpace;
     return references.filter((reference: UAReference) => {
         const obj = resolveReferenceNode(addressSpace, reference) as BaseNode;

package/src/base_node_private.ts

@@ -916,7 +916,15 @@ function __clone_interfaces_related_references(
         if (!typeDefinitionNode) {
             continue;
         }
-        if (doTrace) traceLog(extraInfo?.pad(), chalk.blueBright(newParent.browseName.toString(), "-----> Exploring interface ", typeDefinitionNode.browseName.toString()));
+        if (doTrace)
+            traceLog(
+                extraInfo?.pad(),
+                chalk.blueBright(
+                    newParent.browseName.toString(),
+                    "-----> Exploring interface ",
+                    typeDefinitionNode.browseName.toString()
+                )
+            );
         while (typeDefinitionNode) {
             // c8 ignore next
             doTrace &&
@@ -946,7 +954,7 @@ export function _clone_hierarchical_references(
 ) {
     __clone_children_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
     __clone_organizes_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
- //   __clone_interfaces_related_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
+    //   __clone_interfaces_related_references(nodeToClone, newParent, copyAlsoModellingRules, optionalFilter, extraInfo, browseNameMap);
 }
 export function _clone_non_hierarchical_references(
     nodeToClone: UAObject | UAVariable | UAMethod | UAObjectType | UAVariableType,
@@ -1206,8 +1214,8 @@ function _makeReferenceDescription(addressSpace: IAddressSpace, reference: UARef
     } else {
         const obj2 = obj;
 
-        const objOrVar = (obj2.nodeClass === NodeClass.Object || obj2.nodeClass === NodeClass.Variable ) 
-        ? (obj2 as UAVariable | UAObject) : null;
+        const objOrVar =
+            obj2.nodeClass === NodeClass.Object || obj2.nodeClass === NodeClass.Variable ? (obj2 as UAVariable | UAObject) : null;
 
         assert(reference.nodeId, " obj.nodeId");
         data = {

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}`;
-    }
+    };
     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",