node-opcua-address-space 2.90.0 → 2.91.0

package/src/extension_object_array_node.ts

@@ -105,7 +105,7 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
         throw new Error("cannot find Data Type");
     }
 
-    assert(dataType.isSupertypeOf(structure as any), "expecting a structure (= ExtensionObject) here ");
+    assert(dataType.isSubtypeOf(structure as any), "expecting a structure (= ExtensionObject) here ");
 
     const inner_options = {
         componentOf: parentFolder,
@@ -165,7 +165,7 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
         throw new Error("Cannot find DataType " + variableType.dataType.toString());
     }
 
-    assert(dataType.isSupertypeOf(structure), "expecting a structure (= ExtensionObject) here ");
+    assert(dataType.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
 
     assert(!uaArrayVariableNode.$$variableType, "uaArrayVariableNode has already been bound !");
 
@@ -173,7 +173,7 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
 
     // verify that an object with same doesn't already exist
     dataType = addressSpace.findDataType(variableType.dataType)! as UADataType;
-    assert(dataType!.isSupertypeOf(structure), "expecting a structure (= ExtensionObject) here ");
+    assert(dataType!.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
     assert(!uaArrayVariableNode.$$extensionObjectArray, "UAVariable ExtensionObject array already bounded");
     uaArrayVariableNode.$$dataType = dataType;
     uaArrayVariableNode.$$extensionObjectArray = [];

package/src/index_current.ts

@@ -29,7 +29,7 @@ export * from "../source/loader/register_node_promoter";
 
 export { ContinuationPointManager } from "../source/continuation_points/continuation_point_manager";
 
-export { promoteToStateMachine } from "./state_machine/finite_state_machine";
+export { promoteToStateMachine, promoteToStateMachineType } from "./state_machine/finite_state_machine";
 export * from "../source/interfaces/state_machine/ua_transition_ex";
 
 export * from "./namespace_impl";

package/src/namespace_impl.ts

@@ -512,8 +512,6 @@ export class NamespaceImpl implements NamespacePrivate {
             referenceType: "HasTypeDefinition"
         });
 
-        // xx assert(this.FolderTypeId && this.BaseObjectTypeId); // is default address space generated.?
-
         const createOptions = options as CreateNodeOptions;
         assert(!createOptions.nodeClass);
         createOptions.nodeClass = NodeClass.View;
@@ -1967,8 +1965,6 @@ export class NamespaceImpl implements NamespacePrivate {
 
         options.historizing = !!options.historizing;
 
-        // xx assert(this.FolderTypeId && this.BaseObjectTypeId); // is default address space generated.?
-
         // istanbul ignore next
         if (Object.prototype.hasOwnProperty.call(options, "hasTypeDefinition")) {
             throw new Error("hasTypeDefinition option is invalid. Do you mean typeDefinition instead ?");

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -134,7 +134,7 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
         }
 
         // get the direct backward reference to a external namespace
-        if (referenceType.isSupertypeOf(aggregateReferenceType) && !reference.isForward) {
+        if (referenceType.isSubtypeOf(aggregateReferenceType) && !reference.isForward) {
             if (reference.nodeId.namespace !== node.nodeId.namespace) {
                 // todo: may be check that reference.nodeId.namespace is one of the namespace
                 // on which our namespace is build and not a derived one !
@@ -142,23 +142,23 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
                 return true;
             }
         }
-        if (referenceType.isSupertypeOf(hasSubtypeReferenceType) && reference.isForward) {
+        if (referenceType.isSubtypeOf(hasSubtypeReferenceType) && reference.isForward) {
             // return false;
         }
         // only keep
-        if (referenceType.isSupertypeOf(aggregateReferenceType) && reference.isForward) {
+        if (referenceType.isSubtypeOf(aggregateReferenceType) && reference.isForward) {
             return true;
-        } else if (referenceType.isSupertypeOf(hasSubtypeReferenceType) && !reference.isForward) {
+        } else if (referenceType.isSubtypeOf(hasSubtypeReferenceType) && !reference.isForward) {
             return true;
-        } else if (referenceType.isSupertypeOf(hasTypeDefinitionReferenceType) && reference.isForward) {
+        } else if (referenceType.isSubtypeOf(hasTypeDefinitionReferenceType) && reference.isForward) {
             return true;
-        } else if (referenceType.isSupertypeOf(nonHierarchicalReferencesType) && reference.isForward) {
+        } else if (referenceType.isSubtypeOf(nonHierarchicalReferencesType) && reference.isForward) {
             return true;
-        } else if (referenceType.isSupertypeOf(organizesReferencesType) && !reference.isForward) {
+        } else if (referenceType.isSubtypeOf(organizesReferencesType) && !reference.isForward) {
             return true;
-        } else if (connectsToReferenceType && referenceType.isSupertypeOf(connectsToReferenceType) && reference.isForward) {
+        } else if (connectsToReferenceType && referenceType.isSubtypeOf(connectsToReferenceType) && reference.isForward) {
             return true;
-        } else if (referenceType.isSupertypeOf(hasEventSourceReferenceType) && reference.isForward) {
+        } else if (referenceType.isSubtypeOf(hasEventSourceReferenceType) && reference.isForward) {
             return true;
         }
         return false;

package/src/state_machine/finite_state_machine.ts

@@ -10,18 +10,20 @@ import { AttributeIds } from "node-opcua-data-model";
 import { NodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType } from "node-opcua-variant";
-import { BaseNode, UAMethod, UAObject, UAObjectType, UAVariable } from "node-opcua-address-space-base";
+import { UAString } from "node-opcua-basic-types";
+import { BaseNode, UAMethod, UAObject, UAObjectType, UAVariable, UAVariableT } from "node-opcua-address-space-base";
 import { registerNodePromoter } from "../../source/loader/register_node_promoter";
 
-import { UAStateMachineEx, TransitionSelector } from "../../source/interfaces/state_machine/ua_state_machine_type";
+import { UAStateMachineEx, TransitionSelector, UAStateMachineTypeHelper } from "../../source/interfaces/state_machine/ua_state_machine_type";
 import { UAObjectImpl } from "../ua_object_impl";
 import { UATransitionEx } from "../../source/interfaces/state_machine/ua_transition_ex";
 import { BaseNodeImpl } from "../base_node_impl";
+import { UAObjectTypeImpl } from "../ua_object_type_impl";
 
 const doDebug = false;
 
-export declare interface UATransitionImpl extends UATransition, UATransitionEx {}
-export class UATransitionImpl implements UATransition, UATransitionEx {}
+export declare interface UATransitionImpl extends UATransition, UATransitionEx { }
+export class UATransitionImpl implements UATransition, UATransitionEx { }
 
 function getComponentFromTypeAndSubtype(typeDef: UAObjectType): UAObject[] {
     const components_parts: BaseNode[][] = [];
@@ -65,6 +67,68 @@ const defaultPredicate = (transitions: UATransition[], fromState: UAState, toSta
     return transitions[0];
 };
 
+
+
+export function getFiniteStateMachineTypeStates(uaFiniteStateMachineType: UAObjectType): UAState[] {
+    const addressSpace = uaFiniteStateMachineType.addressSpace;
+
+    const initialStateType = addressSpace.findObjectType("InitialStateType");
+    // istanbul ignore next
+    if (!initialStateType) {
+        throw new Error("cannot find InitialStateType");
+    }
+
+    const stateType = addressSpace.findObjectType("StateType");
+    // istanbul ignore next
+    if (!stateType) {
+        throw new Error("cannot find StateType");
+    }
+
+    assert(initialStateType.isSubtypeOf(stateType));
+
+
+    let comp = getComponentFromTypeAndSubtype(uaFiniteStateMachineType);
+
+    comp = comp.filter((c) => {
+        if (!c.typeDefinitionObj || c.typeDefinitionObj.nodeClass !== NodeClass.ObjectType) {
+            return false;
+        }
+        return c.typeDefinitionObj.isSubtypeOf(stateType);
+    });
+
+    return comp as UAState[];
+}
+export function getFiniteStateMachineTypeTransitions(uaFiniteStateMachineType: UAObjectType): UATransitionEx[] {
+    const addressSpace = uaFiniteStateMachineType.addressSpace;
+
+    const transitionType = addressSpace.findObjectType("TransitionType");
+    // istanbul ignore next
+    if (!transitionType) {
+        throw new Error("cannot find TransitionType");
+    }
+
+    let comp = getComponentFromTypeAndSubtype(uaFiniteStateMachineType);
+
+    comp = comp.filter((c) => {
+        if (!c.typeDefinitionObj || c.typeDefinitionObj.nodeClass !== NodeClass.ObjectType) {
+            return false;
+        }
+        return c.typeDefinitionObj.isSubtypeOf(transitionType);
+    });
+
+    return comp as UATransitionEx[];
+
+}
+
+export function getFiniteStateMachineTypeStateByName(uaFiniteStateMachineType: UAObjectType, stateName: string): UAState | null {
+    let states = getFiniteStateMachineTypeStates(uaFiniteStateMachineType);
+    states = states.filter((s: any) => {
+        return s.browseName.name === stateName;
+    });
+    assert(states.length <= 1);
+    return states.length === 1 ? (states[0] as any as UAState) : null;
+}
+
 /*
  *
  * @class StateMachine
@@ -75,34 +139,8 @@ const defaultPredicate = (transitions: UATransition[], fromState: UAState, toSta
  */
 export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx {
     public getStates(): UAState[] {
-        const addressSpace = this.addressSpace;
-
-        const initialStateType = addressSpace.findObjectType("InitialStateType");
-        // istanbul ignore next
-        if (!initialStateType) {
-            throw new Error("cannot find InitialStateType");
-        }
-
-        const stateType = addressSpace.findObjectType("StateType");
-        // istanbul ignore next
-        if (!stateType) {
-            throw new Error("cannot find StateType");
-        }
-
-        assert(initialStateType.isSupertypeOf(stateType));
-
         const typeDef = this.typeDefinitionObj;
-
-        let comp = getComponentFromTypeAndSubtype(typeDef);
-
-        comp = comp.filter((c) => {
-            if (!c.typeDefinitionObj || c.typeDefinitionObj.nodeClass !== NodeClass.ObjectType) {
-                return false;
-            }
-            return c.typeDefinitionObj.isSupertypeOf(stateType);
-        });
-
-        return comp as UAState[];
+        return getFiniteStateMachineTypeStates(typeDef);
     }
 
     public get states(): UAState[] {
@@ -115,34 +153,12 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
      * @return the state with the given name
      */
     public getStateByName(name: string): UAState | null {
-        let states = this.getStates();
-        states = states.filter((s: any) => {
-            return s.browseName.name === name;
-        });
-        assert(states.length <= 1);
-        return states.length === 1 ? (states[0] as any as UAState) : null;
+        return getFiniteStateMachineTypeStateByName(this.typeDefinitionObj, name);
     }
 
     public getTransitions(): UATransitionEx[] {
-        const addressSpace = this.addressSpace;
-
-        const transitionType = addressSpace.findObjectType("TransitionType");
-        // istanbul ignore next
-        if (!transitionType) {
-            throw new Error("cannot find TransitionType");
-        }
         const typeDef = this.typeDefinitionObj;
-
-        let comp = getComponentFromTypeAndSubtype(typeDef);
-
-        comp = comp.filter((c) => {
-            if (!c.typeDefinitionObj || c.typeDefinitionObj.nodeClass !== NodeClass.ObjectType) {
-                return false;
-            }
-            return c.typeDefinitionObj.isSupertypeOf(transitionType);
-        });
-
-        return comp as UATransitionEx[];
+        return getFiniteStateMachineTypeTransitions(typeDef);
     }
 
     public get transitions(): UATransitionEx[] {
@@ -245,8 +261,8 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
         if (!stateType) {
             throw new Error("Cannot find StateType");
         }
-        assert((_fromStateNode.typeDefinitionObj as any).isSupertypeOf(stateType));
-        assert((_toStateNode.typeDefinitionObj as any).isSupertypeOf(stateType));
+        assert((_fromStateNode.typeDefinitionObj as any).isSubtypeOf(stateType));
+        assert((_toStateNode.typeDefinitionObj as any).isSubtypeOf(stateType));
 
         let transitions = _fromStateNode.findReferencesAsObject("FromState", false) as UATransitionImpl[];
 
@@ -358,8 +374,8 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
                 "fromState.id": fromStateNode
                     ? fromStateNode.stateNumber.readValue().value
                     : {
-                          dataType: "Null"
-                      },
+                        dataType: "Null"
+                    },
 
                 toState: {
                     dataType: "LocalizedText",
@@ -398,7 +414,7 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
         }
 
         // xx assert(this.typeDefinitionObj && !this.subtypeOfObj);
-        // xx assert(!this.typeDefinitionObj || this.typeDefinitionObj.isSupertypeOf(finiteStateMachineType));
+        // xx assert(!this.typeDefinitionObj || this.typeDefinitionObj.isSubtypeOf(finiteStateMachineType));
         // get current Status
 
         const d = this.currentState.readValue();
@@ -424,3 +440,32 @@ export function promoteToStateMachine(node: UAObject): UAStateMachineEx {
     return _node;
 }
 registerNodePromoter(ObjectTypeIds.FiniteStateMachineType, promoteToStateMachine);
+
+
+export class UAStateMachineTypeImpl extends UAObjectTypeImpl implements UAStateMachineTypeHelper {
+    getStateByName(name: string): UAState | null {
+        return getFiniteStateMachineTypeStateByName(this,  name);
+    }
+    getStates(): UAState[] {
+        return getFiniteStateMachineTypeStates(this);
+
+    }
+    getTransitions(): UATransitionEx[] {
+        return getFiniteStateMachineTypeTransitions(this);
+    }
+    nodeVersion?: UAVariableT<UAString, DataType.String> | undefined;
+    _post_initialize(): void {
+        /** */
+    }
+
+}
+export function promoteToStateMachineType(node: UAObject): UAStateMachineTypeHelper {
+    if (node instanceof UAStateMachineTypeImpl) {
+        return node; // already promoted
+    }
+    Object.setPrototypeOf(node, UAStateMachineTypeImpl.prototype);
+    assert(node instanceof UAStateMachineTypeImpl, "should now  be a State Machine");
+    const _node = node as unknown as UAStateMachineTypeImpl;
+    _node._post_initialize();
+    return _node;
+}

package/src/{tool_isSupertypeOf.ts → tool_isSubtypeOf.ts}

@@ -5,12 +5,12 @@
 import { assert } from "node-opcua-assert";
 import { NodeId, NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
 import { sameNodeId } from "node-opcua-nodeid";
+import { NodeClass } from "node-opcua-data-model";
 import { BaseNode, UADataType, UAObjectType, UAReference, UAReferenceType, UAVariableType } from "node-opcua-address-space-base";
 
 import { BaseNode_getCache } from "./base_node_private";
 import { ReferenceImpl } from "./reference_impl";
 import { BaseNodeImpl } from "./base_node_impl";
-import { NodeClass } from "node-opcua-data-model";
 
 const HasSubTypeNodeId = resolveNodeId("HasSubtype");
 
@@ -20,13 +20,13 @@ function _filterSubType(reference: UAReference) {
 
 export type BaseNodeConstructor<T extends BaseNode> = new () => T;
 
-function _slow_isSupertypeOf<T extends UAType>(this: T, Class: typeof BaseNodeImpl, baseType: T | NodeIdLike): boolean {
+function _slow_isSubtypeOf<T extends UAType>(this: T, Class: typeof BaseNodeImpl, baseType: T | NodeIdLike): boolean {
     if (!(baseType instanceof Class)) {
         const node = this.addressSpace.findNode(baseType as NodeIdLike);
         if (!node || !(node instanceof Class)) {
             throw new Error("Invalid argument");
         }
-        return _slow_isSupertypeOf.call(this, Class, node as unknown as T);
+        return _slow_isSubtypeOf.call(this, Class, node as unknown as T);
     }
     assert(this instanceof Class);
     assert(baseType instanceof Class, " Object must have same type");
@@ -50,7 +50,7 @@ function _slow_isSupertypeOf<T extends UAType>(this: T, Class: typeof BaseNodeIm
         if (sameNodeId(subTypeNode.nodeId, baseType.nodeId)) {
             return true;
         } else {
-            if (_slow_isSupertypeOf.call(subTypeNode, Class, baseType)) {
+            if (_slow_isSubtypeOf.call(subTypeNode, Class, baseType)) {
                 return true;
             }
         }
@@ -96,11 +96,11 @@ function hashBaseNode(e: BaseNode): string {
     return e.nodeId.value.toString();
 }
 
-export type IsSupertypeOfFunc<T extends UAType> = (this: T, baseType: T) => boolean;
+export type IsSubtypeOfFunc<T extends UAType> = (this: T, baseType: T) => boolean;
 
 export type UAType = UAReferenceType | UADataType | UAObjectType | UAVariableType;
 
-export function construct_isSupertypeOf<T extends UAType>(Class: typeof BaseNodeImpl): IsSupertypeOfFunc<T> {
+export function construct_isSubtypeOf<T extends UAType>(Class: typeof BaseNodeImpl): IsSubtypeOfFunc<T> {
     return wrap_memoize(function (this: T, baseType: T | NodeIdLike): boolean {
         if (!(baseType instanceof Class)) {
             throw new Error(
@@ -115,13 +115,13 @@ export function construct_isSupertypeOf<T extends UAType>(Class: typeof BaseNode
         if (!(this instanceof Class)) {
             throw new Error("expecting this to be " + Class.name + " but got " + baseType.constructor.name);
         }
-        return _slow_isSupertypeOf.call(this, Class, baseType as T);
+        return _slow_isSubtypeOf.call(this, Class, baseType as T);
     }, hashBaseNode);
 }
 
-export function construct_slow_isSupertypeOf<T extends UAType>(Class: typeof BaseNodeImpl) {
+export function construct_slow_isSubtypeOf<T extends UAType>(Class: typeof BaseNodeImpl) {
     return function (this: T, baseType: T | NodeIdLike): boolean {
-        return _slow_isSupertypeOf.call(this, Class, baseType);
+        return _slow_isSubtypeOf.call(this, Class, baseType);
     };
 }
 

package/src/ua_data_type_impl.ts

@@ -26,9 +26,9 @@ import { SessionContext } from "../source/session_context";
 import { ExtensionObjectConstructorFuncWithSchema } from "../source/interfaces/extension_object_constructor";
 import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
 import { BaseNode_References_toString, BaseNode_toString, ToStringBuilder, ToStringOption } from "./base_node_private";
-import * as tools from "./tool_isSupertypeOf";
-import { get_subtypeOf } from "./tool_isSupertypeOf";
-import { get_subtypeOfObj } from "./tool_isSupertypeOf";
+import * as tools from "./tool_isSubtypeOf";
+import { get_subtypeOf } from "./tool_isSubtypeOf";
+import { get_subtypeOfObj } from "./tool_isSubtypeOf";
 import { BaseNode_getCache } from "./base_node_private";
 
 export interface UADataTypeImpl {
@@ -62,8 +62,8 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
      *
      *    var dataTypeDouble = addressSpace.findDataType("Double");
      *    var dataTypeNumber = addressSpace.findDataType("Number");
-     *    assert(dataTypeDouble.isSupertypeOf(dataTypeNumber));
-     *    assert(!dataTypeNumber.isSupertypeOf(dataTypeDouble));
+     *    assert(dataTypeDouble.isSubtypeOf(dataTypeNumber));
+     *    assert(!dataTypeNumber.isSubtypeOf(dataTypeDouble));
      *
      */
     public get subtypeOf(): NodeId | null {
@@ -74,7 +74,9 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
         return get_subtypeOfObj.call(this) as any as UADataType;
     }
 
-    public isSupertypeOf = tools.construct_isSupertypeOf<UADataType>(UADataTypeImpl);
+    /** @deprecated */
+    public isSupertypeOf = tools.construct_isSubtypeOf<UADataType>(UADataTypeImpl);
+    public isSubtypeOf = tools.construct_isSubtypeOf<UADataType>(UADataTypeImpl);
 
     public readonly isAbstract: boolean;
 
@@ -277,9 +279,9 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
 
         // we have a data type from a companion specification
         // let's see if this data type need to be registered
-        const isEnumeration = enumeration && this.isSupertypeOf(enumeration);
-        const isStructure = structure && this.isSupertypeOf(structure);
-        const isUnion = !!(structure && union && this.isSupertypeOf(union));
+        const isEnumeration = enumeration && this.isSubtypeOf(enumeration);
+        const isStructure = structure && this.isSubtypeOf(structure);
+        const isUnion = !!(structure && union && this.isSubtypeOf(union));
 
         const isRootDataType = (n: UADataType) => n.nodeId.namespace === 0 && n.nodeId.value === DataTypeIds.BaseDataType;
         // https://reference.opcfoundation.org/v104/Core/docs/Part3/8.49/#Table34
@@ -367,24 +369,24 @@ export function DataType_toString(this: UADataTypeImpl, options: ToStringOption)
 
     options.add(
         options.padding +
-            chalk.yellow("          binaryEncodingNodeId: ") +
-            (this.binaryEncodingNodeId ? this.binaryEncodingNodeId.toString() : "<none>")
+        chalk.yellow("          binaryEncodingNodeId: ") +
+        (this.binaryEncodingNodeId ? this.binaryEncodingNodeId.toString() : "<none>")
     );
     options.add(
         options.padding +
-            chalk.yellow("          xmlEncodingNodeId   : ") +
-            (this.xmlEncodingNodeId ? this.xmlEncodingNodeId.toString() : "<none>")
+        chalk.yellow("          xmlEncodingNodeId   : ") +
+        (this.xmlEncodingNodeId ? this.xmlEncodingNodeId.toString() : "<none>")
     );
     options.add(
         options.padding +
-            chalk.yellow("          jsonEncodingNodeId  : ") +
-            (this.jsonEncodingNodeId ? this.jsonEncodingNodeId.toString() : "<none>")
+        chalk.yellow("          jsonEncodingNodeId  : ") +
+        (this.jsonEncodingNodeId ? this.jsonEncodingNodeId.toString() : "<none>")
     );
     if (this.subtypeOfObj) {
         options.add(
             options.padding +
-                chalk.yellow("          subtypeOfObj        : ") +
-                (this.subtypeOfObj ? this.subtypeOfObj.browseName.toString() : "")
+            chalk.yellow("          subtypeOfObj        : ") +
+            (this.subtypeOfObj ? this.subtypeOfObj.browseName.toString() : "")
         );
     }
     // references
@@ -418,8 +420,8 @@ function makeStructureDefinition(
     const structureType = isUnion
         ? StructureType.Union
         : hasOptionalFields
-        ? StructureType.StructureWithOptionalFields
-        : StructureType.Structure;
+            ? StructureType.StructureWithOptionalFields
+            : StructureType.Structure;
 
     const sd = new StructureDefinition({
         baseDataType,

package/src/ua_object_type_impl.ts

@@ -21,8 +21,8 @@ import {
 import { SessionContext } from "../source/session_context";
 import { BaseNodeImpl } from "./base_node_impl";
 import { ToStringBuilder, UAObjectType_toString } from "./base_node_private";
-import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSupertypeOf";
-import * as tools from "./tool_isSupertypeOf";
+import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
+import * as tools from "./tool_isSubtypeOf";
 import {
     assertUnusedChildBrowseName,
     initialize_properties_and_components,
@@ -42,10 +42,16 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
     public get subtypeOf(): NodeId | null {
         return get_subtypeOf.call(this);
     }
+
+
     public get subtypeOfObj(): UAObjectType | null {
         return get_subtypeOfObj.call(this) as any as UAObjectType;
     }
-    public isSupertypeOf = tools.construct_isSupertypeOf<UAObjectType>(UAObjectTypeImpl);
+
+
+    public isSubtypeOf = tools.construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
+    /** @deprecated - use  isSubtypeOf instead */
+    public isSupertypeOf = tools.construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
 
     constructor(options: any) {
         super(options);

package/src/ua_reference_type_impl.ts

@@ -14,8 +14,8 @@ import { DataType } from "node-opcua-variant";
 
 import { SessionContext, UAReferenceType as UAReferenceTypePublic } from "../source";
 import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
-import * as tools from "./tool_isSupertypeOf";
-import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSupertypeOf";
+import * as tools from "./tool_isSubtypeOf";
+import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
 import { ReferenceImpl } from "./reference_impl";
 import { BaseNode_getCache } from "./base_node_private";
 
@@ -98,12 +98,15 @@ export class UAReferenceTypeImpl extends BaseNodeImpl implements UAReferenceType
     /**
      * returns true if self is  a super type of baseType
      */
-    public isSupertypeOf = tools.construct_isSupertypeOf<UAReferenceType>(UAReferenceTypeImpl);
+    public isSubtypeOf = tools.construct_isSubtypeOf<UAReferenceType>(UAReferenceTypeImpl);
+  
+    /** @deprecated - use `isSubtypeOf` instead*/
+    public isSupertypeOf = tools.construct_isSubtypeOf<UAReferenceType>(UAReferenceTypeImpl);
 
     /**
      * @private
      */
-    public _slow_isSupertypeOf = tools.construct_slow_isSupertypeOf<UAReferenceType>(UAReferenceTypeImpl);
+    public _slow_isSubtypeOf = tools.construct_slow_isSubtypeOf<UAReferenceType>(UAReferenceTypeImpl);
 
     constructor(options: UAReferenceTypeOptions) {
         super(options);