node-opcua-address-space 2.178.0 → 2.179.0

package/src/alarms_and_conditions/ua_acknowledgeable_condition_impl.ts

@@ -23,16 +23,14 @@ import { type UAConditionImpl, UAConditionImplBase } from "./ua_condition_impl";
 const debugLog = make_debugLog(__filename);
 const doDebug = false;
 
-
 const $ = (a: UAAcknowledgeableConditionImplBase): UAAcknowledgeableConditionEx => a as unknown as UAAcknowledgeableConditionEx;
 
-
-export interface UAAcknowegeableConditionEvents extends UAConditionEvents  {
+export interface UAAcknowegeableConditionEvents extends UAConditionEvents {
     acknowledged: (eventId: Buffer | null, comment: LocalizedText | null, branch: ConditionSnapshot) => void;
     confirmed: (eventId: Buffer | null, comment: LocalizedText | null, branch: ConditionSnapshot) => void;
 }
 export class UAAcknowledgeableConditionImplBase<
-    T extends UAAcknowegeableConditionEvents & ListenerSignature<T>  = UAAcknowegeableConditionEvents
+    T extends UAAcknowegeableConditionEvents & ListenerSignature<T> = UAAcknowegeableConditionEvents
 > extends UAConditionImplBase<T> {
     /**
      */
@@ -201,7 +199,7 @@ export class UAAcknowledgeableConditionImplBase<
         this.raiseNewBranchState(branch);
 
         this._raiseAuditConditionAcknowledgeEvent(branch);
-        
+
         /**
          * @event acknowledged
          * @param  eventId   {Buffer|null}
@@ -240,7 +238,7 @@ export class UAAcknowledgeableConditionImplBase<
 
         this.raiseNewBranchState(branch);
 
-       /**
+        /**
          * @event confirmed
          * @param  eventId
          * @param  comment
@@ -251,7 +249,7 @@ export class UAAcknowledgeableConditionImplBase<
     }
 
     /**
-     * 
+     *
      */
     public autoConfirmBranch(branch: ConditionSnapshot, comment: LocalizedTextLike): void {
         assert(branch instanceof ConditionSnapshotImpl);

package/src/alarms_and_conditions/ua_alarm_condition_impl.ts

@@ -6,7 +6,7 @@ import type { BaseNode, INamespace, UAEventType, UAVariable } from "node-opcua-a
 import { assert } from "node-opcua-assert";
 import { NodeClass } from "node-opcua-data-model";
 import type { DataValue } from "node-opcua-data-value";
-import { make_debugLog } from "node-opcua-debug";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
 import { NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType, type VariantOptions } from "node-opcua-variant";
@@ -14,12 +14,17 @@ import type { ConditionInfo } from "../../source/interfaces/alarms_and_condition
 import type { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
 import type { UAAlarmConditionEx } from "../../source/interfaces/alarms_and_conditions/ua_alarm_condition_ex";
 import type { AddressSpacePrivate } from "../address_space_private";
-import { _clear_timer_if_any, type UAShelvedStateMachineExImpl, UAShelvedStateMachineExImplBase } from "../state_machine/ua_shelving_state_machine_ex";
+import {
+    _clear_timer_if_any,
+    type UAShelvedStateMachineExImpl,
+    UAShelvedStateMachineExImplBase
+} from "../state_machine/ua_shelving_state_machine_ex";
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
 import { ConditionInfoImpl } from "./condition_info_impl";
 import { UAAcknowledgeableConditionImpl, UAAcknowledgeableConditionImplBase } from "./ua_acknowledgeable_condition_impl";
 
 const debugLog = make_debugLog(__filename);
+const doDebug = checkDebugFlag(__filename);
 
 function _update_suppressedOrShelved(alarmNode: UAAlarmConditionImpl) {
     alarmNode.suppressedOrShelved.setValueFromSource({
@@ -28,7 +33,7 @@ function _update_suppressedOrShelved(alarmNode: UAAlarmConditionImpl) {
     });
 }
 
-const  $ = (a: UAAlarmConditionImplBase): UAAlarmConditionEx =>  a as unknown as UAAlarmConditionEx;
+const $ = (a: UAAlarmConditionImplBase): UAAlarmConditionEx => a as unknown as UAAlarmConditionEx;
 export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase {
     public static MaxDuration = 2 ** 31;
 
@@ -178,7 +183,6 @@ export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase
         return alarmNode;
     }
 
-
     public dispose(): void {
         if ($(this).shelvingState) {
             _clear_timer_if_any($(this).shelvingState as unknown as UAShelvedStateMachineExImpl);
@@ -240,7 +244,7 @@ export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase
         if (duration < 10 || duration >= 2 ** 31) {
             throw new Error(` Invalid maxTimeShelved duration: ${duration}  must be [10,2**31] `);
         }
-       $(this).maxTimeShelved?.setValueFromSource({
+        $(this).maxTimeShelved?.setValueFromSource({
             dataType: "Duration", // <= Duration is basic Type Double! ( milliseconds)
             value: duration
         });
@@ -271,7 +275,7 @@ export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase
      *       whose node id is stored in alarm.inputNode
      */
     public getInputNodeNode(): UAVariable | null {
-        const nodeId =$(this).inputNode.readValue().value.value;
+        const nodeId = $(this).inputNode.readValue().value.value;
         assert(nodeId instanceof NodeId || nodeId === null);
         return this.addressSpace.findNode(nodeId) as UAVariable | null;
     }
@@ -321,22 +325,23 @@ export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase
         assert(inputNode, " must provide options.inputNode (NodeId or BaseNode object)");
 
         if (inputNode instanceof NodeId) {
-           $(this).inputNode.setValueFromSource({
+            $(this).inputNode.setValueFromSource({
                 dataType: DataType.NodeId,
                 value: inputNode as NodeId
             });
         } else {
-           $(this).inputNode.setValueFromSource({
+            $(this).inputNode.setValueFromSource({
                 dataType: "NodeId",
                 value: (inputNode as BaseNode).nodeId
             });
 
             const _node = addressSpace._coerceNode(inputNode);
             if (_node === null) {
-                debugLog(" cannot find nodeId ", inputNode);
+                // c8 ignore next
+                doDebug && debugLog(" cannot find nodeId ", inputNode);
             } else {
                 assert(_node, "Expecting a valid input node");
-               $(this).inputNode.setValueFromSource({
+                $(this).inputNode.setValueFromSource({
                     dataType: DataType.NodeId,
                     value: _node.nodeId
                 });
@@ -433,9 +438,11 @@ export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase
 
         // detect potential internal bugs due to misused of _signalNewCondition
         if (isEqual(oldConditionInfo, newConditionInfo)) {
-            // tslint:disable-next-line:no-console
-            debugLog("oldConditionInfo", oldConditionInfo);
-            debugLog("oldConditionInfo", newConditionInfo);
+            // c8 ignore next
+            if (doDebug) {
+                debugLog("oldConditionInfo", oldConditionInfo);
+                debugLog("oldConditionInfo", newConditionInfo);
+            }
             throw new Error(
                 `condition values have not change, shall we really raise an event ? alarm ${this.browseName.toString()}`
             );

package/src/alarms_and_conditions/ua_base_event_impl.ts

@@ -39,4 +39,4 @@ export class UABaseEventImplBase<T extends UABaseEventEvents & ListenerSignature
 }
 
 export type UABaseEventImpl = UABaseEventImplBase & UABaseEventEx;
-export const UABaseEventImpl = UABaseEventImplBase as unknown as new () => UABaseEventImpl;
+export const UABaseEventImpl = UABaseEventImplBase as unknown as new () => UABaseEventImpl;

package/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.ts

@@ -241,4 +241,4 @@ registerNodePromoter(ObjectTypeIds.CertificateExpirationAlarmType, promoteToCert
 
 export type UACertificateExpirationAlarmImpl = UACertificateExpirationAlarmImplBase & UACertificateExpirationAlarmEx;
 export const UACertificateExpirationAlarmImpl: new () => UACertificateExpirationAlarmImpl =
-    UACertificateExpirationAlarmImplBase as any;
+    UACertificateExpirationAlarmImplBase as unknown as new () => UACertificateExpirationAlarmImpl;

package/src/alarms_and_conditions/ua_condition_impl.ts

@@ -1,4 +1,3 @@
-/* eslint-disable complexity */
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
@@ -44,7 +43,7 @@ import type { UAConditionType } from "../ua_condition_type";
 import { UAObjectImpl } from "../ua_object_impl";
 import type { UAVariableImpl } from "../ua_variable_impl";
 import { ConditionSnapshotImpl } from "./condition_snapshot_impl";
-import {  UABaseEventImplBase } from "./ua_base_event_impl";
+import { UABaseEventImplBase } from "./ua_base_event_impl";
 
 const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
@@ -76,7 +75,9 @@ const warningLog = make_warningLog(__filename);
 
 const $ = (a: UAConditionImplBase): UAConditionEx => a as unknown as UAConditionEx;
 
-export class UAConditionImplBase<T extends UAConditionEvents & ListenerSignature<T> = UAConditionEvents> extends UABaseEventImplBase<T> {
+export class UAConditionImplBase<
+    T extends UAConditionEvents & ListenerSignature<T> = UAConditionEvents
+> extends UABaseEventImplBase<T> {
     public static defaultSeverity = 250;
     public static typeDefinition = resolveNodeId("ConditionType");
 
@@ -239,10 +240,9 @@ export class UAConditionImplBase<T extends UAConditionEvents & ListenerSignature
         assert(!sameNodeId(branch.getBranchId(), NodeId.nullNodeId), "cannot delete branch zero");
         assert(this._branches.has(key));
         this._branches.delete(key);
-        (this as UAConditionImplBase        ).emit("branch_deleted", key);
+        (this as UAConditionImplBase).emit("branch_deleted", key);
     }
 
-
     private get $() {
         return this as unknown as UAConditionEx;
     }
@@ -547,7 +547,8 @@ export class UAConditionImplBase<T extends UAConditionEvents & ListenerSignature
         // for the time being , only current branch
         const currentBranch = this.currentBranch();
         if (currentBranch.getRetain()) {
-            debugLog(` resending condition event for ${this.browseName.toString()}`);
+            // c8 ignore next
+            doDebug && debugLog(` resending condition event for ${this.browseName.toString()}`);
             this.raiseConditionEvent(currentBranch, false);
             return 1;
         }
@@ -643,7 +644,7 @@ export class UAConditionImplBase<T extends UAConditionEvents & ListenerSignature
         throw new Error("Unimplemented , please override");
     }
 }
-export type  UAConditionImpl = UAConditionImplBase & UAConditionEx;
+export type UAConditionImpl = UAConditionImplBase & UAConditionEx;
 export const UAConditionImpl = UAConditionImplBase as unknown as new () => UAConditionImpl;
 
 /**²
@@ -848,7 +849,8 @@ function UACondition_instantiate(
             !options.conditionSource ||
             (options.conditionSource.nodeClass !== NodeClass.Object && options.conditionSource.nodeClass !== NodeClass.Variable)
         ) {
-            debugLog(options.conditionSource);
+            // c8 ignore next
+            doDebug && debugLog(options.conditionSource);
             throw new Error("Expecting condition source to be NodeClass.Object or Variable");
         }
 
@@ -1006,7 +1008,8 @@ function _disable_method(inputArguments: VariantLike[], context: ISessionContext
 
     // c8 ignore next
     if (!(conditionNode instanceof UAConditionImpl)) {
-        debugLog("conditionNode is not a UACondition ", conditionNode?.toString());
+        // c8 ignore next
+        doDebug && debugLog("conditionNode is not a UACondition ", conditionNode?.toString());
         return callback(null, {
             statusCode: StatusCodes.BadNodeIdInvalid
         });
@@ -1210,7 +1213,6 @@ function _create_new_branch_id() {
     return makeNodeId(randomGuid(), 1);
 }
 
-// tslint:disable:no-console
 function _install_condition_variable_type<T, DT extends DataType>(node: UAConditionVariable<T, DT>) {
     // from spec 1.03 : 5.3 condition variables
     // However,  a change in their value is considered important and supposed to trigger

package/src/alarms_and_conditions/ua_discrete_alarm_impl.ts

@@ -15,7 +15,7 @@ import { UAAlarmConditionImplBase } from "./ua_alarm_condition_impl.js";
  * Alarm may take on only a certain number of possible values (e.g. true/false,
  * running/stopped/terminating).
  */
-export class UADiscreteAlarmImplBase extends UAAlarmConditionImplBase  {
+export class UADiscreteAlarmImplBase extends UAAlarmConditionImplBase {
     public static instantiate(
         namespace: INamespace,
         discreteAlarmTypeId: UAEventType | NodeId | string,
@@ -32,10 +32,13 @@ export class UADiscreteAlarmImplBase extends UAAlarmConditionImplBase  {
 
         const discreteAlarmTypeBase = addressSpace.findObjectType("DiscreteAlarmType");
         assert(discreteAlarmTypeBase, "expecting DiscreteAlarmType - please check you nodeset xml file!");
+        if (!discreteAlarmTypeBase) {
+            throw new Error("expecting DiscreteAlarmType - please check you nodeset xml file!");
+        }
 
         /* eventTypeNode should be subtypeOf("DiscreteAlarmType"); */
         /* c8 ignore next */
-        if (!discreteAlarmType.isSubtypeOf(discreteAlarmTypeBase as any)) {
+        if (!discreteAlarmType.isSubtypeOf(discreteAlarmTypeBase)) {
             throw new Error("UADiscreteAlarm.instantiate : event found is not subType of DiscreteAlarmType");
         }
 
@@ -44,11 +47,11 @@ export class UADiscreteAlarmImplBase extends UAAlarmConditionImplBase  {
             discreteAlarmType.nodeId,
             options,
             data
-        ) as  unknown as UADiscreteAlarm;
+        ) as unknown as UADiscreteAlarm;
         Object.setPrototypeOf(alarmNode, UADiscreteAlarmImplBase.prototype);
 
-        return alarmNode as unknown as  UADiscreteAlarmImpl;
+        return alarmNode as unknown as UADiscreteAlarmImpl;
     }
 }
 export type UADiscreteAlarmImpl = UADiscreteAlarmImplBase & UADiscreteAlarmEx;
-export const UADiscreteAlarmImpl = UADiscreteAlarmImplBase as unknown as UADiscreteAlarmImpl;
+export const UADiscreteAlarmImpl = UADiscreteAlarmImplBase as unknown as UADiscreteAlarmImpl;

package/src/alarms_and_conditions/ua_non_exclusive_limit_alarm_impl.ts

@@ -1,4 +1,3 @@
-/* eslint-disable max-statements */
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */

package/src/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -39,7 +39,6 @@ export declare interface UAOffNormalAlarmEx
     setNormalStateValue(value: NodeIdLike): void;
 }
 
-
 const $ = (instance: UAOffNormalAlarmImplBase): UAOffNormalAlarmEx => instance as unknown as UAOffNormalAlarmEx;
 /**
  * The OffNormalAlarmType is a specialization of the DiscreteAlarmType intended to represent a

package/src/apply_condition_refresh.ts

@@ -8,7 +8,7 @@ export function apply_condition_refresh(this: UAObject | UAVariable, cache?: Con
     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) {

package/src/base_node_impl.ts

@@ -7,7 +7,7 @@ import chalk from "chalk";
 import {
     type AddReferenceOpts,
     type AttributeEventName,
-    type BaseNode, 
+    type BaseNode,
     type BaseNodeEvents,
     type BrowseDescriptionOptions2,
     type IAddressSpace,
@@ -23,7 +23,7 @@ import {
     type UAReference,
     type UAReferenceType,
     type UAVariable,
-    type UAVariableType 
+    type UAVariableType
 } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import type { UAString } from "node-opcua-basic-types";
@@ -85,9 +85,6 @@ import { type MinimalistAddressSpace, ReferenceImpl } from "./reference_impl";
 import { coerceRolePermissions } from "./role_permissions";
 
 type ApplyFunc = { apply: (...args: unknown[]) => void };
-// tslint:disable:no-var-requires
-// tslint:disable:no-bitwise
-// tslint:disable:no-console
 
 const doDebug = false;
 const warningLog = make_warningLog(__filename);
@@ -156,8 +153,10 @@ export function makeAttributeEventName(attributeId: AttributeIds): AttributeEven
  *
  */
 
-export abstract class BaseNodeImpl<T extends BaseNodeEvents & ListenerSignature<T> = BaseNodeEvents> 
-extends TypedEventEmitter<T> implements BaseNode<T> {
+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);
     }
@@ -614,7 +613,7 @@ extends TypedEventEmitter<T> implements BaseNode<T> {
         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]  as UAMethod: null;
+        return select.length === 1 ? (select[0] as UAMethod) : null;
     }
 
     public getWriteMask(): number {
@@ -857,7 +856,8 @@ extends TypedEventEmitter<T> implements BaseNode<T> {
 
         /* c8 ignore next */
         if (do_debug) {
-            debugLog("all references :", this.nodeId.toString(), this.browseName.toString());
+            // c8 ignore next
+            doDebug && debugLog("all references :", this.nodeId.toString(), this.browseName.toString());
             dumpReferences(addressSpace, _private._referenceIdx.values());
         }
 
@@ -949,6 +949,16 @@ extends TypedEventEmitter<T> implements BaseNode<T> {
         } else if (_private._back_referenceIdx.has(h)) {
             relatedNode.removeReference(backwardReference);
         } else {
+            // A back reference of a massively used type was never installed: _propagate_ref
+            // skips HasTypeDefinition and HasModellingRule deliberately, "because there are
+            // too many". Removal has to mirror that, or detaching any node asks its type
+            // definition to drop a reference it never held - which is where the hundred-odd
+            // "Cannot find reference to remove: ns=0;i=40" lines per run came from. The
+            // absence is the designed state, not a fault worth reporting.
+            const referenceType = resolveReferenceType(addressSpace, reference);
+            if (!reference.isForward && referenceType && _is_massively_used_reference(referenceType)) {
+                return;
+            }
             warningLog(`Cannot find reference to remove: ${reference.toString()}`);
         }
     }
@@ -1018,7 +1028,6 @@ extends TypedEventEmitter<T> implements BaseNode<T> {
         if (Object.hasOwn(reservedNames, name)) {
             // c8 ignore next
             if (doDebug) {
-                // tslint:disable-next-line:no-console
                 debugLog(chalk.bgWhite.red(`Ignoring reserved keyword  ${name}`));
             }
             return;
@@ -1542,11 +1551,13 @@ function toObject(addressSpace: IAddressSpace, reference: UAReference): BaseNode
     const obj = resolveReferenceNode(addressSpace, reference);
     // c8 ignore next
     if (doDebug && !obj) {
-        debugLog(
-            chalk.red(" Warning :  object with nodeId ") +
-                chalk.cyan(reference.nodeId.toString()) +
-                chalk.red(" cannot be found in the address space !")
-        );
+        // c8 ignore next
+        doDebug &&
+            debugLog(
+                chalk.red(" Warning :  object with nodeId ") +
+                    chalk.cyan(reference.nodeId.toString()) +
+                    chalk.red(" cannot be found in the address space !")
+            );
     }
     return obj;
 }
@@ -1613,11 +1624,7 @@ 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);
 
@@ -1769,20 +1776,12 @@ 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;
@@ -1802,11 +1801,7 @@ function _filter_by_nodeClass(
     });
 }
 
-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

@@ -1,9 +1,6 @@
-/* eslint-disable complexity */
-/* eslint-disable max-statements */
 /**
  * @module node-opcua-address-space.Private
  */
-// tslint:disable:no-bitwise
 import chalk from "chalk";
 import type {
     BaseNode,
@@ -44,7 +41,6 @@ import { UANamespace_process_modelling_rule } from "./namespace_private";
 import { ReferenceImpl } from "./reference_impl";
 import { wipeMemorizedStuff } from "./tool_isSubtypeOf";
 
-// eslint-disable-next-line prefer-const
 const errorLog = make_errorLog("address-space:BaseNode");
 const doTrace = checkDebugFlag("INSTANTIATE");
 const traceLog = errorLog;
@@ -618,7 +614,6 @@ function _clone_collection_new(
 
         // c8 ignore next
         if (typeof node.clone !== "function") {
-            // tslint:disable-next-line:no-console
             warningLog(
                 chalk.red("Warning : cannot clone node ") +
                     fullPath2(node) +
@@ -1278,7 +1273,6 @@ export function BaseNode_add_backward_reference(this: BaseNodeImpl, reference: U
         warningLog("    ", reference.toString(opts));
         warningLog(" already found in ===>");
         warningLog([..._private._back_referenceIdx.values()].map((c: UAReference) => c.toString(opts)).join("\n"));
-        // tslint:disable-next-line:no-console
         warningLog("===>");
         throw new Error("reference exists already in _back_references");
     }

package/src/extension_object_array_node.ts

@@ -2,9 +2,9 @@
  * @module node-opcua-address-space.Private
  */
 
-import type { UADataType, UADynamicVariableArray, UAObject, UAReferenceType, UAVariable } from "node-opcua-address-space-base";
+import type { BindVariableOptionsVariation1, UADynamicVariableArray, UAObject, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { BrowseDirection, NodeClass } from "node-opcua-data-model";
+import { BrowseDirection, NodeClass, type QualifiedName, type QualifiedNameLike } from "node-opcua-data-model";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
 import type { NodeId } from "node-opcua-nodeid";
@@ -52,7 +52,11 @@ function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UA
         throw new Error(" cannot find component ");
     }
 
-    const hasComponent = uaArrayVariableNode.addressSpace.findReferenceType("HasComponent")! as UAReferenceType;
+    const hasComponent = uaArrayVariableNode.addressSpace.findReferenceType("HasComponent");
+    // c8 ignore next
+    if (!hasComponent) {
+        throw new Error("cannot find HasComponent reference type: please check your nodeset file");
+    }
 
     // remove the hasComponent reference toward node
     uaArrayVariableNode.removeReference({
@@ -68,11 +72,22 @@ function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UA
     }
 }
 
+export interface CreateExtObjArrayNodeOptions {
+    browseName: QualifiedNameLike;
+    complexVariableType: string | NodeId;
+    variableType: string | NodeId;
+    indexPropertyName: string;
+    minimumSamplingInterval?: number;
+}
+
 /**
  *
  * create a node Variable that contains a array of ExtensionObject of a given type
  */
-export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: UAObject, options: any): UADynamicVariableArray<T> {
+export function createExtObjArrayNode<T extends ExtensionObject>(
+    parentFolder: UAObject,
+    options: CreateExtObjArrayNodeOptions
+): UADynamicVariableArray<T> {
     assert(typeof options.variableType === "string");
     assert(typeof options.indexPropertyName === "string");
 
@@ -93,7 +108,10 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
     assert(!variableType.nodeId.isEmpty());
 
     const structure = addressSpace.findDataType("Structure");
-    assert(structure, "Structure Type not found: please check your nodeset file");
+    // c8 ignore next
+    if (!structure) {
+        throw new Error("Structure Type not found: please check your nodeset file");
+    }
 
     const dataType = addressSpace.findDataType(variableType.dataType);
 
@@ -103,7 +121,7 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
         throw new Error("cannot find Data Type");
     }
 
-    assert(dataType.isSubtypeOf(structure as any), "expecting a structure (= ExtensionObject) here ");
+    assert(dataType.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
 
     const inner_options = {
         componentOf: parentFolder,
@@ -117,6 +135,10 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
 
     const uaArrayVariableNode = namespace.addVariable(inner_options) as UADynamicVariableArray<T>;
 
+    if (options.minimumSamplingInterval !== undefined) {
+        uaArrayVariableNode.minimumSamplingInterval = options.minimumSamplingInterval;
+    }
+
     bindExtObjArrayNode(uaArrayVariableNode, options.variableType, options.indexPropertyName);
 
     return uaArrayVariableNode;
@@ -134,7 +156,7 @@ function _getElementBrowseName<T extends ExtensionObject>(
     }
     // assert(extObj.constructor === addressSpace.constructExtensionObject(dataType));
     assert(Object.hasOwn(extObj, indexPropertyName1));
-    const browseName = (extObj as any)[indexPropertyName1].toString();
+    const browseName = (extObj as unknown as Record<string, { toString(): string }>)[indexPropertyName1].toString();
     return browseName;
 }
 
@@ -172,18 +194,25 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
     uaArrayVariableNode.$$variableType = variableType;
 
     // verify that an object with same doesn't already exist
-    dataType = addressSpace.findDataType(variableType.dataType)! as UADataType;
-    assert(dataType?.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
+    dataType = addressSpace.findDataType(variableType.dataType);
+    // c8 ignore next
+    if (!dataType) {
+        throw new Error(`Cannot find DataType ${variableType.dataType.toString()}`);
+    }
+    assert(dataType.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
     assert(!uaArrayVariableNode.$$extensionObjectArray, "UAVariable ExtensionObject array already bounded");
     uaArrayVariableNode.$$dataType = dataType;
     uaArrayVariableNode.$$extensionObjectArray = [];
     uaArrayVariableNode.$$indexPropertyName = indexPropertyName;
-    uaArrayVariableNode.$$getElementBrowseName = _getElementBrowseName;
+    // _getElementBrowseName actually returns a plain string (used opaquely via .toString() by every
+    // caller), while the base interface declares QualifiedName — cast to preserve exact prior runtime behavior.
+    uaArrayVariableNode.$$getElementBrowseName = _getElementBrowseName as unknown as (obj: T, index: number) => QualifiedName;
     uaArrayVariableNode.$dataValue.value.value = uaArrayVariableNode.$$extensionObjectArray;
     uaArrayVariableNode.$dataValue.value.arrayType = VariantArrayType.Array;
 
-    const bindOptions: any = {
-        get: getExtObjArrayNodeValue,
+    const bindOptions: BindVariableOptionsVariation1 = {
+        // getExtObjArrayNodeValue is generic over `this: UADynamicVariableArray<T>`, narrower than GetFunc's `this: UAVariable`
+        get: getExtObjArrayNodeValue as unknown as BindVariableOptionsVariation1["get"],
         set: undefined // readonly
     };
     // bind the readonly
@@ -217,7 +246,7 @@ export function addElement<T extends ExtensionObject>(
 
     let extensionObject: T;
     let elVar = null;
-    let browseName;
+    let browseName: QualifiedName;
 
     if (options instanceof UAVariableImpl) {
         elVar = options;
@@ -286,7 +315,7 @@ export function removeElement<T extends ExtensionObject>(
     } else if (element?.nodeClass) {
         // find element by name
         const browseNameToFind = element.browseName.name?.toString();
-        elementIndex = _array.findIndex((obj: any, _i: number) => {
+        elementIndex = _array.findIndex((obj: T, _i: number) => {
             const browseName = uaArrayVariableNode.$$getElementBrowseName(obj, elementIndex).toString();
             return browseName === browseNameToFind;
         });
@@ -298,5 +327,5 @@ export function removeElement<T extends ExtensionObject>(
     if (elementIndex < 0) {
         throw new Error(`removeElement: cannot find element matching ${element.toString()}`);
     }
-    return removeElementByIndex(uaArrayVariableNode, elementIndex);
+    removeElementByIndex(uaArrayVariableNode, elementIndex);
 }

package/src/get_basic_datatype.ts

@@ -14,7 +14,10 @@ export function _getBasicDataTypeFromDataTypeNodeId(
     addressSpace: IAddressSpace,
     dataTypeNodeId: { nodeId: NodeIdLike } | NodeIdLike
 ): DataType {
-    const dataTypeNodeId_ = (dataTypeNodeId as any).nodeId ? (dataTypeNodeId as any).nodeId : dataTypeNodeId;
+    const dataTypeNodeId_ =
+        typeof dataTypeNodeId === "object" && dataTypeNodeId !== null && "nodeId" in dataTypeNodeId
+            ? dataTypeNodeId.nodeId
+            : dataTypeNodeId;
     const dataTypeNode = addressSpace.findDataType(dataTypeNodeId_);
     if (!dataTypeNode) {
         return DataType.Null;