node-opcua-convert-nodeset-to-javascript 2.51.0

package/source/index.ts

@@ -0,0 +1,3 @@
+export * from "./convert_to_typescript";
+export * from "./convert_namespace_to_typescript";
+export * from "./walk_through";

package/source/main.ts

@@ -0,0 +1,56 @@
+import * as path from "path";
+import { AddressSpace, PseudoSession } from "node-opcua-address-space";
+import { generateAddressSpace } from "node-opcua-address-space/nodeJS";
+import { nodesets } from "node-opcua-nodesets";
+import { convertNamespaceTypeToTypescript } from "./convert_namespace_to_typescript";
+
+async function main() {
+    const addressSpace = AddressSpace.create();
+    await generateAddressSpace(addressSpace, [
+        nodesets.standard,
+        nodesets.di,
+        nodesets.adi,
+        nodesets.autoId,
+        nodesets.machineVision,
+        nodesets.commercialKitchenEquipment,
+        nodesets.gds,
+        nodesets.robotics,
+        nodesets.machinery,
+        nodesets.ia,
+        nodesets.machineTool,
+        nodesets.cnc
+    ]);
+
+
+    const nsUA = 0;
+    const nsDI = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/DI/");
+    const nsADI = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/ADI/");
+    const nsMachineVision = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/MachineVision");
+    const nsAutoId = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/AutoID/");
+    const nsGds = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/GDS/");
+    const nsRobotics = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/Robotics/");
+    const nsMachinery = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/Machinery/");
+    const nsIA = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/IA/");
+    const nsMachineTool = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/MachineTool/");
+    const ncCNC = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/CNC");
+    const nsCommercialKitchenEquipment = addressSpace.getNamespaceIndex("http://opcfoundation.org/UA/CommercialKitchenEquipment/");
+
+    const session = new PseudoSession(addressSpace);
+    const options = {
+        baseFolder: path.join(__dirname, "../../"),
+        prefix: "node-opcua-nodeset-"
+    };
+    await convertNamespaceTypeToTypescript(session, nsUA, options);
+    await convertNamespaceTypeToTypescript(session, nsDI, options);
+    await convertNamespaceTypeToTypescript(session, nsADI, options);
+    await convertNamespaceTypeToTypescript(session, nsMachineVision, options);
+    await convertNamespaceTypeToTypescript(session, nsAutoId, options);
+    await convertNamespaceTypeToTypescript(session, nsGds, options);
+    await convertNamespaceTypeToTypescript(session, nsRobotics, options);
+    await convertNamespaceTypeToTypescript(session, nsMachinery, options);
+    await convertNamespaceTypeToTypescript(session, nsIA, options);
+    await convertNamespaceTypeToTypescript(session, nsMachineTool, options);
+    await convertNamespaceTypeToTypescript(session, ncCNC, options);
+    await convertNamespaceTypeToTypescript(session, nsCommercialKitchenEquipment, options);
+}
+main();

package/source/official_namespaces.ts

@@ -0,0 +1,35 @@
+
+
+export const officialNamespaces = {
+    "standard": {
+        location: "node-opcua-ua-types-ua"
+    },
+    "di": {
+        location: "node-opcua-nodeset-di"
+    },
+    "adi": {
+        location: "node-opcua-nodeset-adi"
+    },
+    "autoId": {
+        location: "node-opcua-nodeset-auto-id"
+    },
+    "machineVision": {
+        location: "node-opcua-nodeset-machine-vision"
+    },
+    "commercialKitchenEquipment": {
+        location: "node-opcua-nodeset-commercial-kitchen-equipment"
+        
+    },
+    "gds": {
+        location: "node-opcua-types-gds"
+    }
+};
+/*
+    nodesets.standard,
+    nodesets.di,
+    nodesets.adi,
+    nodesets.autoId,
+    nodesets.machineVision,
+    nodesets.commercialKitchenEquipment,
+    nodesets.gds
+*/

package/source/options.ts

@@ -0,0 +1,4 @@
+export interface Options {
+    baseFolder: string;
+    prefix: string;
+}

package/source/private/cache.ts

@@ -0,0 +1,228 @@
+import * as path from "path";
+import assert from "node-opcua-assert";
+import { AttributeIds, NodeClass, QualifiedName } from "node-opcua-data-model";
+import { NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { IBasicSession } from "node-opcua-pseudo-session";
+import { DataTypeDefinition, EnumDefinition } from "node-opcua-types";
+import { kebabCase } from "case-anything";
+import { Options } from "../options";
+import { getBrowseName, getDefinition } from "./utils";
+
+export interface Import {
+    name: string;
+    module: string;
+    namespace: number;
+}
+interface CacheInterfaceNamespace {
+    namespaceUri: string;
+    sourceFolder: string;
+    module: string;
+    symbols: { [key: string]: number };
+}
+interface CacheInterface {
+    namespace: CacheInterfaceNamespace[];
+    requestedSymbols: RequestedSymbol;
+}
+export interface RequestedSubSymbol {
+    subSymbols: { [key: string]: number };
+}
+interface RequestedSymbol {
+    namespace: {
+        symbols: { [key: string]: RequestedSubSymbol };
+    }[];
+}
+
+export class Cache implements CacheInterface {
+    namespace: CacheInterfaceNamespace[] = [];
+    requestedSymbols: RequestedSymbol = { namespace: [] };
+    requestedBasicTypes: { [key: string]: number } = {};
+    imports: { [key: string]: { [key: string]: number } } = {};
+    public constructor() {
+        this.imports = {
+            "node-opcua-address-space-base": {
+                UAObject: 1,
+                UAVariable: 1,
+                UAVariableT: 1,
+                UAMethod: 1,
+                UADataType: 1,
+                UAProperty: 1,
+            },
+            "node-opcua-variant": {
+                DataType: 1,
+                Variant: 1
+            },
+            "node-opcua-data-model": {
+                LocalizedText: 1,
+                QualifiedName: 1,
+                DiagnosticInfo: 1
+            },
+            "node-opcua-data-access": {
+                EUInformation: 1
+            },
+            "node-opcua-nodeid": {
+                NodeId: 1,
+                ExpandedNodeId: 1
+            },
+            "node-opcua-status-code": {
+                StatusCode: 1,
+                StatusCodes: 1
+            },
+            "node-opcua-basic-types": {
+                Int64: 1,
+                UInt64: 1,
+                UInt32: 1,
+                Int32: 1,
+                UInt16: 1,
+                Int16: 1,
+                Byte: 1,
+                SByte: 1,
+                UAString: 1,
+                DateTime: 1,
+                Guid: 1
+            },
+            "node-opcua-data-value": {
+                DataValue: 1
+            },
+            "node-opcua-types": {
+                EnumValueType: 1
+            }
+        };
+    }
+    resetRequire(): void {
+        this.requestedSymbols = { namespace: [] };
+        this.requestedBasicTypes = {};
+    }
+
+    referenceBasicType(basicType: string): string {
+        this.requestedBasicTypes[basicType] = (this.requestedBasicTypes[basicType] || 0) + 1;
+        return basicType;
+    }
+
+    _reference(namespaceIndex: number, typeName: string, mainTypeName?: string): void {
+        if (namespaceIndex <= 0 && this.imports["node-opcua-address-space-base"][typeName]) {
+            this.referenceBasicType(typeName);
+            return;
+        }
+        {
+            const sourceFolder = this.namespace[namespaceIndex]?.sourceFolder;
+            if (!sourceFolder) {
+                throw new Error("Cannot find namespace  " + namespaceIndex);
+            }
+        }
+        const symbols = (this.namespace[namespaceIndex].symbols = this.namespace[namespaceIndex].symbols || {});
+        symbols[typeName] = (symbols[typeName] || 0) + 1;
+
+        const ns = this.requestedSymbols.namespace[namespaceIndex] || { symbols: {} };
+        this.requestedSymbols.namespace[namespaceIndex] = ns;
+
+        ns.symbols = ns.symbols || {};
+
+        if (!mainTypeName) {
+            mainTypeName = typeName;
+        }
+        const subs = (ns.symbols[mainTypeName] = ns.symbols[mainTypeName] || { subSymbols: {} });
+        subs.subSymbols[typeName] = (subs.subSymbols[typeName] || 0) + 1;
+    }
+
+    ensureImported(i: Import): void {
+        if (i.namespace < 0) {
+            this.referenceBasicType(i.name);
+        } else {
+            this._reference(i.namespace, i.name, i.module);
+        }
+    }
+}
+
+
+function getSourceFolderForNamespace(browseName: QualifiedName, options: Options, cache: Cache2) {
+    const ns = browseName.namespaceIndex;
+    const n = cache.namespaceArray[ns].split("/").filter((s: string) => s.length !== 0);
+    const nn = n[n.length - 1];
+    const module = options.prefix + kebabCase(nn);
+    const namespaceFolder = path.join(options.baseFolder, module);
+    const sourceFolder = path.join(namespaceFolder);
+    return { sourceFolder, module };
+}
+
+export async function referenceExtensionObject(session: IBasicSession, extensionObjectDataType: NodeId): Promise<Import> {
+    const browseName = await getBrowseName(session, extensionObjectDataType);
+    const definition = await getDefinition(session, extensionObjectDataType);
+    const dataTypeNameImport = makeTypeNameNew(NodeClass.DataType, definition, browseName);
+    return dataTypeNameImport;
+}
+
+export class Cache2 extends Cache {
+    public namespaceArray: string[] = [];
+}
+
+export async function constructCache(session: IBasicSession, options: Options): Promise<Cache2> {
+    const cache = new Cache2();
+
+    cache.namespaceArray = cache.namespaceArray.length
+        ? cache.namespaceArray
+        : (
+              await session.read({
+                  nodeId: resolveNodeId("Server_NamespaceArray"),
+                  attributeId: AttributeIds.Value
+              })
+          ).value.value;
+
+    for (let namespaceIndex = 0; namespaceIndex < cache.namespaceArray.length; namespaceIndex++) {
+        const namespaceUri = cache.namespaceArray[namespaceIndex];
+        const { sourceFolder, module } = getSourceFolderForNamespace(
+            new QualifiedName({ name: namespaceUri, namespaceIndex }),
+            options,
+            cache
+        );
+        cache.namespace.push({
+            namespaceUri,
+            sourceFolder,
+            module,
+            symbols: {}
+        });
+    }
+    return cache;
+}
+
+function makeBasicTypeImport(name: string): Import {
+    return { name, module: "BasicType", namespace: -1 };
+}
+export function makeTypeNameNew(nodeClass: NodeClass, definition: DataTypeDefinition | null, browseName: QualifiedName, suffix?: string): Import {
+    assert(browseName && !!browseName.name, "expecting a class name here");
+
+    const typeName = browseName.name!.toString();
+    if (typeName === "EUInformation") {
+        return makeBasicTypeImport("EUInformation");
+    } else if (typeName === "Enumeration") {
+        return makeBasicTypeImport("Enumeration");
+    } else if (typeName === "BaseObjectType") {
+        return makeBasicTypeImport("UAObject");
+    } else if (typeName === "BaseVariableType") {
+        return makeBasicTypeImport("UAVariableT");
+    } else if (typeName === "BaseDataType") {
+        return makeBasicTypeImport("UADataType");
+    } else {
+        let name = "";
+        switch (nodeClass) {
+            case NodeClass.Method:
+                return makeBasicTypeImport("UAMethod");
+            case NodeClass.Variable:
+            case NodeClass.Object:
+            case NodeClass.VariableType:
+            case NodeClass.ObjectType:
+                name = `UA${typeName.replace(/Type$/, "")}` + (suffix || "");
+                break;
+            case NodeClass.DataType:
+                if (definition instanceof EnumDefinition) {
+                    name = `Enum${typeName.replace(/(DataType|Enumeration|Type)$/, "")}`;
+                } else {
+                    name = `DT${typeName.replace(/(DataType|Enumeration|Type)$/, "")}`;
+                }
+                break;
+        }
+        if (name === "") {
+            throw new Error("Internal Error " + NodeClass[nodeClass] + " " + typeName + "browseName = " + browseName.toString());
+        }
+        return { name, module: name, namespace: browseName.namespaceIndex };
+    }
+}

package/source/private/to_filename.ts

@@ -0,0 +1,6 @@
+import { snakeCase } from "case-anything";
+
+export function toFilename(str: string): string {
+    str = str.replace(/^DT/,"dt_").replace(/^UA/,"ua_").replace(/^Enum/,"enum_");
+    return snakeCase(str);
+}

package/source/private/utils.ts

@@ -0,0 +1,212 @@
+import { AttributeIds, BrowseDirection, LocalizedText, NodeClass, NodeClassMask, QualifiedName } from "node-opcua-data-model";
+import { NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { IBasicSession } from "node-opcua-pseudo-session";
+import { BrowseResult, DataTypeDefinition, ReferenceDescription, StructureDefinition } from "node-opcua-types";
+import { ModellingRuleType } from "node-opcua-address-space-base";
+import { DataType } from "node-opcua-variant";
+import { StatusCodes } from "node-opcua-status-code";
+
+export async function getDefinition(session: IBasicSession, nodeId: NodeId): Promise<DataTypeDefinition | null> {
+    const dataValue = await session.read({ nodeId, attributeId: AttributeIds.DataTypeDefinition });
+    return (dataValue.value.value as DataTypeDefinition) || null;
+}
+export async function getBrowseName(session: IBasicSession, nodeId: NodeId): Promise<QualifiedName> {
+    const dataValue = await session.read({ nodeId, attributeId: AttributeIds.BrowseName });
+    return dataValue.value.value as QualifiedName;
+}
+export async function getDataTypeNodeId(session: IBasicSession, nodeId: NodeId): Promise<NodeId | null> {
+    const dataValue = await session.read({ nodeId, attributeId: AttributeIds.DataType });
+    return (dataValue.value.value as NodeId) || null;
+}
+export async function getIsAbstract(session: IBasicSession, nodeId: NodeId): Promise<boolean> {
+    const dataValue = await session.read({ nodeId, attributeId: AttributeIds.IsAbstract });
+    return dataValue.value.value as boolean;
+}
+export async function getDescription(session: IBasicSession, nodeId: NodeId): Promise<LocalizedText> {
+    const dataValue = await session.read({ nodeId, attributeId: AttributeIds.Description });
+    return dataValue.value.value as LocalizedText;
+}
+
+export async function getNodeClass(session: IBasicSession, nodeId: NodeId): Promise<NodeClass> {
+    const dataValue = await session.read({ nodeId, attributeId: AttributeIds.NodeClass });
+    return dataValue.value.value as NodeClass;
+}
+export async function getChildren(session: IBasicSession, nodeId: NodeId): Promise<ReferenceDescription[]> {
+    const browseResult = await session.browse({
+        browseDirection: BrowseDirection.Forward,
+        includeSubtypes: true,
+        nodeClassMask: NodeClassMask.Method | NodeClassMask.Object | NodeClass.Variable,
+        nodeId,
+        referenceTypeId: resolveNodeId("HasChild"),
+        resultMask: 0xffff
+    });
+    return browseResult.references || [];
+}
+export async function getFolderElements(session: IBasicSession, nodeId: NodeId): Promise<ReferenceDescription[]> {
+    const browseResult = await session.browse({
+        browseDirection: BrowseDirection.Forward,
+        includeSubtypes: true,
+        nodeClassMask: NodeClassMask.Method | NodeClassMask.Object | NodeClass.Variable,
+        nodeId,
+        referenceTypeId: resolveNodeId("Organizes"),
+        resultMask: 0xffff
+    });
+    return browseResult.references || [];
+}
+
+export async function getModellingRule(session: IBasicSession, nodeId: NodeId): Promise<ModellingRuleType | null> {
+    const browseResult = await session.browse({
+        browseDirection: BrowseDirection.Forward,
+        includeSubtypes: true,
+        nodeClassMask: NodeClassMask.Method | NodeClassMask.Object | NodeClass.Variable,
+        nodeId,
+        referenceTypeId: resolveNodeId("HasModellingRule"),
+        resultMask: 0xffff
+    });
+    if (!browseResult.references || browseResult.references.length === 0) {
+        return null; 
+        /* 
+        console.log(nodeId.toString());
+        const browseName = await getBrowseName(session, nodeId);
+        throw new Error("No modelling rule for " + nodeId.toString() + " " + browseName.toString());
+        */
+    }
+    return browseResult.references[0].browseName.name! as ModellingRuleType;
+}
+export async function isExtensionObject(session: IBasicSession, nodeId: NodeId): Promise<boolean> {
+    if (nodeId.namespace === 0 && nodeId.value === 22) {
+        return true;
+    }
+    if (nodeId.namespace === 0 && nodeId.value <= 25) {
+        return false;
+    }
+    const r = await getSubtypeNodeIdIfAny(session, nodeId);
+    return await isExtensionObject(session, r!.nodeId);
+}
+
+export async function extractBasicDataType(session: IBasicSession, dataTypeNodeId: NodeId): Promise<DataType> {
+    if (dataTypeNodeId.namespace === 0 && dataTypeNodeId.value <= 25) {
+        return dataTypeNodeId.value as DataType;
+    }
+    const r = await getSubtypeNodeIdIfAny(session, dataTypeNodeId);
+    return await extractBasicDataType(session, r!.nodeId);
+}
+
+export async function getSubtypeNodeIdIfAny(session: IBasicSession, nodeId: NodeId): Promise<ReferenceDescription | null> {
+    if (nodeId.isEmpty()) {
+        return null;
+    }
+    const browseResult = await session.browse({
+        browseDirection: BrowseDirection.Inverse,
+        includeSubtypes: true,
+        nodeClassMask: 0, // NodeClassMask.ObjectType| NodeClass.VariableType,
+        nodeId,
+        referenceTypeId: resolveNodeId("HasSubtype"),
+        resultMask: 0xffff
+    });
+    if (!browseResult.references || browseResult.references.length === 0) {
+        return null;
+    }
+    return browseResult.references[0];
+}
+export async function getSubtypeNodeId(session: IBasicSession, nodeId: NodeId): Promise<ReferenceDescription> {
+    const r = await getSubtypeNodeIdIfAny(session, nodeId);
+    if (!r) {
+        throw new Error("No Subtype");
+    }
+    return r;
+}
+
+export async function getTypeDefOrBaseType(session: IBasicSession, nodeId: NodeId): Promise<ReferenceDescription> {
+    let browseResult: BrowseResult = await session.browse({
+        browseDirection: BrowseDirection.Forward,
+        includeSubtypes: true,
+        nodeClassMask: 0,
+        nodeId,
+        referenceTypeId: resolveNodeId("HasTypeDefinition"),
+        resultMask: 0xffff
+    });
+
+    if (!browseResult.references || browseResult.references.length === 0) {
+        browseResult = await session.browse({
+            browseDirection: BrowseDirection.Inverse,
+            includeSubtypes: true,
+            nodeClassMask: 0,
+            nodeId,
+            referenceTypeId: resolveNodeId("HasSubtype"),
+            resultMask: 0xffff
+        });
+    }
+    if (!browseResult.references || browseResult.references.length === 0) {
+        // console.log("cannot find type definition / subtype for " + nodeId.toString());
+        return new ReferenceDescription({});
+    }
+    return browseResult.references[0];
+}
+export async function getTypeDefinition(session: IBasicSession, nodeId: NodeId): Promise<ReferenceDescription> {
+    const browseResult = await session.browse({
+        browseDirection: BrowseDirection.Forward,
+        includeSubtypes: true,
+        nodeClassMask: 0,
+        nodeId,
+        referenceTypeId: resolveNodeId("HasTypeDefinition"),
+        resultMask: 0xffff
+    });
+    if (!browseResult.references || browseResult.references.length === 0) {
+        console.log(nodeId.toString());
+        throw new Error("No subtype");
+    }
+    return browseResult.references[0];
+}
+
+// see also client-proxy
+export async function convertNodeIdToDataTypeAsync(session: IBasicSession, dataTypeId: NodeId): Promise<DataType> {
+    const nodeToRead = {
+        attributeId: AttributeIds.BrowseName,
+        nodeId: dataTypeId
+    };
+
+    const dataValue = await session.read(nodeToRead);
+
+    let dataType: DataType;
+    // istanbul ignore next
+    if (dataValue.statusCode !== StatusCodes.Good) {
+        return (dataType = DataType.Null);
+    }
+
+    const dataTypeName = dataValue.value.value;
+
+    if (dataTypeId.namespace === 0 && DataType[dataTypeId.value as number]) {
+        dataType = dataTypeId.value as DataType;
+        return dataType;
+    }
+
+    /// example => Duration (i=290) => Double (i=11)
+    // read subTypeOf
+    const nodeToBrowse = {
+        browseDirection: BrowseDirection.Inverse,
+        nodeId: dataTypeId,
+        referenceTypeId: resolveNodeId("HasSubtype"),
+        resultMask: 0xff
+    };
+    // tslint:disable:no-shadowed-variable
+    const browseResult = await session.browse(nodeToBrowse);
+
+    const references = browseResult!.references;
+
+    if (!references || references.length !== 1) {
+        throw new Error("cannot find SuperType of " + dataTypeName.toString());
+    }
+    const nodeId = references[0].nodeId;
+    return convertNodeIdToDataTypeAsync(session, nodeId);
+}
+
+export async function getChildrenOrFolderElements(session: IBasicSession, nodeId: NodeId): Promise<ReferenceDescription[]> {
+    const c1 = await getChildren(session, nodeId);
+    const c2 = await getFolderElements(session, nodeId);
+    return (<ReferenceDescription[]>[]).concat(c1, c2);
+}
+export async function getValueRank(session: IBasicSession, nodeId: NodeId): Promise<number> {
+    const valueRankDataValue = await session.read({ nodeId, attributeId: AttributeIds.ValueRank });
+    return valueRankDataValue.value.value;
+}

package/source/private-stuff.ts

@@ -0,0 +1,6 @@
+export * from "./index";
+export * from "./options";
+export * from "./private/cache";
+export * from "./private/utils";
+
+

package/source/walk_through.ts

@@ -0,0 +1,73 @@
+import { AttributeIds, BrowseDirection, NodeClass, QualifiedName } from "node-opcua-data-model";
+import { ExpandedNodeId, NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { IBasicSession } from "node-opcua-pseudo-session";
+import { ReferenceDescription } from "node-opcua-types";
+
+export interface ReferenceDescriptionEx extends ReferenceDescription {
+    parent: ReferenceDescriptionEx;
+}
+export interface NodeVisitor {
+    visit(reference: ReferenceDescriptionEx, level: number): Promise<void>;
+}
+async function _walkThroughTypes(
+    session: IBasicSession,
+    nodeId: NodeId,
+    visitor?: NodeVisitor,
+    level?: number,
+    parent?: ReferenceDescription
+): Promise<void> {
+    level = level || 0;
+
+    if (!parent) {
+        const dataValues = await session.read([
+            { nodeId, attributeId: AttributeIds.BrowseName },
+            { nodeId, attributeId: AttributeIds.NodeClass }
+        ]);
+        const browseName = dataValues[0].value.value as QualifiedName;
+        const nodeClass = dataValues[1].value.value as NodeClass;
+        parent = new ReferenceDescription({
+            isForward: true,
+            nodeId: nodeId as ExpandedNodeId,
+            browseName,
+            nodeClass,
+            referenceTypeId: resolveNodeId("HasSubtype")
+            // typeDefinition,
+        });
+    }
+    const browseResult = await session.browse({
+        browseDirection: BrowseDirection.Forward,
+        nodeId,
+        includeSubtypes: true,
+        referenceTypeId: resolveNodeId("HasSubtype"),
+        resultMask: 0xff
+    });
+    for (const reference of browseResult.references || []) {
+        if (visitor) {
+            const r = reference as ReferenceDescriptionEx;
+            r.parent = parent as ReferenceDescriptionEx;
+            await visitor.visit(r, level);
+        }
+        await _walkThroughTypes(session, reference.nodeId, visitor, level + 1, reference);
+    }
+}
+
+export async function walkThroughReferenceTypes(session: IBasicSession, nodeVisitor?: NodeVisitor): Promise<void> {
+    const baseReferenceTypeNodeId = resolveNodeId("References");
+    await _walkThroughTypes(session, baseReferenceTypeNodeId, nodeVisitor);
+}
+export async function walkThroughDataTypes(session: IBasicSession, nodeVisitor?: NodeVisitor): Promise<void> {
+    const baseDataTypeTypeNodeId = resolveNodeId("BaseDataType");
+    await _walkThroughTypes(session, baseDataTypeTypeNodeId, nodeVisitor);
+}
+export async function walkThroughInterfaceTypes(session: IBasicSession, nodeVisitor?: NodeVisitor): Promise<void> {
+    const baseInterfaceTypeNodeId = resolveNodeId("BaseInterfaceType");
+    await _walkThroughTypes(session, baseInterfaceTypeNodeId, nodeVisitor);
+}
+export async function walkThroughObjectTypes(session: IBasicSession, nodeVisitor?: NodeVisitor): Promise<void> {
+    const baseObjectType = resolveNodeId("BaseObjectType");
+    await _walkThroughTypes(session, baseObjectType, nodeVisitor);
+}
+export async function walkThroughVariableTypes(session: IBasicSession, nodeVisitor?: NodeVisitor): Promise<void> {
+    const baseObjectType = resolveNodeId("BaseVariableType");
+    await _walkThroughTypes(session, baseObjectType, nodeVisitor);
+}

package/tsconfig-generated.json

@@ -0,0 +1,13 @@
+{
+    "extends": "../tsconfig.json",
+    "compilerOptions": {
+        "rootDir": "./tmp",
+        "outDir": "./dist-tmp",
+        "composite": true,
+        "incremental": true
+    },
+    "references": [
+     ],
+    "exclude": ["node_modules", "dist", "test", "source/*"],
+    "include": ["./tmp/node-opcua-nodeset*/index.d.ts"]
+}