@vitormnm/node-red-simple-opcua 1.0.0 → 1.0.2

package/server/lib/opcua-address-space-builder.js

@@ -1,1456 +0,0 @@
-"use strict";
-
-const {
-    DATA_TYPE_MAP,
-    StatusCodes,
-    Variant,
-    VariantArrayType,
-    sanitizeNodeIdPath,
-    DataType,
-    coerceNodeId
-} = require("./opcua-constants");
-
-const { OpcUaAddressSpaceAlarm } = require("./opcua-address-space-alarm")
-
-class OpcUaAddressSpaceBuilder {
-    constructor(options) {
-        this.namespace = options.namespace;
-        this.namespaces = options.namespaces || new Map([[2, this.namespace]]);
-        this.server = options.server;
-        this.registry = options.registry;
-        this.node = options.node;
-        this.serverName = options.serverName;
-        this.nodeEntries = new Map();
-        this.variableStore = new Map();
-        this.variableNodeIdStore = new Map();
-        this.objectTypeStore = new Map();
-        this.alarmStore = new Map();
-        this.pendingAlarms = [];
-
-        this.addressSpace = options.addressSpace;
-
-
-
-        this.addressSpaceAlarm = new OpcUaAddressSpaceAlarm({
-            namespace: this.namespace,
-            registry: this.registry,
-            server: this.server,
-            node: this.node
-        });
-    }
-
-    rebuild(treeConfig) {
-        
-        this.sync(treeConfig, { fullReset: true });
-    }
-
-    sync(treeConfig, options) {
-        if (!this.namespace || !this.server) {
-            throw new Error("Address space is not initialized");
-        }
-
-        const settings = options || {};
-        const desiredEntries = this.collectDesiredEntries(treeConfig);
-
-        
-
-        if (settings.fullReset) {
-            this.clearDynamicNodes();
-        }
-
-        const removalRoots = this.collectRemovalRoots(desiredEntries);
-        removalRoots.forEach((path) => this.removeSubtree(path));
-
-
-
-        this.updateExistingNodes(desiredEntries);
-        this.createMissingNodes(desiredEntries);
-        this.flushPendingAlarms();
-
-    }
-
-
-
-    clearDynamicNodes() {
-        const paths = Array.from(this.nodeEntries.keys()).sort(comparePathDepthDesc);
-
-        paths.forEach((path) => this.removeSingleNode(path));
-        this.nodeEntries.clear();
-        this.variableStore.clear();
-        this.variableNodeIdStore.clear();
-        this.objectTypeStore.clear();
-        this.alarmStore.clear(); // Adicione esta linha
-        this.pendingAlarms = [];
-    }
-
-    readValueByPath(path) {
-        return this.getVariableRecordByPath(path).getValue();
-    }
-
-    readValueByNodeId(nodeId) {
-        return this.getVariableRecordByNodeId(nodeId).getValue();
-    }
-
-    eventValueByPath(valuePayload) {
-
-        const path = valuePayload.nodePath
-        const value = valuePayload.value
-        const message = valuePayload.message
-        const severity = valuePayload.severity
-        if (!this.nodeEntries.has(path)) {
-            throw new Error("Unknown path: " + path);
-        }
-
-        const entry = this.nodeEntries.get(path);
-
-
-
-        entry.node.raiseEvent("BaseEventType", {
-            sourceName: {
-                dataType: DataType.String,
-                value: path
-            },
-            message: {
-                dataType: DataType.LocalizedText,
-                value: { text: message }
-            },
-            severity: {
-                dataType: DataType.UInt16,
-                value: severity
-            }
-        });
-
-    }
-
-    writeValueByPath(path, value) {
-        return this.getVariableRecordByPath(path).setValue(value);
-    }
-
-    writeValueByNodeId(nodeId, value) {
-        return this.getVariableRecordByNodeId(nodeId).setValue(value);
-    }
-
-    readValue(identifierType, identifier) {
-        return this.getVariableRecord(identifierType, identifier).getValue();
-    }
-
-    writeValue(identifierType, identifier, value) {
-        return this.getVariableRecord(identifierType, identifier).setValue(value);
-    }
-
-    collectDesiredEntries(treeConfig) {
-        const desiredEntries = new Map();
-        const objectTypeConfigs = this.buildObjectTypeConfigMap(treeConfig);
-
-        (Array.isArray(treeConfig.objectsTypes) ? treeConfig.objectsTypes : []).forEach((objectTypeConfig) => {
-            this.collectObjectTypeDefinition(desiredEntries, objectTypeConfig, objectTypeConfigs);
-        });
-
-        (Array.isArray(treeConfig.folders) ? treeConfig.folders : []).forEach((folderConfig) => {
-            this.collectBranch(desiredEntries, "folder", folderConfig, "", "organizedBy", objectTypeConfigs);
-        });
-
-        (Array.isArray(treeConfig.objects) ? treeConfig.objects : []).forEach((objectConfig) => {
-            this.collectBranch(desiredEntries, "object", objectConfig, "", "organizedBy", objectTypeConfigs);
-        });
-
-        return desiredEntries;
-    }
-
-    buildObjectTypeConfigMap(treeConfig) {
-        const objectTypeConfigs = new Map();
-
-        (Array.isArray(treeConfig.objectsTypes) ? treeConfig.objectsTypes : []).forEach((objectTypeConfig) => {
-            if (objectTypeConfigs.has(objectTypeConfig.name)) {
-                throw new Error("Duplicate object type name: " + objectTypeConfig.name);
-            }
-            objectTypeConfigs.set(objectTypeConfig.name, objectTypeConfig);
-        });
-
-        return objectTypeConfigs;
-    }
-
-    collectObjectTypeDefinition(desiredEntries, config, objectTypeConfigs) {
-        const path = this.buildObjectTypePath(config.name);
-        desiredEntries.set(path, this.buildEntryDefinition("objectTypeDefinition", config, path, "", "typeDefinition"));
-        this.collectBranchChildren(desiredEntries, config, path, "componentOf", objectTypeConfigs, {
-            skipAlarms: false,
-            preserveCollectionNames: true,
-            typeRootPath: path
-        });
-    }
-
-    collectBranch(desiredEntries, kind, config, parentPath, relationship, objectTypeConfigs, options) {
-        const settings = options || {};
-        const path = settings.preserveCollectionNames
-            ? this.buildCollectionPath(parentPath, kind === "folder" ? "folders" : "objects", config.name)
-            : this.buildPath(parentPath, config.name);
-        desiredEntries.set(path, this.buildEntryDefinition(kind, config, path, parentPath, relationship));
-        this.collectBranchChildren(
-            desiredEntries,
-            config,
-            path,
-            kind === "folder" ? "organizedBy" : "componentOf",
-            objectTypeConfigs,
-            settings
-        );
-    }
-
-    collectBranchChildren(desiredEntries, config, path, childRelationship, objectTypeConfigs, options) {
-        const settings = options || {};
-        const preserveCollectionNames = !!settings.preserveCollectionNames;
-        (Array.isArray(config.folders) ? config.folders : []).forEach((folderConfig) => {
-            this.collectBranch(
-                desiredEntries,
-                "folder",
-                folderConfig,
-                path,
-                childRelationship,
-                objectTypeConfigs,
-                settings
-            );
-        });
-
-        (Array.isArray(config.objects) ? config.objects : []).forEach((objectConfig) => {
-            this.collectBranch(
-                desiredEntries,
-                "object",
-                objectConfig,
-                path,
-                childRelationship,
-                objectTypeConfigs,
-                settings
-            );
-        });
-
-        (Array.isArray(config.variables) ? config.variables : []).forEach((variableConfig) => {
-            const childPath = preserveCollectionNames
-                ? this.buildCollectionPath(path, "variables", variableConfig.name)
-                : this.buildPath(path, variableConfig.name);
-            desiredEntries.set(
-                childPath,
-                this.buildEntryDefinition("variable", variableConfig, childPath, path, "componentOf")
-            );
-        });
-
-        (Array.isArray(config.methods) ? config.methods : []).forEach((methodConfig) => {
-            const childPath = preserveCollectionNames
-                ? this.buildCollectionPath(path, "methods", methodConfig.name)
-                : this.buildPath(path, methodConfig.name);
-            desiredEntries.set(
-                childPath,
-                this.buildEntryDefinition("method", methodConfig, childPath, path, "componentOf")
-            );
-        });
-
-        (Array.isArray(config.objectsTypes) ? config.objectsTypes : []).forEach((objectTypeInstanceConfig) => {
-            this.collectObjectTypeInstance(
-                desiredEntries,
-                objectTypeInstanceConfig,
-                path,
-                childRelationship,
-                objectTypeConfigs,
-                settings
-            );
-        });
-
-        if (!settings.skipAlarms) {
-            //alarmes
-            (Array.isArray(config.alarms) ? config.alarms : []).forEach((alarmConfig) => {
-                const childPath = preserveCollectionNames
-                    ? this.buildCollectionPath(path, "alarms", alarmConfig.name)
-                    : this.buildPath(path, alarmConfig.name);
-
-                desiredEntries.set(
-                    childPath,
-                    this.buildEntryDefinition("alarm", alarmConfig, childPath, path, "componentOf")
-                );
-                //this.addAlarmPlaceholder(path, alarmConfig);
-            });
-        }
-    }
-
-    collectObjectTypeInstance(desiredEntries, instanceConfig, parentPath, relationship, objectTypeConfigs, options) {
-        const path = this.buildPath(parentPath, instanceConfig.name);
-        desiredEntries.set(
-            path,
-            this.buildEntryDefinition("objectTypeInstance", instanceConfig, path, parentPath, relationship)
-        );
-        // Variables, methods and nested objectsTypes inherited from the type definition
-        // are instantiated automatically by node-opcua when addObject({ typeDefinition })
-        // is called. We must NOT add them as independent desiredEntries — that would
-        // create duplicate nodes on top of the ones the lib already created.
-        // Only extra children defined directly on the instance (not inherited) are added here.
-        const instanceOnlyConfig = {
-            folders:      Array.isArray(instanceConfig.folders)     ? instanceConfig.folders     : [],
-            objects:      Array.isArray(instanceConfig.objects)     ? instanceConfig.objects      : [],
-            variables:    Array.isArray(instanceConfig.variables)   ? instanceConfig.variables   : [],
-            methods:      Array.isArray(instanceConfig.methods)     ? instanceConfig.methods     : [],
-            alarms:       Array.isArray(instanceConfig.alarms)      ? instanceConfig.alarms      : [],
-            objectsTypes: Array.isArray(instanceConfig.objectsTypes) ? instanceConfig.objectsTypes : []
-        };
-        this.collectBranchChildren(desiredEntries, instanceOnlyConfig, path, "componentOf", objectTypeConfigs, Object.assign({}, options, {
-            skipAlarms: false,
-            preserveCollectionNames: false
-        }));
-    }
-
-    expandObjectTypeInstanceConfig(instanceConfig, objectTypeConfigs, stack) {
-        const typeName = instanceConfig.objectsType;
-        if (stack.indexOf(typeName) !== -1) {
-            throw new Error("Circular object type reference: " + stack.concat(typeName).join(" -> "));
-        }
-
-        const baseConfig = objectTypeConfigs.get(typeName);
-        if (!baseConfig) {
-            throw new Error("Unknown object type: " + typeName);
-        }
-
-        return this.mergeObjectTypeConfigs(baseConfig, instanceConfig, objectTypeConfigs, stack.concat(typeName));
-    }
-
-    mergeObjectTypeConfigs(baseConfig, instanceConfig, objectTypeConfigs, stack) {
-        const merged = {
-            name: instanceConfig.name,
-            displayName: instanceConfig.displayName || instanceConfig.name,
-            description: instanceConfig.description || "",
-            folders: this.cloneConfigs(baseConfig.folders),
-            objects: this.cloneConfigs(baseConfig.objects),
-            variables: this.cloneConfigs(baseConfig.variables),
-            methods: this.cloneConfigs(baseConfig.methods),
-            alarms: this.cloneConfigs(baseConfig.alarms),
-            objectsTypes: []
-        };
-
-        const baseInstances = Array.isArray(baseConfig.objectsTypes) ? baseConfig.objectsTypes : [];
-        const instanceOverrides = Array.isArray(instanceConfig.objectsTypes) ? instanceConfig.objectsTypes : [];
-
-        merged.objectsTypes = baseInstances
-            .map((nestedInstanceConfig) => this.mergeNestedObjectTypeInstance(nestedInstanceConfig, objectTypeConfigs, stack))
-            .concat(this.cloneConfigs(instanceOverrides));
-
-        merged.folders = merged.folders.concat(this.cloneConfigs(instanceConfig.folders));
-        merged.objects = merged.objects.concat(this.cloneConfigs(instanceConfig.objects));
-        merged.variables = merged.variables.concat(this.cloneConfigs(instanceConfig.variables));
-        merged.methods = merged.methods.concat(this.cloneConfigs(instanceConfig.methods));
-        merged.alarms = merged.alarms.concat(this.cloneConfigs(instanceConfig.alarms));
-
-        return merged;
-    }
-
-    mergeNestedObjectTypeInstance(instanceConfig, objectTypeConfigs, stack) {
-        const cloned = this.cloneConfig(instanceConfig);
-        if (cloned && cloned.objectsType) {
-            const typeName = cloned.objectsType;
-            if (stack.indexOf(typeName) !== -1) {
-                throw new Error("Circular object type reference: " + stack.concat(typeName).join(" -> "));
-            }
-            if (!objectTypeConfigs.has(typeName)) {
-                throw new Error("Unknown object type: " + typeName);
-            }
-        }
-        return cloned;
-    }
-
-    cloneConfigs(items) {
-        return Array.isArray(items) ? items.map((item) => this.cloneConfig(item)) : [];
-    }
-
-    cloneConfig(item) {
-        return item ? JSON.parse(JSON.stringify(item)) : item;
-    }
-
-    rewriteAlarmVariablePaths(branchConfig, currentPath, rootInstancePath) {
-        if (!branchConfig || typeof branchConfig !== "object") {
-            return;
-        }
-
-        (Array.isArray(branchConfig.alarms) ? branchConfig.alarms : []).forEach((alarmConfig) => {
-            const variableNodeId = String(alarmConfig.variableNodeId || "").trim();
-            if (!variableNodeId) {
-                return;
-            }
-
-            if (variableNodeId.indexOf(".") === 0) {
-                alarmConfig.variableNodeId = this.resolveObjectTypeRelativeReference(rootInstancePath, variableNodeId);
-                return;
-            }
-
-            if (variableNodeId.indexOf(currentPath + ".") === 0 || variableNodeId === currentPath) {
-                return;
-            }
-
-            if (variableNodeId.indexOf(rootInstancePath + ".") === 0 || variableNodeId === rootInstancePath) {
-                return;
-            }
-
-            if (variableNodeId.indexOf("__objectTypes.") === 0) {
-                return;
-            }
-
-            alarmConfig.variableNodeId = currentPath + "." + variableNodeId;
-        });
-
-        (Array.isArray(branchConfig.folders) ? branchConfig.folders : []).forEach((folderConfig) => {
-            this.rewriteAlarmVariablePaths(folderConfig, this.buildPath(currentPath, folderConfig.name), rootInstancePath);
-        });
-
-        (Array.isArray(branchConfig.objects) ? branchConfig.objects : []).forEach((objectConfig) => {
-            this.rewriteAlarmVariablePaths(objectConfig, this.buildPath(currentPath, objectConfig.name), rootInstancePath);
-        });
-    }
-
-    buildEntryDefinition(kind, config, path, parentPath, relationship) {
-        return {
-            kind,
-            path,
-            parentPath,
-            relationship,
-            config,
-            signature: this.buildSignature(kind, config, parentPath, relationship)
-        };
-    }
-
-    buildSignature(kind, config, parentPath, relationship) {
-        if (kind === "variable") {
-            return JSON.stringify({
-                kind,
-                parentPath,
-                relationship,
-                nodeId: config.nodeId || "",
-                namespaceId: this.resolveNamespaceId(config),
-                displayName: config.displayName || config.name,
-                description: config.description || "",
-                type: config.type,
-                access: config.access,
-                isArray: this.isArrayValue(config.value)
-            });
-        }
-
-        if (kind === "method") {
-            return JSON.stringify({
-                kind,
-                parentPath,
-                relationship,
-                nodeId: config.nodeId || "",
-                namespaceId: this.resolveNamespaceId(config),
-                displayName: config.displayName || config.name,
-                description: config.description || "",
-                inputs: Array.isArray(config.inputs) ? config.inputs : [],
-                outputs: Array.isArray(config.outputs) ? config.outputs : []
-            });
-        }
-
-        if (kind === "objectTypeInstance") {
-            return JSON.stringify({
-                kind,
-                parentPath,
-                relationship,
-                nodeId: config.nodeId || "",
-                namespaceId: this.resolveNamespaceId(config),
-                displayName: config.displayName || config.name,
-                description: config.description || "",
-                objectsType: config.objectsType
-            });
-        }
-
-        return JSON.stringify({
-            kind,
-            parentPath,
-            relationship,
-            nodeId: config.nodeId || "",
-            namespaceId: this.resolveNamespaceId(config),
-            displayName: config.displayName || config.name,
-            description: config.description || ""
-        });
-    }
-
-    collectRemovalRoots(desiredEntries) {
-        const candidates = [];
-
-        this.nodeEntries.forEach((entry, path) => {
-            const desired = desiredEntries.get(path);
-
-            if (!desired) {
-                candidates.push(path);
-                return;
-            }
-
-            if (entry.kind !== desired.kind || entry.signature !== desired.signature) {
-                candidates.push(path);
-            }
-        });
-
-        return collapsePaths(candidates);
-    }
-
-    updateExistingNodes(desiredEntries) {
-        desiredEntries.forEach((desired, path) => {
-            const existing = this.nodeEntries.get(path);
-            if (!existing || existing.kind !== desired.kind) {
-                return;
-            }
-
-            if (existing.kind === "variable") {
-                const record = this.variableStore.get(path);
-                if (record) {
-                    record.setRuntimeValue(desired.config.value);
-                }
-            }
-        });
-    }
-
-    createMissingNodes(desiredEntries) {
-        const ordered = Array.from(desiredEntries.values()).sort(compareEntryCreationOrder);
-        ordered.forEach((definition) => {
-            if (this.nodeEntries.has(definition.path)) {
-                return;
-            }
-
-            this.createNode(definition);
-        });
-    }
-
-    createNode(definition) {
-        const parentNode = this.resolveParentNode(definition.parentPath);
-
-        
-
-        if (definition.kind === "folder") {
-            this.addFolder(parentNode, definition.config, definition.parentPath, definition.relationship, definition.path);
-            return;
-        }
-
-        if (definition.kind === "objectTypeDefinition") {
-
-            this.addObjectTypeDefinition(definition.config);
-            return;
-        }
-
-        if (definition.kind === "object") {
-            this.addObject(parentNode, definition.config, definition.parentPath, definition.relationship, definition.path);
-            return;
-        }
-
-        if (definition.kind === "objectTypeInstance") {
-            this.addObjectTypeInstance(parentNode, definition.config, definition.parentPath, definition.relationship, definition.path);
-            return;
-        }
-
-        if (definition.kind === "alarm") {
-            this.addAlarm(parentNode, definition.config, definition.parentPath, definition.relationship, definition.path);
-            return;
-
-        }
-
-        if (definition.kind === "variable") {
-            this.addVariable(parentNode, definition.config, definition.parentPath, definition.path);
-            return;
-        }
-
-        if (definition.kind === "method") {
-            this.addMethod(parentNode, definition.config, definition.parentPath, definition.path);
-        }
-
-
-    }
-
-    resolveParentNode(parentPath) {
-        if (!parentPath) {
-            return this.server.engine.addressSpace.rootFolder.objects;
-        }
-
-        const parentEntry = this.nodeEntries.get(parentPath);
-        if (!parentEntry || !parentEntry.node) {
-            throw new Error("Parent node is not available for path: " + parentPath);
-        }
-
-        return parentEntry.node;
-    }
-
-    removeSubtree(rootPath) {
-        const affectedPaths = Array.from(this.nodeEntries.keys())
-            .filter((path) => isSamePathOrDescendant(path, rootPath))
-            .sort(comparePathDepthDesc);
-
-        affectedPaths.forEach((path) => this.removeSingleNode(path));
-    }
-
-    removeSingleNode(path) {
-        const entry = this.nodeEntries.get(path);
-        if (!entry) {
-            return;
-        }
-
-        if (entry.kind === "variable") {
-            const record = this.variableStore.get(path);
-            if (record && record.nodeIdKey) {
-                this.variableNodeIdStore.delete(record.nodeIdKey);
-            }
-            this.variableStore.delete(path);
-        }
-
-        if (entry.kind === "objectTypeDefinition") {
-            this.objectTypeStore.delete(entry.config.name);
-        }
-
-        try {
-            entry.namespace.deleteNode(entry.node);
-
-        } catch (error) {
-            console.error("error removeSingleNode")
-            console.error(error)
-            this.node.debug("Ignoring deleteNode error for " + path + ": " + error.message);
-        }
-
-
-
-        this.nodeEntries.delete(path);
-    }
-
-    addObject(parentNode, objectConfig, parentPath, relationship, pathOverride) {
-        const namespace = this.getNamespaceForConfig(objectConfig);
-
-        const addressSpace = this.server.engine.addressSpace;
-        const serverNode = addressSpace.rootFolder.objects.server;
-
-
-        const objectName = objectConfig.name;
-        const nextPath = pathOverride || this.buildPath(parentPath, objectName);
-        const options = {
-            browseName: objectConfig.displayName || objectName,
-            displayName: objectConfig.displayName || objectName,
-            description: objectConfig.description || "",
-            nodeId: this.resolveNodeId(objectConfig, nextPath, namespace),
-            eventNotifier: 1, //enabled_events,
-            eventSourceOf: serverNode
-        };
-
-        if (relationship === "organizedBy") {
-            options.organizedBy = parentNode;
-        } else {
-            options.componentOf = parentNode;
-        }
-
-        if (this.isObjectTypePath(parentPath)) {
-            options.modellingRule = "Mandatory";
-        }
-
-        const objectNode = namespace.addObject(options);
-        this.registerNodeEntry("object", nextPath, parentPath, relationship, objectConfig, objectNode, namespace);
-    }
-
-    addObjectTypeDefinition(objectTypeConfig) {
-        const namespace = this.getNamespaceForConfig(objectTypeConfig);
-        const objectTypeNode = namespace.addObjectType({
-            browseName: objectTypeConfig.name,
-            displayName: objectTypeConfig.displayName || objectTypeConfig.name,
-            description: objectTypeConfig.description || "",
-            nodeId: this.resolveNodeId(objectTypeConfig, this.buildObjectTypePath(objectTypeConfig.name), namespace),
-            subtypeOf: "BaseObjectType"
-        });
-
-
-        const path = this.buildObjectTypePath(objectTypeConfig.name);
-
-
-
-        this.registerNodeEntry("objectTypeDefinition", path, "", "typeDefinition", objectTypeConfig, objectTypeNode, namespace);
-        this.objectTypeStore.set(objectTypeConfig.name, {
-            node: objectTypeNode,
-            config: objectTypeConfig,
-            path: path,
-            namespace: namespace
-        });
-    }
-
-    addObjectTypeInstance(parentNode, instanceConfig, parentPath, relationship, pathOverride) {
-        const objectTypeEntry = this.objectTypeStore.get(instanceConfig.objectsType);
-        if (!objectTypeEntry || !objectTypeEntry.node) {
-            throw new Error("Object type is not available for instance " + instanceConfig.name + ": " + instanceConfig.objectsType);
-        }
-
-        const objectName = instanceConfig.name;
-        const nextPath = pathOverride || this.buildPath(parentPath, objectName);
-        const namespace = this.getNamespaceForConfig(instanceConfig);
-
-        const options = {
-            browseName: instanceConfig.displayName || objectName,
-            displayName: instanceConfig.displayName || objectName,
-            description: instanceConfig.description || "",
-            nodeId: this.resolveNodeId(instanceConfig, nextPath, namespace),
-            typeDefinition: objectTypeEntry.node.nodeId,
-            eventNotifier: 1
-        };
-
-        if (relationship === "organizedBy") {
-            options.organizedBy = parentNode;
-        } else {
-            options.componentOf = parentNode;
-        }
-
-        const objectNode = namespace.addObject(options);
-        this.registerNodeEntry("objectTypeInstance", nextPath, parentPath, relationship, instanceConfig, objectNode, namespace);
-
-        // Create the inherited children explicitly using the configs that opcua-config.js
-        // already rewrote with the correct instance nodeIds (e.g. server1.newObjectType.cmd_on).
-        // We do NOT call instantiate() because node-opcua cannot auto-assign nodeIds for the
-        // cloned children when the type children already have explicit string nodeIds registered.
-        this.createInheritedChildren(objectNode, nextPath, instanceConfig, namespace);
-    }
-
-    createInheritedChildren(instanceNode, instancePath, instanceConfig, namespace) {
-        const typeEntry = this.objectTypeStore.get(instanceConfig.objectsType);
-        if (!typeEntry) return;
-
-        // Extract the type's nodeId value prefix (e.g. "Motor_type2") and the
-        // instance's nodeId value prefix (e.g. "server1.newObjectType") so we can
-        // rewrite every child nodeId from the type to the instance on-the-fly.
-        const typeNodeId      = typeEntry.config.nodeId || "";
-        const instanceNodeId  = instanceConfig.nodeId   || "";
-        const typePrefix      = this.extractNodeIdStringValue(typeNodeId);
-        const instancePrefix  = this.extractNodeIdStringValue(instanceNodeId);
-
-        this.createInheritedBranchChildren(typeEntry.config, instanceNode, instancePath, typePrefix, instancePrefix);
-    }
-
-    extractNodeIdStringValue(nodeId) {
-        const m = String(nodeId || "").match(/(?:^|;)s=(.+)$/);
-        return m ? m[1] : "";
-    }
-
-    rewriteInheritedNodeId(nodeId, typePrefix, instancePrefix) {
-        if (!nodeId || !typePrefix || !instancePrefix) return nodeId;
-        const m = String(nodeId).match(/^(ns=\d+;s=)([\s\S]*)$/);
-        if (m && m[2].startsWith(typePrefix)) {
-            return m[1] + instancePrefix + m[2].slice(typePrefix.length);
-        }
-        return nodeId;
-    }
-
-    createInheritedBranchChildren(typeConfig, parentOpcNode, parentPath, typePrefix, instancePrefix) {
-        const variables = Array.isArray(typeConfig.variables) ? typeConfig.variables : [];
-        const methods   = Array.isArray(typeConfig.methods)   ? typeConfig.methods   : [];
-        const folders   = Array.isArray(typeConfig.folders)   ? typeConfig.folders   : [];
-        const objects   = Array.isArray(typeConfig.objects)   ? typeConfig.objects   : [];
-
-        variables.forEach((varConfig) => {
-            const childPath = this.buildPath(parentPath, varConfig.name);
-            const rewrittenConfig = Object.assign({}, varConfig, {
-                nodeId: this.rewriteInheritedNodeId(varConfig.nodeId, typePrefix, instancePrefix)
-            });
-            this.addVariable(parentOpcNode, rewrittenConfig, parentPath, childPath);
-        });
-
-        methods.forEach((methodConfig) => {
-            const childPath = this.buildPath(parentPath, methodConfig.name);
-            const rewrittenConfig = Object.assign({}, methodConfig, {
-                nodeId: this.rewriteInheritedNodeId(methodConfig.nodeId, typePrefix, instancePrefix)
-            });
-            this.addMethod(parentOpcNode, rewrittenConfig, parentPath, childPath);
-        });
-
-        folders.forEach((folderConfig) => {
-            const childPath = this.buildPath(parentPath, folderConfig.name);
-            const rewrittenConfig = Object.assign({}, folderConfig, {
-                nodeId: this.rewriteInheritedNodeId(folderConfig.nodeId, typePrefix, instancePrefix)
-            });
-            this.addFolder(parentOpcNode, rewrittenConfig, parentPath, "componentOf", childPath);
-            const childNode = this.nodeEntries.get(childPath) && this.nodeEntries.get(childPath).node;
-            if (childNode) {
-                this.createInheritedBranchChildren(folderConfig, childNode, childPath, typePrefix, instancePrefix);
-            }
-        });
-
-        objects.forEach((objectConfig) => {
-            const childPath = this.buildPath(parentPath, objectConfig.name);
-            const rewrittenConfig = Object.assign({}, objectConfig, {
-                nodeId: this.rewriteInheritedNodeId(objectConfig.nodeId, typePrefix, instancePrefix)
-            });
-            this.addObject(parentOpcNode, rewrittenConfig, parentPath, "componentOf", childPath);
-            const childNode = this.nodeEntries.get(childPath) && this.nodeEntries.get(childPath).node;
-            if (childNode) {
-                this.createInheritedBranchChildren(objectConfig, childNode, childPath, typePrefix, instancePrefix);
-            }
-        });
-    }
-
-        addAlarm(parentNode, alarmConfig, parentPath, relationship, pathOverride) {
-
-
-
-        try {
-
-            const name = alarmConfig.name;
-            const variableNodeId = alarmConfig.variableNodeId;
-            const objectName = alarmConfig.name;
-            const nextPath = pathOverride || this.buildPath(parentPath, objectName);
-            const path = pathOverride || this.buildPath(parentPath, name);
-            const namespace = this.getNamespaceForConfig(alarmConfig);
-            const options = {
-                browseName: alarmConfig.displayName || objectName,
-                displayName: alarmConfig.displayName || objectName,
-                description: alarmConfig.description || "",
-                nodeId: this.resolveNodeId(alarmConfig, nextPath, namespace),
-                eventNotifier: 1 //enabled_events
-            };
-
-            if (relationship === "organizedBy") {
-                options.organizedBy = parentNode;
-            } else {
-                options.componentOf = parentNode;
-            }
-
-            const variableToMonitor = this.resolveAlarmVariableRecord(parentPath, parentNode, variableNodeId)
-
-            const sourceName = variableToMonitor.node.displayName[0].text
-
-            const browseName = alarmConfig.displayName || objectName
-            const inputNode = variableToMonitor.node
-
-
-
-            const conditionName = alarmConfig.displayName || objectName
-            const nodeId = this.resolveNodeId(alarmConfig, nextPath, namespace)
-
-            const alarmNode = this.addressSpaceAlarm.createAlarm(namespace, browseName, parentNode, inputNode, conditionName, nodeId, sourceName, alarmConfig)
-
-
-
-
-            // register alarm
-            variableToMonitor.alarm = {
-                node: alarmNode,
-                alarmConfig: alarmConfig,
-            }
-            // const alarmNode = this.namespace.instantiateOffNormalAlarm(options);
-            this.registerNodeEntry("alarm", nextPath, parentPath, relationship, alarmConfig, alarmNode, namespace);
-
-
-
-
-        } catch (error) {
-
-            if (error && error.message && error.message.indexOf("Unknown alarm variable reference:") === 0) {
-                this.queuePendingAlarm(parentNode, alarmConfig, parentPath, relationship);
-                return;
-            }
-            console.error("erro addAlarm")
-            console.error(error)
-        }
-
-
-    }
-
-    queuePendingAlarm(parentNode, alarmConfig, parentPath, relationship) {
-        const path = this.buildPath(parentPath, alarmConfig.name);
-        const alreadyQueued = this.pendingAlarms.some((item) => item.path === path);
-        if (alreadyQueued) {
-            return;
-        }
-
-        this.pendingAlarms.push({
-            path: path,
-            parentNode: parentNode,
-            alarmConfig: this.cloneConfig(alarmConfig),
-            parentPath: parentPath,
-            relationship: relationship
-        });
-    }
-
-    flushPendingAlarms() {
-        if (!this.pendingAlarms.length) {
-            return;
-        }
-
-        const pending = this.pendingAlarms.slice();
-        this.pendingAlarms = [];
-
-        pending.forEach((item) => {
-            if (this.nodeEntries.has(item.path)) {
-                return;
-            }
-
-            this.addAlarm(item.parentNode, item.alarmConfig, item.parentPath, item.relationship);
-        });
-
-        if (this.pendingAlarms.length) {
-            const unresolved = this.pendingAlarms.map((item) => item.path).join(", ");
-            this.pendingAlarms = [];
-            throw new Error("Unresolved alarms after build: " + unresolved);
-        }
-    }
-
-
-
-
-    addFolder(parentNode, folderConfig, parentPath, relationship, pathOverride) {
-        const namespace = this.getNamespaceForConfig(folderConfig);
-
-        const addressSpace = this.server.engine.addressSpace;
-        const serverNode = addressSpace.rootFolder.objects.server;
-
-        const folderName = folderConfig.name;
-        const nextPath = pathOverride || this.buildPath(parentPath, folderName);
-        const options = {
-            browseName: folderConfig.displayName || folderName,
-            displayName: folderConfig.displayName || folderName,
-            description: folderConfig.description || "",
-            nodeId: this.resolveNodeId(folderConfig, nextPath, namespace),
-            typeDefinition: "FolderType",
-            eventSourceOf: serverNode,
-            eventNotifier: 1 //enabled_events
-        };
-
-        if (relationship === "organizedBy") {
-            options.organizedBy = parentNode;
-        } else {
-            options.componentOf = parentNode;
-        }
-
-        if (this.isObjectTypePath(parentPath)) {
-            options.modellingRule = "Mandatory";
-        }
-
-        const folderNode = namespace.addObject(options);
-        this.registerNodeEntry("folder", nextPath, parentPath, relationship, folderConfig, folderNode, namespace);
-    }
-
-    addVariable(parentNode, variableConfig, parentPath, pathOverride) {
-        const namespace = this.getNamespaceForConfig(variableConfig);
-        const name = variableConfig.name;
-        const type = variableConfig.type;
-        const access = variableConfig.access;
-        const path = pathOverride || this.buildPath(parentPath, name);
-        const nodeId = this.resolveNodeId(variableConfig, path, namespace);
-        const browseName = variableConfig.displayName || name;
-        const state = {
-            type,
-            access,
-            isArray: this.isArrayValue(variableConfig.value),
-            currentValue: variableConfig.value
-        };
-
-        const variableNode = namespace.addVariable({
-            componentOf: parentNode,
-            browseName,
-            displayName: browseName,
-            description: variableConfig.description || "",
-            nodeId,
-            dataType: type,
-            modellingRule: this.isObjectTypePath(parentPath) ? "Mandatory" : undefined,
-            valueRank: state.isArray ? 1 : -1,
-            accessLevel: access === "readwrite" ? "CurrentRead | CurrentWrite" : "CurrentRead",
-            userAccessLevel: access === "readwrite" ? "CurrentRead | CurrentWrite" : "CurrentRead",
-            minimumSamplingInterval: 500,
-            value: {
-                get: () => {
-                    this.emitTagAccess("read", {
-                        path,
-                        nodeID: nodeId,
-                        browseName,
-                        dataType: state.type,
-                        value: state.currentValue
-                    });
-
-                    const variantOptions = {
-                        dataType: DATA_TYPE_MAP[state.type],
-                        value: state.currentValue
-                    };
-
-                    if (this.isArrayValue(state.currentValue)) {
-                        variantOptions.arrayType = VariantArrayType.Array;
-                    }
-
-                    return new Variant(variantOptions);
-                },
-                set: (variant) => {
-                    if (state.access !== "readwrite") {
-                        return StatusCodes.BadNotWritable;
-                    }
-
-                    try {
-                        state.currentValue = this.coerceValue(variant.value, state.type, state.isArray);
-                        this.emitTagAccess("write", {
-                            path,
-                            nodeID: nodeId,
-                            browseName,
-                            dataType: state.type,
-                            value: state.currentValue
-                        });
-
-                        const alarm = this.variableStore.get(path).alarm
-                        this.addressSpaceAlarm.checkAlarm(alarm, variant.value)
-
-
-
-                        return StatusCodes.Good;
-                    } catch (error) {
-                        console.error("addVariable")
-                        console.error(error)
-                        // this.node.warn("Rejected OPC UA write for " + path + ": " + error.message);
-                        return StatusCodes.BadTypeMismatch;
-                    }
-                }
-            }
-        });
-
-        this.registerNodeEntry("variable", path, parentPath, "componentOf", variableConfig, variableNode, namespace);
-        const record = {
-            node: variableNode,
-            path: path,
-            nodeId: nodeId,
-            nodeIdKey: this.normalizeNodeIdKey(nodeId),
-            getValue: () => state.currentValue,
-            setRuntimeValue: (nextValue) => {
-                state.currentValue = this.coerceValue(nextValue, state.type, state.isArray);
-                return state.currentValue;
-            },
-            setValue: (nextValue) => {
-                if (state.access !== "readwrite") {
-                    throw new Error("Tag is read-only: " + path);
-                }
-
-                state.currentValue = this.coerceValue(nextValue, state.type, state.isArray);
-
-                const alarm = this.variableStore.get(path).alarm
-                this.addressSpaceAlarm.checkAlarm(alarm, state.currentValue)
-
-                return state.currentValue;
-            }
-        };
-        this.variableStore.set(path, record);
-        this.variableNodeIdStore.set(record.nodeIdKey, record);
-    }
-
-
-
-
-
-    addMethod(parentNode, methodConfig, parentPath, pathOverride) {
-        const namespace = this.getNamespaceForConfig(methodConfig);
-        const methodName = methodConfig.name;
-        const path = pathOverride || this.buildPath(parentPath, methodName);
-        const methodNode = namespace.addMethod(parentNode, {
-            browseName: methodConfig.displayName || methodName,
-            displayName: methodConfig.displayName || methodName,
-            description: { text: methodConfig.description || "" },
-            nodeId: this.resolveNodeId(methodConfig, path, namespace),
-            modellingRule: this.isObjectTypePath(parentPath) ? "Mandatory" : undefined,
-            inputArguments: methodConfig.inputs.map((arg) => ({
-                name: arg.name,
-                description: { text: arg.description || "" },
-                dataType: DATA_TYPE_MAP[arg.type]
-            })),
-            outputArguments: methodConfig.outputs.map((arg) => ({
-                name: arg.name,
-                description: { text: arg.description || "" },
-                dataType: DATA_TYPE_MAP[arg.type]
-            }))
-        });
-
-        methodNode.bindMethod((inputArguments, context, callback) => {
-            const callId = Date.now() + "_" + Math.random();
-
-            this.registry.emitMethodCall({
-                methodName: methodConfig.name,
-                callId,
-                inputArguments,
-                serverName: this.serverName
-            });
-
-            this.registry.waitForMethodResponse(callId)
-                .then((outputs) => {
-                    callback(null, {
-                        statusCode: StatusCodes.Good,
-                        outputArguments: outputs.map((output) => new Variant(output))
-                    });
-                })
-                .catch(() => {
-                    callback(null, {
-                        statusCode: StatusCodes.BadInternalError
-                    });
-                });
-        });
-
-        this.registerNodeEntry("method", path, parentPath, "componentOf", methodConfig, methodNode, namespace);
-    }
-
-    addAlarmPlaceholder(parentPath, alarmConfig) {
-        const path = this.buildPath(parentPath, alarmConfig.name);
-        this.node.debug("Alarm definition received but not implemented yet: " + path + " (" + alarmConfig.type + ")");
-    }
-
-    registerNodeEntry(kind, path, parentPath, relationship, config, node, namespace) {
-        this.nodeEntries.set(path, {
-            kind,
-            path,
-            parentPath,
-            relationship,
-            config,
-            signature: this.buildSignature(kind, config, parentPath, relationship),
-            node,
-            namespace
-        });
-    }
-
-    buildPath(parentPath, name) {
-        return parentPath ? parentPath + "." + name : name;
-    }
-
-    buildObjectTypePath(name) {
-        return "__objectTypes." + name;
-    }
-
-    buildCollectionPath(parentPath, collectionName, name) {
-
-        // return parentPath ? parentPath + "." + collectionName + "." + name : collectionName + "." + name;
-        //change nodeId path
-        return parentPath ? parentPath + "." + name : name + "." + name;
-
-    }
-
-    isObjectTypePath(path) {
-        return String(path || "").indexOf("__objectTypes.") === 0;
-    }
-
-    buildStableNodeId(path, namespace) {
-        return "ns=" + namespace.index + ";s=" + sanitizeNodeIdPath(path);
-    }
-
-    resolveNodeId(config, path, namespace) {
-        const customNodeId = config && typeof config.nodeId === "string" ? config.nodeId.trim() : "";
-        return customNodeId || this.buildStableNodeId(path, namespace);
-    }
-
-    resolveNamespaceId(config) {
-        const namespaceId = config && config.namespaceId !== undefined ? Number(config.namespaceId) : 2;
-        return Number.isInteger(namespaceId) && namespaceId >= 2 ? namespaceId : 2;
-    }
-
-    getNamespaceForConfig(config) {
-        const namespaceId = this.resolveNamespaceId(config);
-        if (!this.namespaces.has(namespaceId)) {
-            throw new Error("Namespace " + namespaceId + " is not available");
-        }
-
-        return this.namespaces.get(namespaceId);
-    }
-
-    emitTagAccess(operation, details) {
-        this.registry.emitTagAccess({
-            operation,
-            serverId: this.node.id,
-            serverNodeName: this.node.name || "",
-            serverName: this.serverName,
-            timestamp: new Date().toISOString(),
-            path: details.path,
-            nodeID: details.nodeID,
-            browseName: details.browseName,
-            dataType: details.dataType,
-            value: details.value
-        });
-    }
-
-    getVariableRecord(identifierType, identifier) {
-        if (identifierType === "nodeId") {
-            return this.getVariableRecordByNodeId(identifier);
-        }
-
-        return this.getVariableRecordByPath(identifier);
-    }
-
-    getVariableRecordByPath(path) {
-        if (!this.variableStore.has(path)) {
-            throw new Error("Unknown path: " + path);
-        }
-
-        return this.variableStore.get(path);
-    }
-
-    getVariableRecordByNodeId(nodeId) {
-        const key = this.normalizeNodeIdKey(nodeId);
-        if (!this.variableNodeIdStore.has(key)) {
-            throw new Error("Unknown nodeId: " + nodeId);
-        }
-
-        return this.variableNodeIdStore.get(key);
-    }
-
-    normalizeNodeIdKey(nodeId) {
-        return coerceNodeId(nodeId).toString();
-    }
-
-    resolveAlarmVariableRecord(parentPath, parentNode, variableNodeId) {
-        const reference = String(variableNodeId || "").trim();
-        if (!reference) {
-            throw new Error("Alarm variableNodeId is required");
-        }
-
-        if (reference.indexOf(".") === 0) {
-            const relativeReference = this.resolveObjectTypeRelativeReference(parentPath, reference);
-
-            //not work
-            var corrente = parentNode.getComponentByName("corrent")
-
-            return {
-                node: corrente
-            }
-            if (this.variableStore.has(relativeReference)) {
-                return this.variableStore.get(relativeReference);
-            }
-        }
-
-        if (this.variableStore.has(reference)) {
-            return this.variableStore.get(reference);
-        }
-
-        try {
-            return this.getVariableRecordByNodeId(reference);
-        } catch (error) {
-            // ignore and continue with path heuristics
-        }
-
-        const stringNodeIdPath = this.extractStringNodeIdPath(reference);
-        if (stringNodeIdPath) {
-            if (this.variableStore.has(stringNodeIdPath)) {
-                return this.variableStore.get(stringNodeIdPath);
-            }
-
-            const relativeStringNodeIdPath = this.buildPath(parentPath, stringNodeIdPath);
-            if (this.variableStore.has(relativeStringNodeIdPath)) {
-                return this.variableStore.get(relativeStringNodeIdPath);
-            }
-        }
-
-        const relativePath = this.buildPath(parentPath, reference);
-        if (this.variableStore.has(relativePath)) {
-            return this.variableStore.get(relativePath);
-        }
-
-        const suffixMatches = Array.from(this.variableStore.entries())
-            .filter(([path]) => {
-                return path === reference ||
-                    path.indexOf("." + reference) !== -1 ||
-                    (stringNodeIdPath && (path === stringNodeIdPath || path.indexOf("." + stringNodeIdPath) !== -1));
-            });
-
-        if (suffixMatches.length === 1) {
-            return suffixMatches[0][1];
-        }
-
-        throw new Error("Unknown alarm variable reference: " + reference);
-    }
-
-    extractStringNodeIdPath(reference) {
-        const match = /^ns=\d+;s=(.+)$/.exec(String(reference || "").trim());
-        return match ? match[1] : "";
-    }
-
-    resolveObjectTypeRelativeReference(rootInstancePath, reference) {
-        const tokens = String(reference || "")
-            .trim()
-            .replace(/^\.+/, "")
-            .split(".")
-            .filter((token) => token !== "")
-            .map((token) => this.normalizeCollectionToken(token));
-
-        if (!tokens.length) {
-            return rootInstancePath;
-        }
-
-        return rootInstancePath + "." + tokens.join(".");
-    }
-
-    normalizeCollectionToken(token) {
-        const normalized = String(token || "").trim().toLowerCase();
-        const aliases = {
-            variaveis: "variables",
-            variables: "variables",
-            objetos: "objects",
-            objects: "objects",
-            pastas: "folders",
-            folders: "folders",
-            metodos: "methods",
-            methods: "methods",
-            alarmes: "alarms",
-            alarms: "alarms",
-            objecttypes: "objectsTypes",
-            objectstypes: "objectsTypes",
-            tiposobjetos: "objectsTypes"
-        };
-
-        return aliases[normalized] || token;
-    }
-
-    coerceValue(value, type, expectArray) {
-        if (expectArray) {
-            const items = this.extractArrayItems(value);
-            if (!items) {
-                throw new Error("Expected array value for type " + type);
-            }
-
-            return items.map((item) => this.coerceScalarValue(item, type));
-        }
-
-        if (typeof value === "string") {
-            const trimmed = value.trim();
-            if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-                try {
-                    const parsed = JSON.parse(trimmed);
-                    if (Array.isArray(parsed)) {
-                        throw new Error("Expected scalar value for type " + type + " but received array");
-                    }
-                } catch (error) {
-                    if (error.message.indexOf("Expected scalar value") === 0) {
-                        throw error;
-                    }
-
-                    throw new Error("Invalid array value for type " + type + ": " + error.message);
-                }
-            }
-        }
-
-        if (this.extractArrayItems(value)) {
-            throw new Error("Expected scalar value for type " + type + " but received array");
-        }
-
-        return this.coerceScalarValue(value, type);
-    }
-
-    coerceScalarValue(value, type) {
-
-        if (type === "Int16") {
-            const parsed = Number(value);
-            if (!Number.isFinite(parsed)) {
-                return 0;
-            }
-            return Math.trunc(parsed);
-        }
-
-
-        if (type === "Int32") {
-            const parsed = Number(value);
-            if (!Number.isFinite(parsed)) {
-                return 0;
-            }
-            return Math.trunc(parsed);
-        }
-
-        if (type === "Float") {
-            const parsed = Number(value);
-            if (!Number.isFinite(parsed)) {
-                return 0;
-            }
-            return parsed;
-        }
-
-        if (type === "Boolean") {
-            if (typeof value === "string") {
-                const normalized = value.trim().toLowerCase();
-                if (normalized === "false" || normalized === "0" || normalized === "") {
-                    return false;
-                }
-                if (normalized === "true" || normalized === "1") {
-                    return true;
-                }
-            }
-
-            return Boolean(value);
-        }
-
-        return value === undefined || value === null ? "" : String(value);
-    }
-
-    isArrayValue(value) {
-        return this.extractArrayItems(value) !== null;
-    }
-
-    extractArrayItems(value) {
-        if (Array.isArray(value)) {
-            return value;
-        }
-
-        if (typeof value === "string") {
-            const trimmed = value.trim();
-            if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-                const parsed = JSON.parse(trimmed);
-                return Array.isArray(parsed) ? parsed : null;
-            }
-            return null;
-        }
-
-        if (ArrayBuffer.isView(value)) {
-            return Array.from(value);
-        }
-
-        return null;
-    }
-}
-
-function collapsePaths(paths) {
-    return Array.from(new Set(paths))
-        .sort(comparePathDepthAsc)
-        .filter((path, index, ordered) => {
-            for (let current = 0; current < index; current += 1) {
-                if (isSamePathOrDescendant(path, ordered[current])) {
-                    return false;
-                }
-            }
-            return true;
-        });
-}
-
-function isSamePathOrDescendant(path, rootPath) {
-    return path === rootPath || path.indexOf(rootPath + ".") === 0;
-}
-
-function comparePathDepthAsc(left, right) {
-    return pathDepth(left) - pathDepth(right);
-}
-
-function comparePathDepthDesc(left, right) {
-    return pathDepth(right) - pathDepth(left);
-}
-
-function pathDepth(path) {
-    return String(path || "").split(".").length;
-}
-
-function compareEntryCreationOrder(left, right) {
-    const depthDelta = pathDepth(left.path) - pathDepth(right.path);
-    if (depthDelta !== 0) {
-        return depthDelta;
-    }
-
-    return kindRank(left.kind) - kindRank(right.kind);
-}
-
-function kindRank(kind) {
-    if (kind === "objectTypeDefinition") {
-        return -1;
-    }
-    if (kind === "folder") {
-        return 0;
-    }
-    if (kind === "object") {
-        return 1;
-    }
-    if (kind === "objectTypeInstance") {
-        return 1;
-    }
-    if (kind === "variable") {
-        return 2;
-    }
-    if (kind === "method") {
-        return 3;
-    }
-    if (kind === "alarm") {
-        return 4;
-    }
-    return 10;
-}
-
-module.exports = {
-    OpcUaAddressSpaceBuilder
-};