node-opcua-address-space 2.169.0 → 2.172.0

package/src/_instantiate_helpers.ts

@@ -4,33 +4,30 @@
 // tslint:disable:max-classes-per-file
 // tslint:disable:no-console
 import chalk from "chalk";
-
 import {
-    UAMethod,
-    UAObject,
-    UAObjectType,
-    UAVariable,
-    UAVariableType,
+    CloneHelper,
     reconstructFunctionalGroupType,
     reconstructNonHierarchicalReferences,
-    CloneHelper
+    type UAMethod,
+    type UAObject,
+    type UAObjectType,
+    type UAVariable,
+    type UAVariableType
 } from "node-opcua-address-space-base";
-
-import { checkDebugFlag, make_debugLog, make_warningLog, make_errorLog } from "node-opcua-debug";
-import { sameNodeId } from "node-opcua-nodeid";
-
-import { makeOptionalsMap, OptionalMap } from "../source/helpers/make_optionals_map";
-
-import { _clone_hierarchical_references } from "./base_node_private";
+import { BrowseDirection } from "node-opcua-data-model";
+import { checkDebugFlag, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import { makeOptionalsMap, type OptionalMap } from "../source/helpers/make_optionals_map";
 import { MandatoryChildOrRequestedOptionalFilter } from "./_mandatory_child_or_requested_optional_filter";
+import { _clone_hierarchical_references } from "./base_node_private";
 
-const debugLog = make_debugLog(__filename);
-const doDebug = checkDebugFlag(__filename);
-const warningLog = make_warningLog(__filename);
-const errorLog = make_errorLog(__filename);
+// const debugLog = make_debugLog("INSTANTIATE");
+// const doDebug = checkDebugFlag("INSTANTIATE");
+const warningLog = make_warningLog("INSTANTIATE");
+const errorLog = make_errorLog("INSTANTIATE");
 
 // eslint-disable-next-line prefer-const
-let doTrace = checkDebugFlag("INSTANTIATE");
+const doTrace = checkDebugFlag("INSTANTIATE");
 const traceLog = errorLog;
 
 // install properties and components on a instantiated Object
@@ -58,7 +55,7 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
         warningLog("optionalsMap        =", Object.keys(optionalsMap).join(" "));
 
         const c = typeDefinitionNode.findReferencesEx("Aggregates");
-        warningLog("typeDefinition aggregates      =", c.map((x) => x.node!.browseName.toString()).join(" "));
+        warningLog("typeDefinition aggregates      =", c.map((x) => x.node?.browseName.toString()).join(" "));
     }
     optionalsMap = optionalsMap || {};
 
@@ -71,7 +68,7 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
     doTrace &&
         traceLog(
             chalk.cyan(extraInfo.pad(), "cloning relevant member of typeDefinition class"),
-            typeDefinitionNode.browseName.toString()+ "\n optionals" + (JSON.stringify(optionalsMap))
+            `${typeDefinitionNode.browseName.toString()}\n optionals${JSON.stringify(optionalsMap)}`
         );
 
     _clone_hierarchical_references(typeDefinitionNode, instance, copyAlsoModellingRules, filter, extraInfo, browseNameMap);
@@ -79,7 +76,7 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
     // now apply recursion on baseTypeDefinition  to get properties and components from base class
 
     const baseTypeDefinitionNodeId = typeDefinitionNode.subtypeOf;
-    const baseTypeDefinition = typeDefinitionNode.subtypeOfObj!;
+    const baseTypeDefinition = typeDefinitionNode.subtypeOfObj;
 
     doTrace &&
         traceLog(
@@ -87,7 +84,7 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
                 extraInfo.pad(),
                 "now apply recursion on baseTypeDefinition  to get properties and components from base class"
             ),
-            baseTypeDefinition.browseName.toString()
+            baseTypeDefinition ? baseTypeDefinition.browseName.toString() : "undefined"
         );
 
     // c8 ignore next
@@ -111,10 +108,14 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
 export function initialize_properties_and_components<
     B extends UAObject | UAVariable | UAMethod,
     T extends UAVariableType | UAObjectType
->(instance: B, topMostType: T, nodeType: T,
+>(
+    instance: B,
+    topMostType: T,
+    nodeType: T,
     copyAlsoModellingRules: boolean,
     copyAlsoAllOptionals: boolean,
-    optionals?: string[]): void {
+    optionals?: string[]
+): void {
     const extraInfo = new CloneHelper();
 
     extraInfo.pushContext({
@@ -141,7 +142,59 @@ export function initialize_properties_and_components<
         browseNameMap
     );
 
+    // instantiate optionals from interfaces
+    instantiate_interface_children<B>(
+        nodeType,
+        extraInfo,
+        instance,
+        copyAlsoModellingRules,
+        copyAlsoAllOptionals,
+        optionalsMap,
+        browseNameMap
+    );
+
     reconstructFunctionalGroupType(extraInfo);
 
     reconstructNonHierarchicalReferences(extraInfo);
 }
+
+function instantiate_interface_children<B extends UAObject | UAVariable | UAMethod>(
+    nodeType: UAObjectType | UAVariableType,
+    extraInfo: CloneHelper,
+    instance: B,
+    copyAlsoModellingRules: boolean,
+    copyAlsoAllOptionals: boolean,
+    optionalsMap: OptionalMap,
+    browseNameMap: Set<string>
+) {
+    const interfaces = nodeType.findReferencesEx(resolveNodeId("HasInterface"), BrowseDirection.Forward);
+    if (interfaces.length === 0) {
+        return;
+    }
+    for (const reference of interfaces) {
+        const interfaceType = (reference.node as UAObjectType) || nodeType.addressSpace.findObjectType(reference.nodeId);
+        if (!interfaceType) {
+            warningLog(" cannot find node ", reference.nodeId.toString());
+            continue;
+        }
+        const topMostTypeBaseInterface = nodeType.addressSpace.findObjectType("BaseInterfaceType");
+        if (!topMostTypeBaseInterface) {
+            throw new Error("cannot find BaseInterfaceType");
+        }
+        doTrace &&
+            traceLog(
+                chalk.cyan(extraInfo.pad(), "instantiating optionals from interface"),
+                `${interfaceType.browseName.toString()}`
+            );
+        _initialize_properties_and_components(
+            instance,
+            topMostTypeBaseInterface,
+            interfaceType,
+            copyAlsoModellingRules,
+            copyAlsoAllOptionals,
+            optionalsMap,
+            extraInfo,
+            browseNameMap
+        );
+    }
+}

package/src/_mandatory_child_or_requested_optional_filter.ts

@@ -1,12 +1,18 @@
+import {
+    type BaseNode,
+    type CloneFilter,
+    fullPath2,
+    type UAMethod,
+    type UAObject,
+    type UAReference,
+    type UAVariable
+} from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { BaseNode, UAMethod, UAObject, UAReference, UAVariable, CloneFilter, fullPath2 } from "node-opcua-address-space-base";
-import { checkDebugFlag, make_debugLog, make_warningLog, make_errorLog } from "node-opcua-debug";
 import { BrowseDirection } from "node-opcua-data-model";
-
-import { _clone_hierarchical_references } from "./base_node_private";
+import { checkDebugFlag, make_errorLog, make_warningLog } from "node-opcua-debug";
 
 // const debugLog = make_debugLog(__filename);
-const doDebug = checkDebugFlag(__filename);
+const _doDebug = checkDebugFlag(__filename);
 const warningLog = make_warningLog(__filename);
 const errorLog = make_errorLog(__filename);
 const doTrace = checkDebugFlag("INSTANTIATE");
@@ -14,17 +20,18 @@ const traceLog = errorLog;
 
 export type OptionalMap = Record<string, string | Record<string, any>>;
 export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
-    private readonly instance: BaseNode;
     private readonly optionalsMap: OptionalMap;
     private readonly references: UAReference[];
     private readonly copyAlsoAllOptionals: boolean = false;
 
+    private readonly _instance: BaseNode;
+
     constructor(instance: BaseNode, copyAlsoAllOptionals: boolean, optionalsMap: OptionalMap) {
         this.copyAlsoAllOptionals = copyAlsoAllOptionals;
         // should we clone the node to be a component or propertyOf of a instance
         assert(null !== instance);
         this.optionalsMap = optionalsMap;
-        this.instance = instance;
+        this._instance = instance;
         this.references = instance.findReferencesEx("Aggregates", BrowseDirection.Forward);
     }
 
@@ -32,13 +39,13 @@ export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
         const addressSpace = node.addressSpace;
 
         const alreadyIn = this.references.filter((r: UAReference) => {
-            const n = addressSpace.findNode(r.nodeId)!;
+            const n = addressSpace.findNode(r.nodeId);
             // c8 ignore next
             if (!n) {
                 warningLog(" cannot find node ", r.nodeId.toString());
                 return false;
             }
-            return n.browseName!.name!.toString() === node.browseName!.name!.toString();
+            return n.browseName?.name?.toString() === node.browseName?.name?.toString();
         });
 
         if (alreadyIn.length > 0) {
@@ -54,13 +61,7 @@ export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
             case null:
             case undefined:
                 // c8 ignore next
-                doTrace &&
-                    traceLog(
-                        "node ",
-                        fullPath2(node),
-                        " has no modellingRule ",
-                        node ? fullPath2(node) : ""
-                    );
+                doTrace && traceLog("node ", fullPath2(node), " has no modellingRule ", node ? fullPath2(node) : "");
                 /**
                  * in some badly generated NodeSet2.xml file, the modellingRule is not specified
                  *
@@ -76,7 +77,7 @@ export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
                 return true; // keep;
             case "Optional":
                 // only if in requested optionals
-                return this.copyAlsoAllOptionals || (node.browseName!.name! in this.optionalsMap);
+                return this.copyAlsoAllOptionals || (node.browseName?.name || "") in this.optionalsMap;
             case "OptionalPlaceholder":
                 return false; // ignored
             default:
@@ -85,12 +86,12 @@ export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
     }
 
     public filterFor(childInstance: UAVariable | UAObject | UAMethod): CloneFilter {
-        const browseName: string = childInstance.browseName.name!;
+        const browseName: string = childInstance.browseName.name || "";
 
         let map: OptionalMap = Object.create(null);
 
         if (browseName in this.optionalsMap) {
-            map = this.optionalsMap[browseName] as any;
+            map = this.optionalsMap[browseName] as OptionalMap;
         }
         // c8 ignore next
         doTrace && traceLog("filterFor ", browseName, map);

package/src/address_space.ts

@@ -51,24 +51,17 @@ import type {
     ModelChangeStructureDataType,
     RelativePathElement
 } from "node-opcua-types";
-import {
-    BrowsePath,
-    BrowsePathResult,
-} from "node-opcua-types";
+import { BrowsePath, BrowsePathResult } from "node-opcua-types";
 import { isNullOrUndefined, lowerFirstLetter } from "node-opcua-utils";
 import { DataType, Variant, VariantArrayType, type VariantOptions, type VariantT } from "node-opcua-variant";
 import { adjustBrowseDirection } from "../source/helpers/adjust_browse_direction";
-import type {
-    ExtensionObjectConstructorFuncWithSchema
-} from "../source/interfaces/extension_object_constructor";
+import type { ExtensionObjectConstructorFuncWithSchema } from "../source/interfaces/extension_object_constructor";
 import type { UARootFolder } from "../source/ua_root_folder";
 import type { AddressSpacePrivate } from "./address_space_private";
-import { UAAcknowledgeableConditionImpl, UAConditionImpl } from "./alarms_and_conditions";
+import { UAAcknowledgeableConditionImplBase, UAConditionImplBase } from "./alarms_and_conditions";
 import { BaseNodeImpl } from "./base_node_impl";
 import { EventData } from "./event_data";
-import {
-    AddressSpace_installHistoricalDataNode
-} from "./historical_access/address_space_historical_data_node";
+import { AddressSpace_installHistoricalDataNode } from "./historical_access/address_space_historical_data_node";
 import { isNonEmptyQualifiedName, NamespaceImpl } from "./namespace_impl";
 import type { NamespacePrivate } from "./namespace_private";
 import { ReferenceImpl } from "./reference_impl";
@@ -139,7 +132,7 @@ function _extract_namespace_and_browse_name_as_string(
     }
 
     /* c8 ignore next */
-    if (!result || !result[0]) {
+    if (!result?.[0]) {
         throw new Error(` Cannot find namespace associated with ${browseNameOrNodeId} ${namespaceIndex}`);
     }
     return result as [NamespacePrivate, string];
@@ -510,9 +503,9 @@ export class AddressSpace implements AddressSpacePrivate {
         if (!(dataTypeNode instanceof UADataTypeImpl)) {
             throw new Error(
                 "we are expecting an UADataType here :  " +
-                _orig_dataTypeNode.toString() +
-                " should not refer to a  " +
-                (dataTypeNode as BaseNode).browseName.name
+                    _orig_dataTypeNode.toString() +
+                    " should not refer to a  " +
+                    (dataTypeNode as BaseNode).browseName.name
             );
         }
 
@@ -693,30 +686,24 @@ export class AddressSpace implements AddressSpacePrivate {
     /*=
      * construct a simple javascript object with all the default properties of the event
      *
-     * @return result.$eventDataSource {BaseNode} the event type node
-     * @return result.eventId {NodeId} the
-     * ...
-     *
      *
      * eventTypeId can be a UAEventType
      *
      * @private
      */
-    public constructEventData(eventTypeId: UAEventType, data: RaiseEventData): IEventData {
-        data = data || {};
+    public constructEventData(eventTypeId: UAEventType, dataInput: Record<string, unknown>): IEventData {
+        const data: RaiseEventData = (dataInput || {}) as RaiseEventData;
 
         // construct the reference dataStructure to store event Data
-        let eventTypeNode = eventTypeId;
+        let eventTypeNode: UAEventType | null = eventTypeId;
 
         // make sure that eventType is really a object that derived from EventType
         if (eventTypeId instanceof UAObjectTypeImpl) {
-            eventTypeNode = this.findEventType(eventTypeId)!;
+            eventTypeNode = this.findEventType(eventTypeId) as UAEventType | null;
         }
-
         /* c8 ignore next */
-        if (!eventTypeNode) {
-            throw new Error(` cannot find EvenType for ${eventTypeId}`);
-        }
+        if (!eventTypeNode) throw new Error(` cannot find EventType for ${eventTypeId}`);
+
         assert(eventTypeNode instanceof UAObjectTypeImpl, "eventTypeId must represent a UAObjectType");
 
         // eventId
@@ -732,11 +719,15 @@ export class AddressSpace implements AddressSpacePrivate {
         assert(data.sourceNode.dataType === DataType.NodeId);
 
         // sourceName
-        const sourceNode = this.findNode(data.sourceNode.value)!;
-
+        const sourceNode = this.findNode(data.sourceNode.value);
+        if (!sourceNode) {
+            warningLog(
+                `constructEventData: cannot find sourceNode ${data.sourceNode.value?.toString()} for event ${eventTypeNode.browseName.toString()}`
+            );
+        }
         data.sourceName = data.sourceName || {
             dataType: DataType.String,
-            value: sourceNode.getDisplayName("en")
+            value: sourceNode?.getDisplayName("en") || ""
         };
 
         const nowUTC = new Date();
@@ -794,18 +785,18 @@ export class AddressSpace implements AddressSpacePrivate {
                         // tslint:disable:no-console
                         errorLog(
                             chalk.red("ERROR : AddressSpace#constructEventData(eventType,options) " + "cannot find property ") +
-                            self.browseName.toString() +
-                            " => " +
-                            chalk.cyan(lowerName)
+                                self.browseName.toString() +
+                                " => " +
+                                chalk.cyan(lowerName)
                         );
                     } else {
                         errorLog(
                             chalk.yellow(
                                 "Warning : AddressSpace#constructEventData(eventType,options)" + " cannot find property "
                             ) +
-                            self.browseName.toString() +
-                            " => " +
-                            chalk.cyan(lowerName)
+                                self.browseName.toString() +
+                                " => " +
+                                chalk.cyan(lowerName)
                         );
                     }
                 }
@@ -822,11 +813,11 @@ export class AddressSpace implements AddressSpacePrivate {
                 if (!alreadyVisited(k)) {
                     warningLog(
                         "constructEventData:  cannot find property '" +
-                        k +
-                        "' in [ " +
-                        Object.keys(visitedProperties).join(", ") +
-                        "] when filling " +
-                        eventTypeNode.browseName.toString()
+                            k +
+                            "' in [ " +
+                            Object.keys(visitedProperties).join(", ") +
+                            "] when filling " +
+                            eventTypeNode?.browseName.toString()
                     );
                 }
             });
@@ -964,7 +955,7 @@ export class AddressSpace implements AddressSpacePrivate {
         // TranslateBrowsePathToNodeIds further restrict RelativePath targetName rules:
         // The last element in the relativePath shall always have a targetName specified.
         const last_el = browsePath.relativePath.elements[elements_length - 1];
-        if (!last_el.targetName || !last_el.targetName.name || last_el.targetName.name.length === 0) {
+        if (!last_el.targetName?.name || last_el.targetName.name.length === 0) {
             return new BrowsePathResult({ statusCode: StatusCodes.BadBrowseNameInvalid });
         }
 
@@ -1360,7 +1351,7 @@ export class AddressSpace implements AddressSpacePrivate {
             params.node = params.nodeId as BaseNode;
             params.nodeId = params.node.nodeId;
         } else {
-            let _nodeId = params.nodeId! as NodeId;
+            let _nodeId = params.nodeId as NodeId;
             assert(!!_nodeId, "missing 'nodeId' in reference");
             if (_nodeId && (_nodeId as any).nodeId) {
                 _nodeId = (_nodeId as any).nodeId as NodeId;
@@ -1393,8 +1384,8 @@ export class AddressSpace implements AddressSpacePrivate {
      *
      */
     public installAlarmsAndConditionsService(): void {
-        UAConditionImpl.install_condition_refresh_handle(this);
-        UAAcknowledgeableConditionImpl.install_method_handle_on_type(this);
+        UAConditionImplBase.install_condition_refresh_handle(this);
+        UAAcknowledgeableConditionImplBase.install_method_handle_on_type(this);
     }
 
     // -- internal stuff -----------------------------------------------------------------------------------------------

package/src/address_space_change_event_tools.ts

@@ -2,16 +2,13 @@
  * @module node-opcua-address-space
  */
 import chalk from "chalk";
-
-import { UAReference, BaseNode, UAObject, UAVariable, UAObjectType, UAVariableType } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
+import type { BaseNode, UAObject, UAReference, UAVariable } from "node-opcua-address-space-base";
 import { BrowseDirection, NodeClass } from "node-opcua-data-model";
-import { Enum, EnumItem } from "node-opcua-enum";
-import { NodeId } from "node-opcua-nodeid";
+import { Enum } from "node-opcua-enum";
+import type { NodeId } from "node-opcua-nodeid";
 import { ModelChangeStructureDataType } from "node-opcua-types";
-
-import { AddressSpacePrivate } from "./address_space_private";
-import { BaseNodeImpl } from "./base_node_impl";
+import type { AddressSpacePrivate } from "./address_space_private";
+import type { BaseNodeImpl } from "./base_node_impl";
 
 const verbFlags = new Enum({
     //                         NodeAdded        0         Indicates the affected Node has been added.
@@ -35,29 +32,27 @@ const verbFlags = new Enum({
     DataTypeChanged: 0x10
 });
 
-function makeVerb(verbs: any): number {
-    const e: EnumItem = verbFlags.get(verbs)!;
-    assert(e !== null);
-    return e.value;
+type VerbFlagNames = "NodeAdded" | "NodeDeleted" | "ReferenceAdded" | "ReferenceDeleted" | "DataTypeChanged";
+
+function makeVerb(verbs: VerbFlagNames): number {
+    const e = verbFlags.get(verbs);
+    return e?.value || 0;
 }
 
 function _getTypeDef(node: BaseNode) {
     if (node.nodeClass === NodeClass.Object || node.nodeClass === NodeClass.Variable) {
-        return (<UAVariable | UAObject>node).typeDefinitionObj.nodeId;
+        return (node as unknown as UAObject | UAVariable).typeDefinitionObj.nodeId;
     }
     return null;
 }
 export function _handle_add_reference_change_event(node1: BaseNode, node2id: NodeId): void {
-    
     const addressSpace = node1.addressSpace as AddressSpacePrivate;
     const node2 = addressSpace.findNode(node2id);
     if (!node2) return;
 
-    if (node1.getNodeVersion() ||node2.getNodeVersion()) {
-
+    if (node1.getNodeVersion() || node2.getNodeVersion()) {
         // a event has to be send
         addressSpace.modelChangeTransaction(() => {
-
             let modelChangeTgt = new ModelChangeStructureDataType({
                 affected: node1.nodeId,
                 affectedType: _getTypeDef(node1),
@@ -78,7 +73,7 @@ export function _handle_add_reference_change_event(node1: BaseNode, node2id: Nod
 }
 
 try {
-    (ModelChangeStructureDataType as any).prototype.toString = function (options: any): string {
+    ModelChangeStructureDataType.prototype.toString = function (options?: { addressSpace: AddressSpacePrivate }): string {
         if (!options) {
             return "";
         }
@@ -88,16 +83,16 @@ try {
             if (!nodeId || nodeId.isEmpty()) {
                 return "";
             }
-            const node = addressSpace.findNode(nodeId)!;
-            return '"' + nodeId.toString() + '"' + chalk.yellow(" /* " + (node ? node.browseName.toString() : "???") + " */");
+            const node = addressSpace.findNode(nodeId);
+            return `"${nodeId.toString()}"${chalk.yellow(` /* ${node ? node.browseName.toString() : "???"} */`)}`;
         }
 
-        let str = "{ verb:" + verbFlags.get(this.verb)!.key + ",";
-        str += " affected: " + n(this.affected) + ",";
-        str += " type: " + n(this.affectedType) + " }";
+        let str = `{ verb:${verbFlags.get(this.verb)?.key},`;
+        str += ` affected: ${n(this.affected)},`;
+        str += ` type: ${n(this.affectedType)} }`;
         return str;
     };
-} catch (err) {
+} catch (_err) {
     //
 }
 
@@ -113,7 +108,7 @@ export function _handle_model_change_event(node: BaseNodeImpl): void {
         typeDefinitionNodeId = node.typeDefinitionObj.nodeId;
     }
     for (const parent of [...parents, ...containingFolders]) {
-        if (parent && parent.getNodeVersion()) {
+        if (parent?.getNodeVersion()) {
             addressSpace.modelChangeTransaction(() => {
                 const modelChange1 = new ModelChangeStructureDataType({
                     affected: node.nodeId,
@@ -147,22 +142,22 @@ export function _handle_delete_node_model_change_event(node: BaseNode): void {
     const addressSpace = node.addressSpace as AddressSpacePrivate;
 
     // get backward references
-    const references = node.findReferencesEx("HierarchicalReferences", BrowseDirection.Inverse)!;
+    const references = node.findReferencesEx("HierarchicalReferences", BrowseDirection.Inverse);
 
     const parentNodes = references.map((r: UAReference) => {
-        return addressSpace.findNode(r.nodeId)! as BaseNode;
+        return addressSpace.findNode(r.nodeId) as BaseNode;
     });
 
-    const versionableNodes = parentNodes.filter((n) => null!=n.getNodeVersion());
+    const versionableNodes = parentNodes.filter((n) => null != n.getNodeVersion());
 
     if (versionableNodes.length >= 1 || node.getNodeVersion()) {
         addressSpace.modelChangeTransaction(() => {
             // ...
             for (const r of references) {
-                const target = addressSpace.findNode(r.nodeId)!;
+                const target = addressSpace.findNode(r.nodeId);
 
                 const modelChangeSrc_l = new ModelChangeStructureDataType({
-                    affected: target.nodeId,
+                    affected: target?.nodeId,
                     affectedType: null,
                     verb: makeVerb("ReferenceDeleted")
                 });

package/src/address_space_private.ts

@@ -1,33 +1,32 @@
 /**
  * @module node-opcua-address-space.Private
  */
-import { ExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
-import { NodeClass, QualifiedNameLike } from "node-opcua-data-model";
-import { ExtensionObject } from "node-opcua-extension-object";
-import { NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { ModelChangeStructureDataType, ReadProcessedDetails, HistoryReadResult } from "node-opcua-types";
-import { NumericRange } from "node-opcua-numeric-range";
-import { CallbackT } from "node-opcua-status-code";
-
-import {
-    IAddressSpace,
+
+import type {
+    AddReferenceOpts,
     BaseNode,
-    UADataType,
-    UAView,
+    ContinuationData,
+    IAddressSpace,
     ISessionContext,
-    AddReferenceOpts,
-    UAVariableType,
+    MethodCallInterceptor,
+    UADataType,
     UAObjectType,
     UAReference,
     UAVariable,
-    ContinuationData,
-    MethodCallInterceptor
+    UAVariableType,
+    UAView
 } from "node-opcua-address-space-base";
-import { UARootFolder } from "../source/ua_root_folder";
-import { ExtensionObjectConstructorFuncWithSchema } from "../source/interfaces/extension_object_constructor";
-
-import { NamespacePrivate } from "./namespace_private";
-
+import type { ExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
+import type { NodeClass, QualifiedNameLike } from "node-opcua-data-model";
+import type { ExtensionObject } from "node-opcua-extension-object";
+import type { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import type { NumericRange } from "node-opcua-numeric-range";
+import type { CallbackT } from "node-opcua-status-code";
+import type { HistoryReadResult, ModelChangeStructureDataType, ReadProcessedDetails } from "node-opcua-types";
+import type { ExtensionObjectConstructorFuncWithSchema } from "../source/interfaces/extension_object_constructor";
+import type { UARootFolder } from "../source/ua_root_folder";
+
+import type { NamespacePrivate } from "./namespace_private";
 
 export interface AddressSpacePrivate extends IAddressSpace {
     rootFolder: UARootFolder;

package/src/alarms_and_conditions/condition.ts

@@ -2,8 +2,6 @@
  * @module node-opcua-address-space.AlarmsAndConditions
  */
 
-
-
 /*
  As per spec OPCUA 1.03 part 9: