node-opcua-address-space 2.177.0 → 2.179.0

package/source/pseudo_session.ts

@@ -150,17 +150,24 @@ export class PseudoSession implements IBasicSession {
     public browse(nodesToBrowse: BrowseDescriptionLike[], callback: ResponseCallback<BrowseResult[]>): void;
     public browse(nodeToBrowse: BrowseDescriptionLike): Promise<BrowseResult>;
     public browse(nodesToBrowse: BrowseDescriptionLike[]): Promise<BrowseResult[]>;
-    public browse(nodesToBrowse: BrowseDescriptionLike | BrowseDescriptionLike[], callback?: ResponseCallback<any>): any {
+    public browse(
+        nodesToBrowse: BrowseDescriptionLike | BrowseDescriptionLike[],
+        callback?: ResponseCallback<BrowseResult> | ResponseCallback<BrowseResult[]>
+        // biome-ignore lint/suspicious/noConfusingVoidType: implementation must satisfy both the void (callback) and Promise<T> (thenify-wrapped) overloads; biome's suggested undefined-in-union fix breaks the "not all code paths return a value" check
+    ): void | Promise<BrowseResult> | Promise<BrowseResult[]> {
         const isArray = Array.isArray(nodesToBrowse);
         if (!isArray) {
-            return this.browse([nodesToBrowse as BrowseDescriptionLike], (err, results) => {
-                return callback?.(err, results ? results[0] : undefined);
+            const callbackSingle = callback as ResponseCallback<BrowseResult> | undefined;
+            this.browse([nodesToBrowse as BrowseDescriptionLike], (err, results) => {
+                callbackSingle?.(err, results ? results[0] : undefined);
             });
+            return;
         }
+        const callbackArray = callback as ResponseCallback<BrowseResult[]> | undefined;
         const browseAll = (nodesToBrowse: BrowseDescriptionOptions[], callack: ResponseCallback<BrowseResult[]>) => {
             const results: BrowseResult[] = [];
             for (const browseDescription of nodesToBrowse as BrowseDescriptionOptions[]) {
-                browseDescription.referenceTypeId = resolveNodeId(browseDescription.referenceTypeId!);
+                browseDescription.referenceTypeId = resolveNodeId(browseDescription.referenceTypeId || NodeId.nullNodeId);
                 const _browseDescription = coerceBrowseDescription(browseDescription);
                 const nodeId = resolveNodeId(_browseDescription.nodeId);
                 const r = this[$addressSpace].browseSingleNode(nodeId, _browseDescription, this[$context]);
@@ -179,7 +186,7 @@ export class PseudoSession implements IBasicSession {
                     maxBrowseContinuationPoints: this.maxBrowseContinuationPoints
                 },
                 nodesToBrowse as BrowseDescriptionOptions[],
-                callback
+                callbackArray
             );
         });
     }
@@ -188,7 +195,11 @@ export class PseudoSession implements IBasicSession {
     public read(nodesToRead: ReadValueIdOptions[], callback: ResponseCallback<DataValue[]>): void;
     public read(nodeToRead: ReadValueIdOptions): Promise<DataValue>;
     public read(nodesToRead: ReadValueIdOptions[]): Promise<DataValue[]>;
-    public read(nodesToRead: ReadValueIdOptions[] | ReadValueIdOptions, callback?: ResponseCallback<any>): any {
+    public read(
+        nodesToRead: ReadValueIdOptions[] | ReadValueIdOptions,
+        callback?: ResponseCallback<DataValue> | ResponseCallback<DataValue[]>
+        // biome-ignore lint/suspicious/noConfusingVoidType: implementation must satisfy both the void (callback) and Promise<T> (thenify-wrapped) overloads; biome's suggested undefined-in-union fix breaks the "not all code paths return a value" check
+    ): void | Promise<DataValue> | Promise<DataValue[]> {
         const isArray = Array.isArray(nodesToRead);
         if (!isArray) {
             nodesToRead = [nodesToRead as ReadValueIdOptions];
@@ -197,7 +208,10 @@ export class PseudoSession implements IBasicSession {
         const context = this[$context];
 
         const readV = async (nodeToRead: ReadValueIdOptions): Promise<DataValue> => {
-            const obj = this[$addressSpace].findNode(nodeToRead.nodeId!);
+            if (!nodeToRead.nodeId) {
+                return new DataValue({ statusCode: StatusCodes.BadNodeIdUnknown });
+            }
+            const obj = this[$addressSpace].findNode(nodeToRead.nodeId);
             if (!obj) {
                 return new DataValue({ statusCode: StatusCodes.BadNodeIdUnknown });
             }
@@ -206,15 +220,23 @@ export class PseudoSession implements IBasicSession {
                 return await (obj as UAVariable).readValueAsync(context);
             }
             assert(!!nodeToRead.nodeId, "expecting a nodeId");
-            assert(!!nodeToRead.attributeId, "expecting a attributeId");
-            const attributeId = nodeToRead.attributeId!;
+            if (!nodeToRead.attributeId) {
+                throw new Error("expecting a attributeId");
+            }
+            const attributeId = nodeToRead.attributeId;
             const indexRange = nodeToRead.indexRange;
             const dataEncoding = nodeToRead.dataEncoding;
             const dataValue = obj.readAttribute(context, attributeId, indexRange, dataEncoding);
             return dataValue;
         };
         Promise.all(_nodesToRead.map(async (nodeToRead: ReadValueIdOptions) => await readV(nodeToRead)))
-            .then((dataValues) => callback?.(null, isArray ? dataValues : dataValues[0]))
+            .then((dataValues) => {
+                if (isArray) {
+                    (callback as ResponseCallback<DataValue[]> | undefined)?.(null, dataValues);
+                } else {
+                    (callback as ResponseCallback<DataValue> | undefined)?.(null, dataValues[0]);
+                }
+            })
             .catch((err) => callback?.(err));
     }
 
@@ -236,22 +258,26 @@ export class PseudoSession implements IBasicSession {
     public browseNext(
         continuationPoints: Buffer | Buffer[],
         releaseContinuationPoints: boolean,
-        callback?: ResponseCallback<any>
-    ): any {
+        callback?: ResponseCallback<BrowseResult> | ResponseCallback<BrowseResult[]>
+        // biome-ignore lint/suspicious/noConfusingVoidType: implementation must satisfy both the void (callback) and Promise<T> (thenify-wrapped) overloads; biome's suggested undefined-in-union fix breaks the "not all code paths return a value" check
+    ): void | Promise<BrowseResult> | Promise<BrowseResult[]> {
         setImmediate(() => {
             if (continuationPoints instanceof Buffer) {
-                return this.browseNext([continuationPoints], releaseContinuationPoints, (err, _results) => {
+                const callbackSingle = callback as ResponseCallback<BrowseResult> | undefined;
+                this.browseNext([continuationPoints], releaseContinuationPoints, (err, _results) => {
                     if (err) {
-                        return callback?.(err);
+                        callbackSingle?.(err);
+                        return;
                     }
-                    callback?.(null, _results?.[0]);
+                    callbackSingle?.(null, _results?.[0]);
                 });
+                return;
             }
             innerBrowseNext(
                 { continuationPointManager: this.continuationPointManager },
                 continuationPoints as Buffer[],
                 releaseContinuationPoints,
-                callback
+                callback as ResponseCallback<BrowseResult[]> | undefined
             );
         });
     }
@@ -261,7 +287,11 @@ export class PseudoSession implements IBasicSession {
     public call(methodsToCall: CallMethodRequestLike[], callback: ResponseCallback<CallMethodResult[]>): void;
     public call(methodToCall: CallMethodRequestLike): Promise<CallMethodResult>;
     public call(methodsToCall: CallMethodRequestLike[]): Promise<CallMethodResult[]>;
-    public call(methodsToCall: CallMethodRequestLike | CallMethodRequestLike[], callback?: ResponseCallback<any>): any {
+    public call(
+        methodsToCall: CallMethodRequestLike | CallMethodRequestLike[],
+        callback?: ResponseCallback<CallMethodResult> | ResponseCallback<CallMethodResult[]>
+        // biome-ignore lint/suspicious/noConfusingVoidType: implementation must satisfy both the void (callback) and Promise<T> (thenify-wrapped) overloads; biome's suggested undefined-in-union fix breaks the "not all code paths return a value" check
+    ): void | Promise<CallMethodResult> | Promise<CallMethodResult[]> {
         const isArray = Array.isArray(methodsToCall);
         if (!isArray) {
             methodsToCall = [methodsToCall as CallMethodRequestLike];
@@ -281,7 +311,11 @@ export class PseudoSession implements IBasicSession {
             })
         )
             .then((callMethodResults) => {
-                callback?.(null, isArray ? callMethodResults : callMethodResults[0]);
+                if (isArray) {
+                    (callback as ResponseCallback<CallMethodResult[]> | undefined)?.(null, callMethodResults);
+                } else {
+                    (callback as ResponseCallback<CallMethodResult> | undefined)?.(null, callMethodResults[0]);
+                }
             })
             .catch((err) => {
                 callback?.(err);
@@ -290,7 +324,11 @@ export class PseudoSession implements IBasicSession {
 
     public getArgumentDefinition(methodId: MethodId): Promise<ArgumentDefinition>;
     public getArgumentDefinition(methodId: MethodId, callback: ResponseCallback<ArgumentDefinition>): void;
-    public getArgumentDefinition(methodId: MethodId, callback?: ResponseCallback<ArgumentDefinition>): any {
+    public getArgumentDefinition(
+        methodId: MethodId,
+        callback?: ResponseCallback<ArgumentDefinition>
+        // biome-ignore lint/suspicious/noConfusingVoidType: implementation must satisfy both the void (callback) and Promise<T> (thenify-wrapped) overloads; biome's suggested undefined-in-union fix breaks the "not all code paths return a value" check
+    ): void | Promise<ArgumentDefinition> {
         getArgumentDefinitionHelper(this, methodId)
             .then((result) => {
                 callback?.(null, result);
@@ -304,7 +342,11 @@ export class PseudoSession implements IBasicSession {
     public translateBrowsePath(browsePath: BrowsePath, callback: ResponseCallback<BrowsePathResult>): void;
     public translateBrowsePath(browsePath: BrowsePath): Promise<BrowsePathResult>;
     public translateBrowsePath(browsePaths: BrowsePath[]): Promise<BrowsePathResult[]>;
-    public translateBrowsePath(browsePaths: BrowsePath[] | BrowsePath, callback?: ResponseCallback<any>): any {
+    public translateBrowsePath(
+        browsePaths: BrowsePath[] | BrowsePath,
+        callback?: ResponseCallback<BrowsePathResult> | ResponseCallback<BrowsePathResult[]>
+        // biome-ignore lint/suspicious/noConfusingVoidType: implementation must satisfy both the void (callback) and Promise<T> (thenify-wrapped) overloads; biome's suggested undefined-in-union fix breaks the "not all code paths return a value" check
+    ): void | Promise<BrowsePathResult> | Promise<BrowsePathResult[]> {
         const isArray = Array.isArray(browsePaths);
         if (!isArray) {
             browsePaths = [browsePaths as BrowsePath];
@@ -312,23 +354,32 @@ export class PseudoSession implements IBasicSession {
         const browsePathResults = (browsePaths as BrowsePath[]).map((browsePath: BrowsePath) => {
             return this[$addressSpace].browsePath(browsePath);
         });
-        callback?.(null, isArray ? browsePathResults : browsePathResults[0]);
+        if (isArray) {
+            (callback as ResponseCallback<BrowsePathResult[]> | undefined)?.(null, browsePathResults);
+        } else {
+            (callback as ResponseCallback<BrowsePathResult> | undefined)?.(null, browsePathResults[0]);
+        }
     }
     public write(nodeToWrite: WriteValueOptions, callback: ResponseCallback<StatusCode>): void;
     public write(nodesToWrite: WriteValueOptions[], callback: ResponseCallback<StatusCode[]>): void;
     public write(nodeToWrite: WriteValueOptions): Promise<StatusCode>;
     public write(nodesToWrite: WriteValueOptions[]): Promise<StatusCode[]>;
-    public write(nodesToWrite: WriteValueOptions[] | WriteValueOptions, callback?: ResponseCallback<any>): any {
+    public write(
+        nodesToWrite: WriteValueOptions[] | WriteValueOptions,
+        callback?: ResponseCallback<StatusCode> | ResponseCallback<StatusCode[]>
+        // biome-ignore lint/suspicious/noConfusingVoidType: implementation must satisfy both the void (callback) and Promise<T> (thenify-wrapped) overloads; biome's suggested undefined-in-union fix breaks the "not all code paths return a value" check
+    ): void | Promise<StatusCode> | Promise<StatusCode[]> {
         const isArray = Array.isArray(nodesToWrite);
         const _nodesToWrite: WriteValueOptions[] = !isArray ? [nodesToWrite] : nodesToWrite;
         const context = this[$context];
         setImmediate(() => {
             const statusCodesPromises = _nodesToWrite.map((nodeToWrite: WriteValueOptions) => {
-                assert(!!nodeToWrite.nodeId, "expecting a nodeId");
                 assert(!!nodeToWrite.attributeId, "expecting a attributeId");
 
-                const nodeId = nodeToWrite.nodeId!;
-                const obj = this[$addressSpace].findNode(nodeId);
+                if (!nodeToWrite.nodeId) {
+                    return StatusCodes.BadNodeIdUnknown;
+                }
+                const obj = this[$addressSpace].findNode(nodeToWrite.nodeId);
                 if (!obj) {
                     return StatusCodes.BadNodeIdUnknown;
                 }
@@ -340,7 +391,11 @@ export class PseudoSession implements IBasicSession {
             });
             Promise.all(statusCodesPromises)
                 .then((statusCodes) => {
-                    callback?.(null, isArray ? statusCodes : statusCodes[0]);
+                    if (isArray) {
+                        (callback as ResponseCallback<StatusCode[]> | undefined)?.(null, statusCodes as StatusCode[]);
+                    } else {
+                        (callback as ResponseCallback<StatusCode> | undefined)?.(null, statusCodes[0]);
+                    }
                 })
                 .catch((err) => {
                     callback?.(err);
@@ -349,8 +404,6 @@ export class PseudoSession implements IBasicSession {
     }
 }
 
-// tslint:disable:no-var-requires
-// tslint:disable:max-line-length
 import { withCallback } from "thenify-ex";
 
 PseudoSession.prototype.read = withCallback(PseudoSession.prototype.read);

package/source/session_context.ts

@@ -70,6 +70,7 @@ function getUserName(userIdentityToken: AnyUserIdentityToken): string {
 // The canonical definition now lives in node-opcua-constants so that
 // client-side packages can use it without pulling in address-space.
 import { WellKnownRoles } from "node-opcua-constants";
+
 export { WellKnownRoles } from "node-opcua-constants";
 
 /** @deprecated Use WellKnownRoles instead */

package/source/xml_writer.ts

@@ -3,7 +3,7 @@ export type TranslationTable = Map<number, number>;
 export interface XmlWriter {
     translationTable: TranslationTable;
     priorityTable: number[];
-    visitedNode: Set<any>;
+    visitedNode: Set<string>;
 
     startDocument(options: { encoding: string; version: string }): void;
     startElement(elementName: string): this;

package/src/_instantiate_helpers.ts

@@ -1,8 +1,6 @@
 /**
  * @module node-opcua-address-space
  */
-// tslint:disable:max-classes-per-file
-// tslint:disable:no-console
 import chalk from "chalk";
 import {
     CloneHelper,
@@ -26,7 +24,6 @@ import { _clone_hierarchical_references } from "./base_node_private";
 const warningLog = make_warningLog("INSTANTIATE");
 const errorLog = make_errorLog("INSTANTIATE");
 
-// eslint-disable-next-line prefer-const
 const doTrace = checkDebugFlag("INSTANTIATE");
 const traceLog = errorLog;
 

package/src/_mandatory_child_or_requested_optional_filter.ts

@@ -18,20 +18,19 @@ const errorLog = make_errorLog(__filename);
 const doTrace = checkDebugFlag("INSTANTIATE");
 const traceLog = errorLog;
 
-export type OptionalMap = Record<string, string | Record<string, any>>;
+export interface OptionalMap {
+    [key: string]: OptionalMap;
+}
 export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
     private readonly optionalsMap: OptionalMap;
     private readonly references: UAReference[];
     private readonly copyAlsoAllOptionals: boolean = false;
 
-    private readonly _instance: BaseNode;
-
     constructor(instance: BaseNode, copyAlsoAllOptionals: boolean, optionalsMap: OptionalMap) {
         this.copyAlsoAllOptionals = copyAlsoAllOptionals;
         // should we clone the node to be a component or propertyOf of a instance
         assert(null !== instance);
         this.optionalsMap = optionalsMap;
-        this._instance = instance;
         this.references = instance.findReferencesEx("Aggregates", BrowseDirection.Forward);
     }
 

package/src/address_space.ts

@@ -9,6 +9,8 @@ import type {
     IEventData,
     IHistoricalDataNodeOptions,
     ISessionContext,
+    IVariableHistorian,
+    IVariableHistorianOptions,
     MethodCallInterceptor,
     RaiseEventData,
     ShutdownTask,
@@ -75,7 +77,6 @@ const errorLog = make_errorLog(__filename);
 const debugLog = make_debugLog(__filename);
 const warningLog = make_warningLog(__filename);
 
-// tslint:disable-next-line:no-var-requires
 const Dequeue = require("dequeue");
 
 const regexNumberColumnString = /^([0-9]+):(.*)/;
@@ -152,6 +153,10 @@ function isNodeIdString(str: unknown): boolean {
  *
  *     const addressSpace = AddressSpace.create();
  */
+export interface IHistorizerFactory {
+    create(node: UAVariable, options: IVariableHistorianOptions): IVariableHistorian;
+}
+
 export class AddressSpace implements AddressSpacePrivate {
     public get rootFolder(): UARootFolder {
         const rootFolder = this.findNode(this.resolveNodeId("RootFolder"));
@@ -163,7 +168,7 @@ export class AddressSpace implements AddressSpacePrivate {
     }
 
     public static isNonEmptyQualifiedName = isNonEmptyQualifiedName;
-    public static historizerFactory?: any;
+    public static historizerFactory?: IHistorizerFactory;
 
     public static create(): AddressSpace {
         return new AddressSpace();
@@ -184,6 +189,8 @@ export class AddressSpace implements AddressSpacePrivate {
     private readonly _private_namespaceIndex: number;
     private readonly _namespaceArray: NamespacePrivate[];
     private _shutdownTask?: ShutdownTask[];
+    private _eventIdCounter?: Buffer;
+    public $$extraDataTypeManager?: ExtraDataTypeManager;
     private _modelChangeTransactionCounter = 0;
     private _modelChanges: ModelChangeStructureDataType[] = [];
     public _methodCallInterceptors: MethodCallInterceptor[] = [];
@@ -213,12 +220,10 @@ export class AddressSpace implements AddressSpacePrivate {
      * @internal
      */
     public getDataTypeManager(): ExtraDataTypeManager {
-        const addressSpacePriv: any = this as any;
-        assert(
-            addressSpacePriv.$$extraDataTypeManager,
-            "expecting a $$extraDataTypeManager please make sure ensureDatatypeExtracted is called"
-        );
-        return addressSpacePriv.$$extraDataTypeManager;
+        if (!this.$$extraDataTypeManager) {
+            throw new Error("expecting a $$extraDataTypeManager please make sure ensureDatatypeExtracted is called");
+        }
+        return this.$$extraDataTypeManager;
     }
 
     public getNamespaceUri(namespaceIndex: number): string {
@@ -283,7 +288,7 @@ export class AddressSpace implements AddressSpacePrivate {
     public registerNamespace(namespaceUri: string): NamespacePrivate {
         let index = this._namespaceArray.findIndex((ns) => ns.namespaceUri === namespaceUri);
         if (index !== -1) {
-            assert((this._namespaceArray[index].addressSpace as any) === (this as any));
+            assert(this._namespaceArray[index].addressSpace === this);
             return this._namespaceArray[index];
         }
         index = this._namespaceArray.length;
@@ -454,7 +459,7 @@ export class AddressSpace implements AddressSpacePrivate {
         if (dataType instanceof UADataTypeImpl) {
             return this.findDataType(dataType.nodeId);
         } else if (dataType instanceof NodeId) {
-            return _find_by_node_id<UADataType>(this, dataType!, namespaceIndex);
+            return _find_by_node_id<UADataType>(this, dataType, namespaceIndex);
         }
         if (typeof dataType === "number") {
             if (DataType[dataType] !== undefined) {
@@ -492,11 +497,12 @@ export class AddressSpace implements AddressSpacePrivate {
         }
 
         if (dataTypeNode instanceof NodeId) {
-            dataTypeNode = this.findDataType(dataTypeNode)!;
+            const foundDataTypeNode = this.findDataType(dataTypeNode);
             /* c8 ignore next */
-            if (!dataTypeNode) {
+            if (!foundDataTypeNode) {
                 throw Error(`cannot find dataTypeNode ${_orig_dataTypeNode.toString()}`);
             }
+            dataTypeNode = foundDataTypeNode;
         }
         /* c8 ignore next */
         if (!(dataTypeNode instanceof UADataTypeImpl)) {
@@ -669,16 +675,15 @@ export class AddressSpace implements AddressSpacePrivate {
          *
          */
         const offset = 16;
-        const self = this as any;
-        if (!self._eventIdCounter) {
-            self._eventIdCounter = randomBytes(20);
-            self._eventIdCounter.writeInt32BE(0, offset);
+        if (!this._eventIdCounter) {
+            this._eventIdCounter = randomBytes(20);
+            this._eventIdCounter.writeInt32BE(0, offset);
         }
-        self._eventIdCounter.writeInt32BE(self._eventIdCounter.readInt32BE(offset) + 1, offset);
+        this._eventIdCounter.writeInt32BE(this._eventIdCounter.readInt32BE(offset) + 1, offset);
 
         return new Variant({
             dataType: DataType.ByteString,
-            value: Buffer.from(self._eventIdCounter)
+            value: Buffer.from(this._eventIdCounter)
         }) as VariantT<Buffer, DataType.ByteString>;
     }
 
@@ -758,7 +763,7 @@ export class AddressSpace implements AddressSpacePrivate {
             throw new Error("BaseObjectType must be defined in the address space");
         }
 
-        const hasProperty = (data: any, propertyName: string): boolean => Object.hasOwn(data, propertyName);
+        const hasProperty = (data: RaiseEventData, propertyName: string): boolean => Object.hasOwn(data, propertyName);
 
         const visitedProperties: { [key: string]: number } = {};
         const alreadyVisited = (key: string) => Object.hasOwn(visitedProperties, key);
@@ -781,7 +786,6 @@ export class AddressSpace implements AddressSpacePrivate {
                 // c8 ignore next
                 if (doDebug) {
                     if (node.modellingRule === "Mandatory") {
-                        // tslint:disable:no-console
                         errorLog(
                             chalk.red("ERROR : AddressSpace#constructEventData(eventType,options) " + "cannot find property ") +
                                 self.browseName.toString() +
@@ -822,7 +826,7 @@ export class AddressSpace implements AddressSpacePrivate {
             });
         }
 
-        const populate_data = (self: any, eventData1: any) => {
+        const populate_data = (self: UAObjectType, eventData1: EventData) => {
             if (sameNodeId(baseObjectType?.nodeId, self.nodeId)) {
                 return; // nothing to do
             }
@@ -839,7 +843,8 @@ export class AddressSpace implements AddressSpacePrivate {
                 throw new Error(chalk.red("Cannot find object with nodeId ") + baseTypeNodeId);
             }
 
-            populate_data(baseType, eventData1);
+            // subtypeOf always points to another node in the ObjectType hierarchy
+            populate_data(baseType as UAObjectType, eventData1);
 
             // get properties and components from base class
             const properties = self.getProperties();
@@ -853,7 +858,7 @@ export class AddressSpace implements AddressSpacePrivate {
 
             for (const node of children) {
                 // only keep those that have a "HasModellingRule"
-                if (!(node as any).modellingRule) {
+                if (!node.modellingRule) {
                     continue;
                 }
                 // ignore also methods
@@ -1022,13 +1027,26 @@ export class AddressSpace implements AddressSpacePrivate {
         const _dataType = dataType as UADataTypeImpl;
 
         // to do verify that dataType is of type "Structure"
+        const structureDataType = this.findDataType("Structure");
+        /* c8 ignore next */
+        if (!structureDataType) {
+            throw new Error("getExtensionObjectConstructor: cannot find 'Structure' DataType in standard address Space");
+        }
         /* c8 ignore next */
-        if (!_dataType.isSubtypeOf(this.findDataType("Structure")!)) {
-            debugLog(_dataType.toString());
+        if (!_dataType.isSubtypeOf(structureDataType)) {
+            // c8 ignore next
+            doDebug && debugLog(_dataType.toString());
         }
-        assert(_dataType.isSubtypeOf(this.findDataType("Structure")!));
+        assert(_dataType.isSubtypeOf(structureDataType));
         if (!_dataType._extensionObjectConstructor) {
-            const dataTypeManager = (this as any).$$extraDataTypeManager as ExtraDataTypeManager;
+            if (!this.$$extraDataTypeManager) {
+                throw new Error(
+                    `getExtensionObjectConstructor: cannot build a constructor for ${_dataType.browseName.toString()} (${_dataType.nodeId.toString()}): ` +
+                        "the DataType manager is not initialised. " +
+                        "Make sure generateAddressSpace() completed successfully and/or that ensureDatatypeExtracted(addressSpace) was awaited before using structured DataTypes."
+                );
+            }
+            const dataTypeManager = this.$$extraDataTypeManager;
             _dataType._extensionObjectConstructor = dataTypeManager.getExtensionObjectConstructorFromDataType(
                 _dataType.nodeId
             ) as ExtensionObjectConstructorFuncWithSchema;
@@ -1145,7 +1163,7 @@ export class AddressSpace implements AddressSpacePrivate {
         // check if referenceTypeId is correct
         if (browseDescription.referenceTypeId instanceof NodeId) {
             if (browseDescription.referenceTypeId.value === 0) {
-                (browseDescription as any).referenceTypeId = null;
+                (browseDescription as unknown as { referenceTypeId: NodeId | null }).referenceTypeId = null;
             } else {
                 const rf = this.findNode(browseDescription.referenceTypeId);
                 if (!rf || !(rf instanceof UAReferenceTypeImpl)) {
@@ -1177,7 +1195,7 @@ export class AddressSpace implements AddressSpacePrivate {
         if (folder && !_isFolder(this, folder)) {
             throw new Error(`Parent folder must be of FolderType ${folder.typeDefinition.toString()}`);
         }
-        return folder as any as BaseNode;
+        return folder;
     }
 
     /**
@@ -1206,7 +1224,7 @@ export class AddressSpace implements AddressSpacePrivate {
     public extractRootViews(node: UAObject | UAVariable): UAView[] {
         assert(node.nodeClass === NodeClass.Object || node.nodeClass === NodeClass.Variable);
 
-        const visitedMap: any = {};
+        const visitedMap: Record<string, BaseNode> = {};
 
         const q = new Dequeue();
         q.push(node);
@@ -1267,9 +1285,9 @@ export class AddressSpace implements AddressSpacePrivate {
 
                 // https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore
                 // const nodeIds = _.uniq(this._modelChanges.map((c: any) => c.affected));
-                const nodeIds = [...new Set(this._modelChanges.map((c: any) => c.affected))];
+                const nodeIds = [...new Set(this._modelChanges.map((c) => c.affected))];
 
-                const nodes = nodeIds.map((nodeId: NodeId) => this.findNode(nodeId)!);
+                const nodes = nodeIds.map((nodeId: NodeId) => this.findNode(nodeId));
 
                 nodes.forEach(_increase_version_number);
                 // raise events
@@ -1352,8 +1370,9 @@ export class AddressSpace implements AddressSpacePrivate {
         } else {
             let _nodeId = params.nodeId as NodeId;
             assert(!!_nodeId, "missing 'nodeId' in reference");
-            if (_nodeId && (_nodeId as any).nodeId) {
-                _nodeId = (_nodeId as any).nodeId as NodeId;
+            const _nodeIdWithNodeId = _nodeId as unknown as { nodeId?: NodeId };
+            if (_nodeId && _nodeIdWithNodeId.nodeId) {
+                _nodeId = _nodeIdWithNodeId.nodeId;
             }
             _nodeId = resolveNodeId(_nodeId);
             params.nodeId = _nodeId;
@@ -1421,7 +1440,11 @@ export class AddressSpace implements AddressSpacePrivate {
     public _coerceTypeDefinition(typeDefinition: string | NodeId): NodeId {
         if (typeof typeDefinition === "string") {
             // coerce parent folder to an node
-            const typeDefinitionNode = this.findNode(typeDefinition)!;
+            const typeDefinitionNode = this.findNode(typeDefinition);
+            /* c8 ignore next */
+            if (!typeDefinitionNode) {
+                throw new Error(`_coerceTypeDefinition: cannot find node ${typeDefinition}`);
+            }
             typeDefinition = typeDefinitionNode.nodeId;
         }
         assert(typeDefinition instanceof NodeId);
@@ -1454,12 +1477,13 @@ export class AddressSpace implements AddressSpacePrivate {
         if (!baseTypeNode) {
             throw new Error(`Cannot find ObjectType or VariableType for ${baseType.toString()}`);
         }
+        const baseTypeNodeWithIsSubtypeOf = baseTypeNode as unknown as { isSubtypeOf?: (t: BaseNode) => boolean };
         /* c8 ignore next */
-        if (!(baseTypeNode as any).isSubtypeOf) {
+        if (!baseTypeNodeWithIsSubtypeOf.isSubtypeOf) {
             throw new Error(`Cannot find ObjectType or VariableType for ${baseType.toString()}`);
         }
         /* c8 ignore next */
-        if (!(baseTypeNode as any).isSubtypeOf(topMostBaseTypeNode)) {
+        if (!baseTypeNodeWithIsSubtypeOf.isSubtypeOf(topMostBaseTypeNode)) {
             throw new Error("wrong type ");
         }
         return baseTypeNode;
@@ -1486,7 +1510,7 @@ export class AddressSpace implements AddressSpacePrivate {
             throw new Error(` Cannot find  DataType  ${dataType.toString()} in standard address Space`);
         }
 
-        const enumerationNode = this.findDataType("Enumeration")!;
+        const enumerationNode = this.findDataType("Enumeration");
         if (!enumerationNode) {
             throw new Error(" Cannot find 'Enumeration' DataType in standard address Space");
         }
@@ -1495,9 +1519,9 @@ export class AddressSpace implements AddressSpacePrivate {
 
     private _coerce_Type(
         dataType: BaseNode | string | NodeId | number,
-        typeMap: any,
+        typeMap: Record<string, number | string>,
         typeMapName: string,
-        finderMethod: any
+        finderMethod: (this: AddressSpace, nodeId: NodeId) => BaseNode | null
     ): NodeId {
         if (typeof dataType === "number") {
             return this._coerce_Type(coerceNodeId(dataType), typeMap, typeMapName, finderMethod);

package/src/address_space_private.ts

@@ -36,6 +36,8 @@ export interface AddressSpacePrivate extends IAddressSpace {
 
     _condition_refresh_in_progress: boolean;
 
+    $$extraDataTypeManager?: ExtraDataTypeManager;
+
     _coerceNode(node: string | BaseNode | NodeIdLike): BaseNode | null;
 
     _coerceFolder(folder: string | BaseNode | NodeId): BaseNode | null;

package/src/alarms_and_conditions/condition_snapshot_impl.ts

@@ -31,8 +31,8 @@ function normalizeName(str: string): string {
 
 const disabledVar = new Variant({
     dataType: "StatusCode",
-    value: StatusCodes.BadConditionDisabled,
-    // statusCode: StatusCodes.BadConditionDisabled    
+    value: StatusCodes.BadConditionDisabled
+    // statusCode: StatusCodes.BadConditionDisabled
 });
 
 // list of Condition variables that should not be published as BadConditionDisabled when the condition
@@ -94,7 +94,8 @@ export class ConditionSnapshotImpl extends EventEmitter implements ConditionSnap
         for (const fullBrowsePath of this._map.keys()) {
             const node = this._node_index.get(fullBrowsePath);
             if (!node) {
-                debugLog("cannot node for find key", fullBrowsePath);
+                // c8 ignore next
+                doDebug && debugLog("cannot node for find key", fullBrowsePath);
                 continue;
             }
             if (isDisabled && !Object.hasOwn(_varTable, fullBrowsePath)) {
@@ -210,12 +211,6 @@ export class ConditionSnapshotImpl extends EventEmitter implements ConditionSnap
         }
         return variant;
     }
-
-    #_is_varValid(varName: string) {
-        const key = normalizeName(varName);
-        const variant = this._map.get(key);
-        return !(variant && variant.dataType === DataType.StatusCode && variant.value === StatusCodes.BadConditionDisabled);
-    }
     #_get_varTDefault<T>(dataType: DataType, varName: string, defaultValue: T): T {
         const variant = this.#_get_var_inner(varName);
         if (variant.dataType !== dataType) {
@@ -281,7 +276,8 @@ export class ConditionSnapshotImpl extends EventEmitter implements ConditionSnap
         const node = this._node_index.get(key);
         if (!node) {
             // for instance localTime is optional
-            debugLog(`Cannot serVar ${varName} dataType ${DataType[dataType]}`);
+            // c8 ignore next
+            doDebug && debugLog(`Cannot serVar ${varName} dataType ${DataType[dataType]}`);
             return;
         }
         assert(node.nodeClass === NodeClass.Variable);