node-opcua-convert-nodeset-to-javascript 2.183.0 → 2.184.0

package/dist/convert_to_typescript.js

@@ -1,32 +1,18 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertDataTypeToTypescript = convertDataTypeToTypescript;
-exports.makeTypeName2 = makeTypeName2;
-exports.extractClassDefinition = extractClassDefinition;
-exports.findClassMember = findClassMember;
-exports.checkIfShouldExposeInnerDefinition = checkIfShouldExposeInnerDefinition;
-exports.extractClassMemberDef = extractClassMemberDef;
-exports.findUsedImport = findUsedImport;
-exports._convertTypeToTypescript = _convertTypeToTypescript;
-exports.convertTypeToTypescript = convertTypeToTypescript;
-const chalk_1 = __importDefault(require("chalk"));
-const node_opcua_assert_1 = __importDefault(require("node-opcua-assert"));
-const node_opcua_data_model_1 = require("node-opcua-data-model");
-const node_opcua_debug_1 = require("node-opcua-debug");
-const node_opcua_types_1 = require("node-opcua-types");
-const node_opcua_utils_1 = require("node-opcua-utils");
-const node_opcua_variant_1 = require("node-opcua-variant");
-const _dataType_js_1 = require("./_dataType.js");
-const cache_js_1 = require("./private/cache.js");
-const get_corresponding_data_type_js_1 = require("./private/get_corresponding_data_type.js");
-const to_filename_js_1 = require("./private/to_filename.js");
-const utils_js_1 = require("./private/utils.js");
-const utils2_js_1 = require("./utils2.js");
-const warningLog = (0, node_opcua_debug_1.make_warningLog)("typescript");
-const debugLog = (0, node_opcua_debug_1.make_debugLog)("typescript");
+import chalk from "chalk";
+import assert from "node-opcua-assert";
+import { NodeClass } from "node-opcua-data-model";
+import { make_debugLog, make_warningLog } from "node-opcua-debug";
+import { StructureDefinition } from "node-opcua-types";
+import { LineFile } from "node-opcua-utils";
+import { DataType } from "node-opcua-variant";
+import { _exportDataTypeToTypescript } from "./_dataType.js";
+import { constructCache, makeTypeNameNew } from "./private/cache.js";
+import { getCorrespondingJavascriptType2 } from "./private/get_corresponding_data_type.js";
+import { toFilename } from "./private/to_filename.js";
+import { extractBasicDataType, getBrowseName, getChildrenOrFolderElements, getDataTypeNodeId, getDefinition, getDescription, getIsAbstract, getModellingRule, getNodeClass, getSubtypeNodeIdIfAny, getTypeDefOrBaseType, getValueRank } from "./private/utils.js";
+import { f1, f2, quotifyIfNecessary, toComment, toJavascritPropertyName } from "./utils2.js";
+const warningLog = make_warningLog("typescript");
+const debugLog = make_debugLog("typescript");
 const doDebug = false;
 const baseExtension = "_Base";
 const m0 = !doDebug ? "" : `/* 0 */`;
@@ -45,12 +31,12 @@ const mC = !doDebug ? "" : `/* c */`;
 const mD = !doDebug ? "" : `/* d */`;
 const mE = !doDebug ? "" : `/* e */`;
 const mF = !doDebug ? "" : `/* f */`;
-async function convertDataTypeToTypescript(session, dataTypeId) {
-    const definition = await (0, utils_js_1.getDefinition)(session, dataTypeId);
-    const browseName = await (0, utils_js_1.getBrowseName)(session, dataTypeId);
+export async function convertDataTypeToTypescript(session, dataTypeId) {
+    const definition = await getDefinition(session, dataTypeId);
+    const browseName = await getBrowseName(session, dataTypeId);
     const dataTypeTypescriptName = `UA${browseName.name?.toString()}`;
-    const f = new node_opcua_utils_1.LineFile();
-    if (definition && definition instanceof node_opcua_types_1.StructureDefinition) {
+    const f = new LineFile();
+    if (definition && definition instanceof StructureDefinition) {
         f.write(`interface ${dataTypeTypescriptName} {`);
         for (const _field of definition.fields || []) {
             /** */
@@ -58,14 +44,14 @@ async function convertDataTypeToTypescript(session, dataTypeId) {
         f.write(`}`);
     }
 }
-function makeTypeName2(nodeClass, browseName, suffix) {
-    (0, node_opcua_assert_1.default)(browseName);
-    if (nodeClass === node_opcua_data_model_1.NodeClass.Method) {
+export function makeTypeName2(nodeClass, browseName, suffix) {
+    assert(browseName);
+    if (nodeClass === NodeClass.Method) {
         return { name: "UAMethod", namespace: 0, module: "UAMethod" };
     }
-    return (0, cache_js_1.makeTypeNameNew)(nodeClass, null, browseName, suffix);
+    return makeTypeNameNew(nodeClass, null, browseName, suffix);
 }
-async function extractClassDefinition(session, nodeId, cache) {
+export async function extractClassDefinition(session, nodeId, cache) {
     const extraImports = [];
     const cacheWithClassDefCache = cache;
     const _c = cacheWithClassDefCache.classDefCache || {};
@@ -74,29 +60,29 @@ async function extractClassDefinition(session, nodeId, cache) {
     if (classDef) {
         return classDef;
     }
-    const nodeClass = await (0, utils_js_1.getNodeClass)(session, nodeId);
-    if (nodeClass !== node_opcua_data_model_1.NodeClass.VariableType && nodeClass !== node_opcua_data_model_1.NodeClass.ObjectType) {
-        throw new Error(`Invalid nodeClass ${node_opcua_data_model_1.NodeClass[nodeClass]} nodeId ${nodeId.toString()}`);
+    const nodeClass = await getNodeClass(session, nodeId);
+    if (nodeClass !== NodeClass.VariableType && nodeClass !== NodeClass.ObjectType) {
+        throw new Error(`Invalid nodeClass ${NodeClass[nodeClass]} nodeId ${nodeId.toString()}`);
     }
-    const browseName = await (0, utils_js_1.getBrowseName)(session, nodeId);
-    const isAbstract = await (0, utils_js_1.getIsAbstract)(session, nodeId);
-    const superType = (await (0, utils_js_1.getSubtypeNodeIdIfAny)(session, nodeId)) || undefined;
-    const dataTypeNodeId = await (0, utils_js_1.getDataTypeNodeId)(session, nodeId);
+    const browseName = await getBrowseName(session, nodeId);
+    const isAbstract = await getIsAbstract(session, nodeId);
+    const superType = (await getSubtypeNodeIdIfAny(session, nodeId)) || undefined;
+    const dataTypeNodeId = await getDataTypeNodeId(session, nodeId);
     let dataTypeName = "";
-    let dataType = node_opcua_variant_1.DataType.Null;
+    let dataType = DataType.Null;
     let dataTypeImport;
     let valueRank;
     let dataTypeCombination;
-    if (nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
+    if (nodeClass === NodeClass.VariableType) {
         if (!dataTypeNodeId) {
             throw new Error(`VariableType ${nodeId.toString()} is expected to have a DataType attribute`);
         }
-        dataType = await (0, utils_js_1.extractBasicDataType)(session, dataTypeNodeId);
+        dataType = await extractBasicDataType(session, dataTypeNodeId);
         const importCollector = (i) => {
             extraImports.push(i);
             cache.ensureImported(i);
         };
-        const info = await (0, get_corresponding_data_type_js_1.getCorrespondingJavascriptType2)(session, nodeId, dataTypeNodeId, cache, importCollector);
+        const info = await getCorrespondingJavascriptType2(session, nodeId, dataTypeNodeId, cache, importCollector);
         const jtype = info.jtype;
         dataTypeCombination = info.dataTypeCombination;
         dataTypeName = jtype; // with decoration
@@ -105,15 +91,15 @@ async function extractClassDefinition(session, nodeId, cache) {
             // const bn = await getBrowseName(session, dataTypeNodeId!);
             dataTypeImport = extraImports; // makeTypeName2(NodeClass.DataType, bn);
         }
-        valueRank = await (0, utils_js_1.getValueRank)(session, nodeId);
+        valueRank = await getValueRank(session, nodeId);
     }
     const baseClassDef = !superType ? null : await extractClassDefinition(session, superType.nodeId, cache);
-    const description = await (0, utils_js_1.getDescription)(session, nodeId);
+    const description = await getDescription(session, nodeId);
     // const definition = await getDefinition(session, nodeId);
     const interfaceName = makeTypeName2(nodeClass, browseName);
     const baseInterfaceName = !superType ? null : makeTypeName2(nodeClass, superType.browseName);
     // extract member
-    const children = await (0, utils_js_1.getChildrenOrFolderElements)(session, nodeId);
+    const children = await getChildrenOrFolderElements(session, nodeId);
     const members = [];
     classDef = {
         nodeClass,
@@ -150,15 +136,15 @@ async function classify(session, refs, classDef) {
         ExposesItsArray: []
     };
     for (const mm of refs) {
-        let modellingRule = await (0, utils_js_1.getModellingRule)(session, mm.nodeId);
+        let modellingRule = await getModellingRule(session, mm.nodeId);
         if (modellingRule) {
             // if Optional, check that base class member is also Optional or force to Mandatory
             if (modellingRule === "Optional" && classDef.baseClassDef) {
                 const sameMember = classDef.baseClassDef.members.find((m) => m.browseName.name === mm.browseName.name);
                 if (sameMember) {
                     if (!sameMember.isOptional) {
-                        console.log(chalk_1.default.cyan("Warning: ") +
-                            chalk_1.default.yellow(classDef.browseName.toString()) +
+                        console.log(chalk.cyan("Warning: ") +
+                            chalk.yellow(classDef.browseName.toString()) +
                             " ModellingRule is Optional but base class member is Mandatory");
                         modellingRule = "Mandatory";
                     }
@@ -188,7 +174,7 @@ async function extractAllMembers(session, classDef, _cache) {
     const members = await classify(session, m, classDef);
     return members;
 }
-async function findClassMember(session, browseName, baseParentDef, cache) {
+export async function findClassMember(session, browseName, baseParentDef, cache) {
     const childBrowseName = browseName.toString();
     const r = baseParentDef.children.find((a) => a.browseName.toString() === childBrowseName);
     if (r) {
@@ -214,7 +200,7 @@ function hasNewMaterial(referenceMembers, instanceMembers) {
 // we should expose an inner definition if
 //  - at least one mandatory in instnace doesn't exist in main.Mandatory
 //  - at least one optional in instnace doesn't exist in main.Mandatory
-function checkIfShouldExposeInnerDefinition(main, instance) {
+export function checkIfShouldExposeInnerDefinition(main, instance) {
     const hasNewStuff = hasNewMaterial(main.Mandatory, instance.Mandatory) || hasNewMaterial(main.Optional, instance.Optional);
     return hasNewStuff;
 }
@@ -243,18 +229,18 @@ async function _extractLocalMembers(session, parent, classMember, cache) {
     const children2 = [];
     for (const child of classMember.children) {
         const nodeId = child.nodeId;
-        const browseName = await (0, utils_js_1.getBrowseName)(session, nodeId);
+        const browseName = await getBrowseName(session, nodeId);
         if (!browseName.name) {
             throw new Error(`Expecting a browseName.name for node ${nodeId.toString()}`);
         }
-        const name = (0, utils2_js_1.toJavascritPropertyName)(browseName.name, {
+        const name = toJavascritPropertyName(browseName.name, {
             ignoreConflictingName: true,
             parentNodeClass: classMember.nodeClass
         });
-        const description = await (0, utils_js_1.getDescription)(session, nodeId);
-        const modellingRule = await (0, utils_js_1.getModellingRule)(session, nodeId);
+        const description = await getDescription(session, nodeId);
+        const modellingRule = await getModellingRule(session, nodeId);
         const isOptional = sameInBaseClassIsMandatory(parent, browseName) ? false : modellingRule === "Optional";
-        const typeDefinition = await (0, utils_js_1.getTypeDefOrBaseType)(session, nodeId);
+        const typeDefinition = await getTypeDefOrBaseType(session, nodeId);
         const childInBase = classMember.classDef?.members.find((a) => a.browseName.toString() === browseName.toString());
         let childType;
         if (childInBase) {
@@ -282,7 +268,7 @@ async function _extractLocalMembers(session, parent, classMember, cache) {
     return children2;
 }
 function isUnspecifiedDataType(dataType) {
-    return dataType === node_opcua_variant_1.DataType.Null || dataType === node_opcua_variant_1.DataType.Variant;
+    return dataType === DataType.Null || dataType === DataType.Variant;
 }
 async function extractVariableExtra(session, nodeId, cache, classMember) {
     const typeToReference = [];
@@ -290,24 +276,24 @@ async function extractVariableExtra(session, nodeId, cache, classMember) {
         typeToReference.push(i);
         cache.ensureImported(i);
     };
-    const nodeClass = await (0, utils_js_1.getNodeClass)(session, nodeId);
-    if (nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
-        const dataTypeNodeId = await (0, utils_js_1.getDataTypeNodeId)(session, nodeId);
+    const nodeClass = await getNodeClass(session, nodeId);
+    if (nodeClass === NodeClass.Variable) {
+        const dataTypeNodeId = await getDataTypeNodeId(session, nodeId);
         if (!dataTypeNodeId) {
             throw new Error(`Variable ${nodeId.toString()} is expected to have a DataType attribute`);
         }
-        const _valueRank = await (0, utils_js_1.getValueRank)(session, nodeId);
+        const _valueRank = await getValueRank(session, nodeId);
         _valueRank;
-        const { dataType, jtype, dataTypeCombination } = await (0, get_corresponding_data_type_js_1.getCorrespondingJavascriptType2)(session, nodeId, dataTypeNodeId, cache, importCollector);
+        const { dataType, jtype, dataTypeCombination } = await getCorrespondingJavascriptType2(session, nodeId, dataTypeNodeId, cache, importCollector);
         cache?.referenceBasicType("DataType");
         importCollector({ name: "DataType", namespace: -1, module: "BasicType" });
         const t = isUnspecifiedDataType(classMember.classDef?.dataType);
         const suffix = jtype === "undefined" || isUnspecifiedDataType(dataType)
             ? `<any, any>`
-            : `<${jtype}${t ? `, ${m0}DataType.${node_opcua_variant_1.DataType[dataType]}` : ""}>`;
+            : `<${jtype}${t ? `, ${m0}DataType.${DataType[dataType]}` : ""}>`;
         // const suffix2 = `<T${t ? `, /DT extends DataType` : ""}>`;
         const suffix3 = `<T${t ? `, ${m1}DT` : ""}>`;
-        const typeDef = await (0, utils_js_1.getTypeDefOrBaseType)(session, nodeId);
+        const typeDef = await getTypeDefOrBaseType(session, nodeId);
         const typeDefCD = await extractClassDefinition(session, typeDef.nodeId, cache);
         const chevrons = calculateChevrons(typeDefCD, { dataType });
         const suffix2 = chevrons.chevronsDef;
@@ -336,7 +322,7 @@ async function extractVariableExtra(session, nodeId, cache, classMember) {
                 }
             }
             else {
-                suffixInstantiate = `<${jtype}, DataType.${node_opcua_variant_1.DataType[dataType]}${mF}>`;
+                suffixInstantiate = `<${jtype}, DataType.${DataType[dataType]}${mF}>`;
             }
         }
         return {
@@ -357,33 +343,33 @@ async function extractVariableExtra(session, nodeId, cache, classMember) {
 /** the class of the instances of a type: what a generated interface describes */
 function instanceNodeClass(typeNodeClass) {
     switch (typeNodeClass) {
-        case node_opcua_data_model_1.NodeClass.ObjectType:
-            return node_opcua_data_model_1.NodeClass.Object;
-        case node_opcua_data_model_1.NodeClass.VariableType:
-            return node_opcua_data_model_1.NodeClass.Variable;
+        case NodeClass.ObjectType:
+            return NodeClass.Object;
+        case NodeClass.VariableType:
+            return NodeClass.Variable;
         default:
             return typeNodeClass;
     }
 }
-async function extractClassMemberDef(session, nodeId, parentDef, cache) {
-    const nodeClass = await (0, utils_js_1.getNodeClass)(session, nodeId);
-    const browseName = await (0, utils_js_1.getBrowseName)(session, nodeId);
+export async function extractClassMemberDef(session, nodeId, parentDef, cache) {
+    const nodeClass = await getNodeClass(session, nodeId);
+    const browseName = await getBrowseName(session, nodeId);
     if (!browseName.name) {
         throw new Error(`Expecting a browseName.name for node ${nodeId.toString()}`);
     }
-    const name = (0, utils2_js_1.toJavascritPropertyName)(browseName.name, {
+    const name = toJavascritPropertyName(browseName.name, {
         ignoreConflictingName: true,
         parentNodeClass: instanceNodeClass(parentDef.nodeClass)
     });
-    if (nodeClass !== node_opcua_data_model_1.NodeClass.Method && nodeClass !== node_opcua_data_model_1.NodeClass.Object && nodeClass !== node_opcua_data_model_1.NodeClass.Variable) {
-        throw new Error(`Invalid property ${node_opcua_data_model_1.NodeClass[nodeClass]} ${browseName?.toString()} ${nodeId.toString()}`);
+    if (nodeClass !== NodeClass.Method && nodeClass !== NodeClass.Object && nodeClass !== NodeClass.Variable) {
+        throw new Error(`Invalid property ${NodeClass[nodeClass]} ${browseName?.toString()} ${nodeId.toString()}`);
     }
-    const description = await (0, utils_js_1.getDescription)(session, nodeId);
-    const children = await (0, utils_js_1.getChildrenOrFolderElements)(session, nodeId);
-    const modellingRule = await (0, utils_js_1.getModellingRule)(session, nodeId);
+    const description = await getDescription(session, nodeId);
+    const children = await getChildrenOrFolderElements(session, nodeId);
+    const modellingRule = await getModellingRule(session, nodeId);
     const isOptional = sameInBaseClassIsMandatory(parentDef, browseName) ? false : modellingRule === "Optional";
-    const typeDefinition = await (0, utils_js_1.getTypeDefOrBaseType)(session, nodeId);
-    if (nodeClass !== node_opcua_data_model_1.NodeClass.Method && !typeDefinition.browseName?.name) {
+    const typeDefinition = await getTypeDefOrBaseType(session, nodeId);
+    if (nodeClass !== NodeClass.Method && !typeDefinition.browseName?.name) {
         warningLog(typeDefinition.toString());
         warningLog("cannot find typeDefinition for ", browseName.toString(), "( is the namespace loaded ?)");
     }
@@ -396,7 +382,7 @@ async function extractClassMemberDef(session, nodeId, parentDef, cache) {
     const baseParentDef = parentDef.superType && (await extractClassDefinition(session, parentDef.superType?.nodeId, cache));
     if (classDef && baseParentDef) {
         const _chevrons1 = calculateChevrons(classDef, baseParentDef);
-        (0, node_opcua_assert_1.default)(!innerClass);
+        assert(!innerClass);
         // let's extract the member that are theorically defined in the member
         const membersReference = await extractAllMembers(session, classDef, cache);
         // find member exposed by this member
@@ -427,22 +413,22 @@ async function extractClassMemberDef(session, nodeId, parentDef, cache) {
                 childBase = childType;
                 childType = innerClass;
             }
-            (0, node_opcua_assert_1.default)(innerClass);
-            (0, node_opcua_assert_1.default)(childBase);
+            assert(innerClass);
+            assert(childBase);
         }
         else {
             if (sameMemberInBaseClass && sameMemberInBaseClass.childType.name !== childType.name) {
                 childType = sameMemberInBaseClass.childType;
             }
-            (0, node_opcua_assert_1.default)(!innerClass);
-            (0, node_opcua_assert_1.default)(!childBase);
+            assert(!innerClass);
+            assert(!childBase);
         }
     }
     else {
         // the lass member has no HasTypeDefinition reference
         // may be is a method
-        (0, node_opcua_assert_1.default)(!innerClass);
-        (0, node_opcua_assert_1.default)(!childBase);
+        assert(!innerClass);
+        assert(!childBase);
     }
     let classMember = {
         name,
@@ -467,7 +453,7 @@ async function extractClassMemberDef(session, nodeId, parentDef, cache) {
         chevrons: null
     };
     classMember.children2 = await _extractLocalMembers(session, classDef, classMember, cache);
-    if (nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
+    if (nodeClass === NodeClass.Variable) {
         const extra = await extractVariableExtra(session, nodeId, cache, classMember);
         classMember = {
             ...classMember,
@@ -482,14 +468,14 @@ async function extractClassMemberDef(session, nodeId, parentDef, cache) {
                 // childType was inherited from base (e.g., UADiscreteItem instead of UATwoStateDiscrete)
                 // Recalculate suffix based on base class's classDef
                 if (sameMemberInBase.classDef && classMember.dataType !== undefined) {
-                    const baseTypeHasUnspecifiedDataType = sameMemberInBase.classDef.dataType === node_opcua_variant_1.DataType.Null ||
-                        sameMemberInBase.classDef.dataType === node_opcua_variant_1.DataType.Variant;
+                    const baseTypeHasUnspecifiedDataType = sameMemberInBase.classDef.dataType === DataType.Null ||
+                        sameMemberInBase.classDef.dataType === DataType.Variant;
                     if (baseTypeHasUnspecifiedDataType &&
-                        classMember.dataType !== node_opcua_variant_1.DataType.Null &&
-                        classMember.dataType !== node_opcua_variant_1.DataType.Variant) {
+                        classMember.dataType !== DataType.Null &&
+                        classMember.dataType !== DataType.Variant) {
                         // Base type is generic (2 params), current has specific dataType
                         // Generate: <specificType, DataType.SpecificType>
-                        classMember.suffixInstantiate = `<${classMember.jtype}, DataType.${node_opcua_variant_1.DataType[classMember.dataType]}>`;
+                        classMember.suffixInstantiate = `<${classMember.jtype}, DataType.${DataType[classMember.dataType]}>`;
                     }
                 }
             }
@@ -498,7 +484,7 @@ async function extractClassMemberDef(session, nodeId, parentDef, cache) {
     return classMember;
 }
 async function preDumpChildren(padding, classDef, f, cache) {
-    f = f || new node_opcua_utils_1.LineFile();
+    f = f || new LineFile();
     for (const memberDef of classDef.members) {
         const { innerClass, suffix2, nodeClass, childBase } = memberDef;
         if (!innerClass || !childBase) {
@@ -510,7 +496,7 @@ async function preDumpChildren(padding, classDef, f, cache) {
         }
         const baseStuff = getBaseClassWithOmit2(memberDef);
         //f.write(`export interface ${innerClass.name}${suffix2} extends ${childBase.name}${suffix3} { // ${NodeClass[nodeClass]}`);
-        f.write(`export interface ${innerClass.name}${suffix2} extends ${baseStuff} { // ${node_opcua_data_model_1.NodeClass[nodeClass]}`);
+        f.write(`export interface ${innerClass.name}${suffix2} extends ${baseStuff} { // ${NodeClass[nodeClass]}`);
         await dumpChildren(`${padding}  `, memberDef.children2, f, cache);
         f.write("}");
     }
@@ -523,7 +509,7 @@ function countExposedChildren(children) {
     return children.reduce((p, def) => p + (isPlaceHolder(def) ? 0 : 1), 0);
 }
 function dumpChildren(padding, children, f, cache) {
-    f = f || new node_opcua_utils_1.LineFile();
+    f = f || new LineFile();
     for (const def of children) {
         const { suffixInstantiate, name, childType, isOptional, description } = def;
         def.typeToReference.forEach((t) => {
@@ -536,14 +522,14 @@ function dumpChildren(padding, children, f, cache) {
         cache.ensureImported(childType);
         // name went through the rule already, with its parent class known; this is the same
         // transformation applied to an already adjusted name, hence no parent class here
-        const adjustedName = (0, utils2_js_1.toJavascritPropertyName)(name, { ignoreConflictingName: true });
+        const adjustedName = toJavascritPropertyName(name, { ignoreConflictingName: true });
         if (description.text) {
             f.write(`${padding}/**`);
             f.write(`${padding} * ${name || ""}`);
-            f.write((0, utils2_js_1.toComment)(`${padding} * `, description.text || ""));
+            f.write(toComment(`${padding} * `, description.text || ""));
             f.write(`${padding} */`);
         }
-        f.write(`${padding}${(0, utils2_js_1.quotifyIfNecessary)(adjustedName)}${isOptional ? "?" : ""}: ${childType.name}${suffixInstantiate || ""};`);
+        f.write(`${padding}${quotifyIfNecessary(adjustedName)}${isOptional ? "?" : ""}: ${childType.name}${suffixInstantiate || ""};`);
     }
 }
 // now from other namespace
@@ -554,7 +540,7 @@ const getSubSymbolList = (s) => {
     }
     return subSymbolList;
 };
-function findUsedImport(namespaceIndex, cache) {
+export function findUsedImport(namespaceIndex, cache) {
     const usedImport = [];
     // from standard types
     for (const imp of Object.keys(cache.imports)) {
@@ -577,7 +563,7 @@ function findUsedImport(namespaceIndex, cache) {
     return usedImport;
 }
 function dumpUsedExport(currentType, namespaceIndex, cache, f) {
-    f = f || new node_opcua_utils_1.LineFile();
+    f = f || new LineFile();
     for (const imp of Object.keys(cache.imports)) {
         const symbolToImport = Object.keys(cache.imports[imp]).filter((f) => f !== currentType && Object.hasOwn(cache.requestedBasicTypes, f));
         if (symbolToImport.length === 0) {
@@ -591,7 +577,7 @@ function dumpUsedExport(currentType, namespaceIndex, cache, f) {
         if (ns === namespaceIndex) {
             // include individuals stuff
             for (const [symbol, s] of Object.entries(cache.requestedSymbols.namespace[ns].symbols).filter((a) => a[0] !== currentType)) {
-                const filename = (0, to_filename_js_1.toFilename)(symbol);
+                const filename = toFilename(symbol);
                 const subSymbolList = getSubSymbolList(s);
                 // ".js": ESM has no extension search, and the generated files are shipped
                 // source. Without it every regeneration would undo the extensions across
@@ -603,7 +589,7 @@ function dumpUsedExport(currentType, namespaceIndex, cache, f) {
             if (cache.requestedSymbols.namespace[ns]) {
                 for (const [symbol, s] of Object.entries(cache.requestedSymbols.namespace[ns].symbols)) {
                     const subSymbolList = getSubSymbolList(s);
-                    const filename = (0, to_filename_js_1.toFilename)(symbol);
+                    const filename = toFilename(symbol);
                     f.write(`import { ${subSymbolList.join(", ")} } from "${module}/dist/${filename}.js"`);
                 }
             }
@@ -616,7 +602,7 @@ function calculateChevrons(classDef, classDefDerived) {
     let chevronsDef = "";
     let chevronsUse = "";
     let chevronsExtend = "";
-    if (nodeClass !== node_opcua_data_model_1.NodeClass.VariableType) {
+    if (nodeClass !== NodeClass.VariableType) {
         return { chevronsDef, chevronsUse, chevronsExtend };
     }
     if (!isUnspecifiedDataType(dataType)) {
@@ -624,7 +610,7 @@ function calculateChevrons(classDef, classDefDerived) {
         chevronsUse = `<T${m4}>`;
         if (classDefDerived) {
             if (isUnspecifiedDataType(classDefDerived.dataType)) {
-                chevronsExtend = `<T, ${m5}DataType.${node_opcua_variant_1.DataType[dataType]}>`;
+                chevronsExtend = `<T, ${m5}DataType.${DataType[dataType]}>`;
             }
             else {
                 chevronsExtend = `<T${m6}>`;
@@ -640,8 +626,8 @@ function calculateChevrons(classDef, classDefDerived) {
                 chevronsExtend = `<T${m8}, DT>`;
             }
             else {
-                chevronsUse = `<T, ${m9}DataType.${node_opcua_variant_1.DataType[classDefDerived.dataType]}>`;
-                chevronsExtend = `<T, ${mA}DataType.${node_opcua_variant_1.DataType[classDefDerived.dataType]}>`;
+                chevronsUse = `<T, ${m9}DataType.${DataType[classDefDerived.dataType]}>`;
+                chevronsExtend = `<T, ${mA}DataType.${DataType[classDefDerived.dataType]}>`;
             }
         }
     }
@@ -696,11 +682,11 @@ function getBaseClassWithOmit2(classMember) {
 /**
  *  nodeId : a DataType, ReferenceType,AObjectType, VariableType node
  */
-async function _convertTypeToTypescript(session, nodeId, cache, f) {
-    f = f || new node_opcua_utils_1.LineFile();
-    const nodeClass = await (0, utils_js_1.getNodeClass)(session, nodeId);
-    if (nodeClass === node_opcua_data_model_1.NodeClass.DataType) {
-        return await (0, _dataType_js_1._exportDataTypeToTypescript)(session, nodeId, cache, f);
+export async function _convertTypeToTypescript(session, nodeId, cache, f) {
+    f = f || new LineFile();
+    const nodeClass = await getNodeClass(session, nodeId);
+    if (nodeClass === NodeClass.DataType) {
+        return await _exportDataTypeToTypescript(session, nodeId, cache, f);
     }
     const classDef = await extractClassDefinition(session, nodeId, cache);
     // if (classDef.browseName.toString().match(/PubSubDiagnosticsWriterGroupType/)) {
@@ -712,21 +698,21 @@ async function _convertTypeToTypescript(session, nodeId, cache, f) {
     //  f.write(superType.toString());
     f.write(`/**`);
     if (description.text) {
-        f.write((0, utils2_js_1.toComment)(" * ", description.text || ""));
+        f.write(toComment(" * ", description.text || ""));
         f.write(` *`);
     }
-    f.write(` * |                |${(0, utils2_js_1.f1)(" ")}|`);
-    f.write(` * |----------------|${(0, utils2_js_1.f2)("-")}|`);
-    f.write(` * |namespace       |${(0, utils2_js_1.f1)(cache.namespace[nodeId.namespace].namespaceUri)}|`);
-    f.write(` * |nodeClass       |${(0, utils2_js_1.f1)(node_opcua_data_model_1.NodeClass[nodeClass])}|`);
-    f.write(` * |typedDefinition |${(0, utils2_js_1.f1)(`${browseName.name?.toString()} ${n(nodeId)}`)}|`);
-    if (nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
+    f.write(` * |                |${f1(" ")}|`);
+    f.write(` * |----------------|${f2("-")}|`);
+    f.write(` * |namespace       |${f1(cache.namespace[nodeId.namespace].namespaceUri)}|`);
+    f.write(` * |nodeClass       |${f1(NodeClass[nodeClass])}|`);
+    f.write(` * |typedDefinition |${f1(`${browseName.name?.toString()} ${n(nodeId)}`)}|`);
+    if (nodeClass === NodeClass.VariableType) {
         const { valueRank } = classDef;
-        f.write(` * |dataType        |${(0, utils2_js_1.f1)(node_opcua_variant_1.DataType[dataType])}|`);
-        f.write(` * |dataType Name   |${(0, utils2_js_1.f1)(`${dataTypeName} ${n(dataTypeNodeId)}`)}|`);
-        valueRank && f.write(` * |value rank      |${(0, utils2_js_1.f1)(valueRank.toString())}|`);
+        f.write(` * |dataType        |${f1(DataType[dataType])}|`);
+        f.write(` * |dataType Name   |${f1(`${dataTypeName} ${n(dataTypeNodeId)}`)}|`);
+        valueRank && f.write(` * |value rank      |${f1(valueRank.toString())}|`);
     }
-    f.write(` * |isAbstract      |${(0, utils2_js_1.f1)(isAbstract.toString())}|`);
+    f.write(` * |isAbstract      |${f1(isAbstract.toString())}|`);
     f.write(` */`);
     // if (interfaceName.name === "UAOperationLimits") {
     //     debugger;
@@ -737,13 +723,13 @@ async function _convertTypeToTypescript(session, nodeId, cache, f) {
     cache.ensureImported(baseInterfaceName);
     cache.ensureImported({ ...baseInterfaceName, name: `${baseInterfaceName.name}${baseExtension}` });
     const ch = calculateChevrons(classDef);
-    if (nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
+    if (nodeClass === NodeClass.VariableType) {
         if (classDef.dataTypeImport) {
             // c8 ignore next
             if (doDebug) {
-                debugLog(chalk_1.default.red(" ----------------> ", classDef.browseName));
+                debugLog(chalk.red(" ----------------> ", classDef.browseName));
                 classDef.dataTypeImport.forEach((a) => {
-                    debugLog(chalk_1.default.red(" ------------------------> ", a.module, a.name, a.namespace));
+                    debugLog(chalk.red(" ------------------------> ", a.module, a.name, a.namespace));
                 });
             }
             classDef.dataTypeImport.forEach(cache.ensureImported.bind(cache));
@@ -792,7 +778,7 @@ async function _convertTypeToTypescript(session, nodeId, cache, f) {
         }
     }
     const baseStuff = getBaseClassWithOmit(classDef);
-    if (nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
+    if (nodeClass === NodeClass.VariableType) {
         cache.referenceBasicType("DataType");
         // if dataType is a extension object we can simpligy by forcing DT
         const className = `${interfaceName.name}${ch.chevronsDef}`;
@@ -808,16 +794,16 @@ async function _convertTypeToTypescript(session, nodeId, cache, f) {
     f.write(`}`);
     return { type: "ua", content: f.toString(), typeName: interfaceName.name };
 }
-async function convertTypeToTypescript(session, nodeId, options, cache, f) {
-    f = new node_opcua_utils_1.LineFile();
-    cache = cache || (await (0, cache_js_1.constructCache)(session, options));
+export async function convertTypeToTypescript(session, nodeId, options, cache, f) {
+    f = new LineFile();
+    cache = cache || (await constructCache(session, options));
     const { type, content, typeName } = await _convertTypeToTypescript(session, nodeId, cache);
     f.write(`// ----- this file has been automatically generated - do not edit`);
     f.write(dumpUsedExport(typeName, nodeId.namespace, cache));
     f.write(content);
     const folder = cache.namespace[nodeId.namespace].sourceFolder;
     const module = cache.namespace[nodeId.namespace].module;
-    const filename = (0, to_filename_js_1.toFilename)(typeName);
+    const filename = toFilename(typeName);
     const dependencies = findUsedImport(nodeId.namespace, cache);
     return { type, content: f.toString(), folder, module, filename, dependencies };
 }