node-opcua-address-space 2.177.0 → 2.179.0

package/source/interfaces/state_machine/ua_program_state_machine_type.ts

@@ -1,7 +1,6 @@
 /**
  * @module node-opcua-address-space
  */
-// tslint:disable:no-empty-interface
 import type { InstantiateObjectOptions, UAObjectType } from "node-opcua-address-space-base";
 import type { UAProgramStateMachine_Base } from "node-opcua-nodeset-ua";
 import type { UAStateMachineEx } from "./ua_state_machine_type";

package/source/interfaces/state_machine/ua_state_machine_type.ts

@@ -1,7 +1,6 @@
 /**
  * @module node-opcua-address-space
  */
-// tslint:disable:no-empty-interface
 
 import type {
     InstantiateObjectOptions,

package/source/loader/decode_xml_extension_object.ts

@@ -12,14 +12,14 @@ const debugLog = make_debugLog(__filename);
 const _errorLog = make_errorLog(__filename);
 
 function encodingNodeIdToDataTypeNode(addressSpace: IAddressSpace, encodingNodeId: NodeId): UADataType {
-    const encodingNode = addressSpace.findNode(encodingNodeId)!;
+    const encodingNode = addressSpace.findNode(encodingNodeId);
 
     // c8 ignore next
     if (!encodingNode) {
         throw new Error(`findDataTypeNode:  Cannot find encoding NodeId${encodingNodeId.toString()}`);
     }
     const refs = encodingNode.findReferences("HasEncoding", false);
-    const dataTypes = refs.map((ref) => addressSpace.findNode(ref.nodeId)).filter((obj: any) => obj !== null);
+    const dataTypes = refs.map((ref) => addressSpace.findNode(ref.nodeId)).filter((obj) => obj !== null);
     // c8 ignore next
     if (dataTypes.length !== 1) {
         throw new Error("Internal Error");
@@ -60,7 +60,7 @@ export function decodeXmlExtensionObject(
 ): ExtensionObject | null {
     const definitionMap = makeDefinitionMap(addressSpace);
 
-    const dataType = encodingNodeIdToDataTypeNode(addressSpace, encodingNodeId)!;
+    const dataType = encodingNodeIdToDataTypeNode(addressSpace, encodingNodeId);
 
     //  const { name, definition } = definitionMap.findDefinition(dataType.nodeId);
     // const hasOptionalFields = definition.fields!.some((field) => field.isOptional);

package/source/loader/ensure_datatype_extracted.ts

@@ -23,6 +23,10 @@ interface UADataTypePriv extends UADataType {
     $partialDefinition?: StructureField[];
 }
 
+interface AddressSpacePrivateWithDataTypeManager extends AddressSpacePrivate {
+    $$extraDataTypeManager?: ExtraDataTypeManager;
+}
+
 function fixDefinition103(addressSpace: IAddressSpace, namespaceArray: string[], dataTypeManager: ExtraDataTypeManager): void {
     // fix datatype _getDefinition();
     for (let namespaceIndex = 1; namespaceIndex < namespaceArray.length; namespaceIndex++) {
@@ -48,7 +52,7 @@ function fixDefinition103(addressSpace: IAddressSpace, namespaceArray: string[],
 }
 
 export async function ensureDatatypeExtracted(addressSpace: IAddressSpace): Promise<ExtraDataTypeManager> {
-    const addressSpacePriv: any = addressSpace as AddressSpacePrivate;
+    const addressSpacePriv = addressSpace as AddressSpacePrivateWithDataTypeManager;
 
     if (!addressSpacePriv.$$extraDataTypeManager) {
         const dataTypeManager = new ExtraDataTypeManager();
@@ -108,7 +112,7 @@ export async function ensureDatatypeExtracted(addressSpace: IAddressSpace): Prom
         // turn old <=103 structure to have valid DataTypeDefinition
         fixDefinition103(addressSpace, namespaceArray, dataTypeManager);
     }
-    return addressSpacePriv.$$extraDataTypeManager;
+    return addressSpacePriv.$$extraDataTypeManager as ExtraDataTypeManager;
 }
 
 export function ensureDatatypeExtractedWithCallback(addressSpace: IAddressSpace, callback: CallbackT<ExtraDataTypeManager>): void {

package/source/loader/generateAddressSpaceRaw.ts

@@ -2,7 +2,7 @@ import type { IAddressSpace, RequiredModel } from "node-opcua-address-space-base
 import { getMinOPCUADate } from "node-opcua-date-time";
 import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
 import type { CallbackT } from "node-opcua-status-code";
-import { type ReaderStateParser, type ReaderStateParserLike, Xml2Json } from "node-opcua-xml2json";
+import { type ReaderStateParser, type ReaderStateParserLike, Xml2Json, type XmlAttributes } from "node-opcua-xml2json";
 import type { NamespacePrivate } from "../../src/namespace_private";
 import { adjustNamespaceArray } from "../../src/nodeset_tools/adjust_namespace_array";
 import type { NodeSetLoaderOptions } from "../interfaces/nodeset_loader_options";
@@ -41,7 +41,7 @@ async function parseDependencies(xmlData: string): Promise<NodesetInfo> {
                     Models: {
                         parser: {
                             Model: {
-                                init(_elementName: string, attrs: any) {
+                                init(_elementName: string, attrs: XmlAttributes) {
                                     const modelUri = attrs.ModelUri;
                                     const version = attrs.Version;
                                     const publicationDate = new Date(Date.parse(attrs.PublicationDate));
@@ -56,7 +56,7 @@ async function parseDependencies(xmlData: string): Promise<NodesetInfo> {
                                 },
                                 parser: {
                                     RequiredModel: {
-                                        init(_elementName: string, attrs: any) {
+                                        init(_elementName: string, attrs: XmlAttributes) {
                                             const modelUri = attrs.ModelUri;
                                             const version = attrs.Version;
                                             const publicationDate = new Date(Date.parse(attrs.PublicationDate));
@@ -200,7 +200,8 @@ export async function generateAddressSpaceRaw(
     for (let index = 0; index < order.length; index++) {
         const nodesetIndex = order[index];
         const nodeset = nodesetDesc[nodesetIndex];
-        debugLog(" loading ", nodesetIndex, nodeset.xmlData.length);
+        // c8 ignore next
+        doDebug && debugLog(" loading ", nodesetIndex, nodeset.xmlData.length);
         try {
             await nodesetLoader.addNodeSetAsync(nodeset.xmlData);
         } catch (err) {

package/source/loader/load_nodeset2.ts

@@ -1,4 +1,3 @@
-/* eslint-disable max-statements */
 /**
  * @module node-opcua-address-space
  */
@@ -16,7 +15,7 @@ import type {
     UAVariable,
     UAVariableType
 } from "node-opcua-address-space-base";
-import { assert, renderError } from "node-opcua-assert";
+import { assert } from "node-opcua-assert";
 import { coerceBoolean, coerceByte, coerceInt32, StatusCodes } from "node-opcua-basic-types";
 import { DataTypeIds } from "node-opcua-constants";
 import {
@@ -221,7 +220,8 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
     let performedCalled = false;
 
     function _reset_namespace_translation() {
-        debugLog("_reset_namespace_translation");
+        // c8 ignore next
+        doDebug && debugLog("_reset_namespace_translation");
         namespaceUriTranslationMap.clear();
         foundNamespaceMap.clear();
         namespaceCounter = 0;
@@ -711,11 +711,13 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
         node: { browseName: QualifiedName; nodeClass: NodeClass }
     ) => {
         if (isDraft && !options.loadDraftNodes) {
-            debugLog("Ignoring Draft            =", NodeClass[node.nodeClass], node.browseName.toString());
+            // c8 ignore next
+            doDebug && debugLog("Ignoring Draft            =", NodeClass[node.nodeClass], node.browseName.toString());
             return true;
         }
         if (isDeprecated && !options.loadDeprecatedNodes) {
-            debugLog("Ignoring Deprecate        =", NodeClass[node.nodeClass], node.browseName.toString());
+            // c8 ignore next
+            doDebug && debugLog("Ignoring Deprecate        =", NodeClass[node.nodeClass], node.browseName.toString());
             return true;
         }
         return false;
@@ -806,15 +808,16 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
                 this.obj.value = makeDefaultVariant(addressSpace, dataTypeNode, valueRank);
             }
             */
-            // eslint-disable-next-line prefer-const
             let capturedVariable: UAVariable | undefined;
             if (this.obj.value && this.obj.value.dataType !== DataType.Null) {
                 let capturedValue: VariantOptions | undefined = this.obj.value;
                 const task = async (_addressSpace2: IAddressSpace) => {
                     if (!capturedVariable) return;
                     const cv = capturedVariable;
+                    // biome-ignore lint/correctness/noConstantCondition: deliberate debug on/off toggle, not dead code
                     if (false && doDebug) {
-                        debugLog("1 setting value to ", cv.nodeId.toString(), new Variant(capturedValue).toString());
+                        // c8 ignore next
+                        doDebug && debugLog("1 setting value to ", cv.nodeId.toString(), new Variant(capturedValue).toString());
                     }
                     cv.setValueFromSource(capturedValue as VariantOptions);
                     capturedValue = undefined;
@@ -836,8 +839,10 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
 
                     const value = makeDefaultVariant(addressSpace, dataTypeNode, valueRank, arrayDimensions);
                     if (value) {
+                        // biome-ignore lint/correctness/noConstantCondition: deliberate debug on/off toggle, not dead code
                         if (false && doDebug) {
-                            debugLog("2 setting value to ", cv.nodeId.toString(), value);
+                            // c8 ignore next
+                            doDebug && debugLog("2 setting value to ", cv.nodeId.toString(), value);
                         }
                         // a Matrix variable declared with fixed ArrayDimensions but no <Value> is built with
                         // an empty value (value=[]) yet non-zero declared dimensions. This is an *uninitialized*
@@ -1160,17 +1165,30 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
                     chalk.green("DONE")
             );
 
-        async function performPostLoadingTasks(tasks: Task[]): Promise<void> {
+        /**
+         * run every queued post-loading task.
+         *
+         * A task that throws (typically: a `<Value>` in a third-party nodeset that does not
+         * match the declared DataType) is logged and skipped — it must NOT abort the remaining
+         * tasks nor the remaining stages of finalSteps(). Previously the failing task was
+         * re-run inside the catch block, the second throw escaped the loop, finalSteps() was
+         * abandoned and `ensureDatatypeExtracted` was never called: the address space was
+         * left half-initialised (no DataTypeManager) and any later use of a structured
+         * DataType failed with an opaque
+         * "Cannot read properties of undefined (reading 'getExtensionObjectConstructorFromDataType')".
+         */
+        async function performPostLoadingTasks(stage: string, tasks: Task[]): Promise<void> {
             for (const task of tasks) {
                 try {
                     await task(addressSpace1);
                 } catch (err) {
                     // c8 ignore next
-                    // tslint:disable:no-console
                     if (types.isNativeError(err)) {
-                        errorLog(" performPostLoadingTasks Err  => ", err.message, "\n", err);
+                        errorLog(
+                            `[NODE-OPCUA-W36] generateAddressSpace: post-loading task failed during "${stage}" and was skipped: ${err.message}`
+                        );
+                        doDebug && debugLog(err);
                     }
-                    await task(addressSpace1);
                 }
             }
             tasks.splice(0);
@@ -1179,11 +1197,11 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
             /// ----------------------------------------------------------------------------------------
             // perform post task
             doDebug && debugLog(chalk.bgGreenBright("Performing post loading tasks -------------------------------------------"));
-            await performPostLoadingTasks(postTasks);
+            await performPostLoadingTasks("post tasks", postTasks);
 
             doDebug &&
                 debugLog(chalk.bgGreenBright("Performing post loading task: Initializing Simple Variables ---------------------"));
-            await performPostLoadingTasks(postTasks0_InitializeVariable);
+            await performPostLoadingTasks("initializing simple variables", postTasks0_InitializeVariable);
 
             doDebug && debugLog(chalk.bgGreenBright("Performing DataType extraction -------------------------------------------"));
             assert(!addressSpace1.suspendBackReference);
@@ -1202,14 +1220,17 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
             pendingSimpleTypeToRegister.splice(0);
 
             doDebug && debugLog(chalk.bgGreenBright("Performing post loading task: Decoding Pojo String (parsing XML objects) -"));
-            await performPostLoadingTasks(postTasks0_DecodePojoString);
+            await performPostLoadingTasks("decoding XML extension objects", postTasks0_DecodePojoString);
 
             doDebug &&
                 debugLog(chalk.bgGreenBright("Performing post loading task: Initializing Complex Variables ---------------------"));
-            await performPostLoadingTasks(postTasks1_InitializeVariable);
+            await performPostLoadingTasks("initializing complex variables", postTasks1_InitializeVariable);
 
             doDebug && debugLog(chalk.bgGreenBright("Performing post loading tasks: (assigning Extension Object to Variables) -"));
-            await performPostLoadingTasks(postTasks2_AssignedExtensionObjectToDataValue);
+            await performPostLoadingTasks(
+                "assigning extension objects to variables",
+                postTasks2_AssignedExtensionObjectToDataValue
+            );
 
             doDebug && debugLog(chalk.bgGreenBright("Performing post variable initialization ---------------------"));
             promoteObjectsAndVariables(addressSpace);
@@ -1218,7 +1239,13 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
         try {
             await finalSteps();
         } catch (err) {
-            renderError(err);
+            // `renderError` was a no-op here, so a failure in the final steps (DataType extraction,
+            // promotion of objects/variables, ...) used to be silently swallowed and the caller was
+            // handed back a half-initialised address space. Surface it: log and re-throw so that
+            // generateAddressSpace() rejects.
+            const message = types.isNativeError(err) ? err.message : String(err);
+            errorLog(`[NODE-OPCUA-E30] generateAddressSpace: final post-loading steps failed: ${message}`);
+            throw err;
         }
     }
     async function addNodeSet(xmlData: string): Promise<void> {

package/source/loader/make_xml_extension_object_parser.ts

@@ -11,7 +11,7 @@ import {
     type UInt32,
     type UInt64
 } from "node-opcua-basic-types";
-import { make_debugLog, make_warningLog } from "node-opcua-debug";
+import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
 import { coerceNodeId, ExpandedNodeId, type INodeId, type NodeId, NodeIdType } from "node-opcua-nodeid";
 import { coerceStatusCode, StatusCodes } from "node-opcua-status-code";
 import { EnumDefinition, StructureDefinition } from "node-opcua-types";
@@ -31,6 +31,7 @@ import { makeVariantReader } from "./parsers/variant_parser";
 
 const warningLog = make_warningLog(__filename);
 const debugLog = make_debugLog(__filename);
+const doDebug = checkDebugFlag(__filename);
 
 // textual form of an ExpandedNodeId, as found in <ExpandedNodeId><Identifier>...</Identifier></ExpandedNodeId>:
 // an optional server index, an optional namespace uri, then a plain nodeId. see OPC UA part 6.
@@ -70,18 +71,30 @@ function clamp(value: number, minValue: number, maxValue: number) {
 
 interface Parser<T> extends ReaderStateParserLike {
     value: T | null;
-    parent: any;
+    parent: Parser<unknown>;
     text: string;
 }
 
+// generic loose parser-state shape used by the Xml2Json engine: `this` here is a
+// dynamically-populated reader state whose fields (value/parent/text/...) vary by parser,
+// see the `this: any` justification in ReaderStateParserLike itself (node-opcua-xml2json).
+interface AnyParserState extends ReaderStateParserLike {
+    value: unknown;
+    parent: AnyParserState;
+    text: string;
+    name?: string;
+    obj?: unknown;
+    parser: Record<string, AnyParserState>;
+}
+
 // <StatusCode><Code>2153644032</Code></StatusCode>
 const statusCode_parser: ReaderStateParserLike = {
-    init(this: any) {
+    init(this: AnyParserState) {
         this.value = StatusCodes.Good;
     },
     parser: {
         Code: {
-            finish(this: any) {
+            finish(this: AnyParserState) {
                 this.parent.value = coerceStatusCode(parseInt(this.text, 10));
             }
         }
@@ -92,16 +105,16 @@ const statusCode_parser: ReaderStateParserLike = {
 // created when at least one field is present ( <DiagnosticInfo/> stays empty ).
 function _diagnosticInfoField(name: string, convert: (text: string) => unknown): ReaderStateParserLike {
     return {
-        finish(this: any) {
+        finish(this: AnyParserState) {
             this.parent.value = this.parent.value || {};
-            this.parent.value[name] = convert(this.text);
+            (this.parent.value as Record<string, unknown>)[name] = convert(this.text);
         }
     };
 }
 
 // <DiagnosticInfo><SymbolicId>1</SymbolicId>...<InnerDiagnosticInfo>...</InnerDiagnosticInfo></DiagnosticInfo>
 const diagnosticInfo_parser: ReaderStateParserLike = {
-    init(this: any) {
+    init(this: AnyParserState) {
         this.value = undefined;
     },
     parser: {
@@ -112,20 +125,23 @@ const diagnosticInfo_parser: ReaderStateParserLike = {
         AdditionalInfo: _diagnosticInfoField("additionalInfo", (text) => text),
         InnerStatusCode: {
             ...statusCode_parser,
-            finish(this: any) {
+            finish(this: AnyParserState) {
                 this.parent.value = this.parent.value || {};
-                this.parent.value.innerStatusCode = this.value;
+                (this.parent.value as Record<string, unknown>).innerStatusCode = this.value;
             }
         }
     }
 };
 // InnerDiagnosticInfo is a DiagnosticInfo in turn: the parser is registered after the
 // fact so that it can refer to the reader being built.
-diagnosticInfo_parser.parser!.InnerDiagnosticInfo = {
+if (!diagnosticInfo_parser.parser) {
+    throw new Error("internal error: diagnosticInfo_parser.parser must be defined");
+}
+diagnosticInfo_parser.parser.InnerDiagnosticInfo = {
     ...diagnosticInfo_parser,
-    finish(this: any) {
+    finish(this: AnyParserState) {
         this.parent.value = this.parent.value || {};
-        this.parent.value.innerDiagnosticInfo = this.value;
+        (this.parent.value as Record<string, unknown>).innerDiagnosticInfo = this.value;
     }
 };
 const partials = {
@@ -238,7 +254,7 @@ const partials = {
     },
 
     Variant: {
-        finish(this: any) {
+        finish(this: AnyParserState) {
             /** to do */
             warningLog(" Missing  Implemntation contact sterfive.com!");
         }
@@ -281,7 +297,7 @@ export interface DefinitionMap2 {
     findDefinition(dataTypeNodeId: NodeId): TypeInfo;
 }
 
-function _clone(a: any): any {
+function _clone(a: unknown): unknown {
     if (typeof a === "string" || typeof a === "number" || typeof a === "boolean") {
         return a;
     }
@@ -294,7 +310,7 @@ function _clone(a: any): any {
     if (Array.isArray(a)) {
         return a.map((x) => _clone(x));
     }
-    return { ...a };
+    return { ...(a as Record<string, unknown>) };
 }
 
 function _makeTypeReader(
@@ -302,7 +318,7 @@ function _makeTypeReader(
     definitionMap: DefinitionMap2,
     readerMap: Map<string, ReaderStateParserLike>,
     translateNodeId: (nodeId: string) => NodeId
-): { name: string; reader: ReaderStateParser } {
+): { name: string; reader: ReaderStateParserLike } {
     const n = dataTypeNodeId1 as INodeId;
     if (n.identifierType === NodeIdType.NUMERIC && n.namespace === 0 && n.value === 0) {
         // a generic Extension Object
@@ -311,7 +327,7 @@ function _makeTypeReader(
 
     if (n.namespace === 0 && n.identifierType === NodeIdType.NUMERIC && n.value < DataType.ExtensionObject) {
         const name = DataType[n.value as number] as string;
-        const reader = partials[name as keyof typeof partials] as ReaderStateParser;
+        const reader = partials[name as keyof typeof partials] as ReaderStateParserLike;
         return { name, reader };
     }
 
@@ -319,26 +335,32 @@ function _makeTypeReader(
 
     const dataTypeName = name;
 
-    let reader: ReaderStateParserLike = readerMap.get(dataTypeName)!;
+    let reader: ReaderStateParserLike | undefined = readerMap.get(dataTypeName);
 
     if (reader) {
         return { name, reader };
     }
 
     reader = {
-        init(this: any) {
+        init(this: AnyParserState) {
             // the same reader instance is used for every element of that data type: the value must be
             // reset here, or the element being read would inherit the fields of the previously read one
             // ( or of the enclosing one, when the structure refers to itself ).
             this.value = undefined;
         },
-        finish(this: any) {
+        finish(this: AnyParserState) {
             /** empty  */
         },
         parser: {
             /** empty  */
         }
     };
+    // `reader.parser` is guaranteed defined: it was just set as a literal above, and the
+    // ReaderStateParserLike interface only declares it optional for other unrelated call sites.
+    const readerParser = reader.parser;
+    if (!readerParser) {
+        throw new Error("internal error: reader.parser must be defined");
+    }
 
     if (definition instanceof StructureDefinition) {
         // the reader must be registered *before* its fields are explored: a structure may refer to
@@ -363,72 +385,75 @@ function _makeTypeReader(
                     throw new Error(`??? ${field.dataType}  ${field.name}`);
                 }
 
-                reader.parser![field.name || ""] = {
+                readerParser[field.name || ""] = {
                     parser: fieldParser.parser,
                     // the field reader borrows the partial's sub-parsers: it must borrow its init
                     // too, or the state those sub-parsers write into is never set up.
-                    init(this: any, elementName: string, attrs: XmlAttributes, parent: IReaderState, engine: Xml2Json) {
+                    init(this: AnyParserState, elementName: string, attrs: XmlAttributes, parent: IReaderState, engine: Xml2Json) {
                         if (fieldParser.init) {
                             fieldParser.init.call(this, elementName, attrs, parent, engine);
                         }
                     },
                     // endElement: fieldReader.endElement,
-                    finish(this: any) {
+                    finish(this: AnyParserState) {
                         const elName = lowerFirstLetter(field.name || "");
                         if (fieldParser.finish) {
                             fieldParser.finish.call(this);
                         } else {
-                            debugLog(`xxx check ${fieldTypename}`);
+                            // c8 ignore next
+                            doDebug && debugLog(`xxx check ${fieldTypename}`);
                         }
                         this.parent.value = this.parent.value || Object.create(null);
-                        this.parent.value[elName] = _clone(this.value);
+                        (this.parent.value as Record<string, unknown>)[elName] = _clone(this.value);
                     }
                 };
             } else if (field.valueRank === 1) {
                 const listReader: ReaderStateParserLike = {
-                    init(this: any) {
+                    init(this: AnyParserState) {
                         this.value = [];
                     },
                     parser: {
                         /** empty */
                     },
-                    finish(this: any) {
-                        const elName = lowerFirstLetter(this.name);
+                    finish(this: AnyParserState) {
+                        const elName = lowerFirstLetter(this.name || "");
                         this.parent.value = this.parent.value || Object.create(null);
-                        this.parent.value[elName] = this.value;
+                        (this.parent.value as Record<string, unknown>)[elName] = this.value;
                         this.value = undefined;
                     },
                     startElement(_name: string, _attrs: XmlAttributes) {
                         // empty
                     },
-                    endElement(element: string) {
-                        this.value.push(_clone(this.parser[element].value));
+                    endElement(this: AnyParserState, element: string) {
+                        (this.value as unknown[]).push(_clone(this.parser[element].value));
                     }
                 };
-                listReader.parser![fieldTypename] = fieldParser;
-                reader.parser![field.name!] = listReader;
+                const listReaderParser = listReader.parser;
+                if (!listReaderParser) {
+                    throw new Error("internal error: listReader.parser must be defined");
+                }
+                listReaderParser[fieldTypename] = fieldParser;
+                readerParser[field.name || ""] = listReader;
             } else {
                 throw new Error("Unsupported ValueRank !");
             }
         }
         return { name, reader };
     } else if (definition instanceof EnumDefinition) {
-        const turnToInt = (value: any) => {
+        const turnToInt = (value: string) => {
             // Green_100
             return parseInt(value.split("_")[1], 10);
         };
         return {
             name,
             reader: {
-                finish(this: any) {
+                finish(this: AnyParserState) {
                     this.value = turnToInt(this.text);
                 }
             }
         };
     } else if (definition?.dataType === DataType.Variant) {
         // <Value><String>Foo</String></Value>
-        type Task = (addressSpace: any) => Promise<void>;
-
         let variantOptions: VariantOptions = Object.create(null);
 
         const variantReader = makeVariantReader(
@@ -444,11 +469,11 @@ function _makeTypeReader(
         return {
             name,
             reader: {
-                init(this: any, _name: string, _attrs: XmlAttributes, _parent: IReaderState, _engine: Xml2Json) {
+                init(this: AnyParserState, _name: string, _attrs: XmlAttributes, _parent: IReaderState, _engine: Xml2Json) {
                     this.obj = {};
                 },
                 ...variantReader,
-                finish(this: any & { value: Variant }) {
+                finish(this: AnyParserState) {
                     this.value = new Variant(variantOptions);
                 }
             }
@@ -456,7 +481,7 @@ function _makeTypeReader(
     } else {
         // basic datatype
         const typeName: string = DataType[definition.dataType];
-        const reader = partials[typeName as keyof typeof partials] as ReaderStateParser;
+        const reader = partials[typeName as keyof typeof partials] as ReaderStateParserLike;
         // c8 ignore next
         if (!reader) {
             throw new Error(`missing parse for ${typeName}`);
@@ -478,14 +503,22 @@ export function makeXmlExtensionObjectReader(
         throw new Error("Expecting StructureDefinition");
     }
     //
-    const reader1: ReaderStateParser = {
-        parser: {},
-        endElement(this: any) {
+    interface Reader1State extends IReaderState {
+        _pojo?: unknown;
+        parser: Record<string, AnyParserState>;
+    }
+    const reader1 = {
+        parser: {} as Record<string, AnyParserState>,
+        endElement(this: Reader1State) {
             this._pojo = this.parser[name].value;
         }
     };
     const { reader } = _makeTypeReader(dataTypeNodeId, definitionMap, readerMap, translateNodeId);
-    reader1.parser![name] = reader as ReaderStateParserLike;
+    const reader1Parser = reader1.parser;
+    if (!reader1Parser) {
+        throw new Error("internal error: reader1.parser must be defined");
+    }
+    reader1Parser[name] = reader as unknown as AnyParserState;
 
-    return new ReaderState(reader1);
+    return new ReaderState(reader1 as unknown as ReaderStateParser);
 }

package/source/loader/namespace_post_step.ts

@@ -38,7 +38,7 @@ export async function promoteObjectAndVariablesInNamespace(namespace: INamespace
                 }
                 const before = a.constructor.name;
 
-                promoter.promoter(a as any);
+                promoter.promoter(a as UAVariable & UAObject);
                 const after = a.constructor.name;
                 // c8 ignore next
                 if (doDebug) {