node-opcua-address-space 2.169.0 → 2.172.0

package/src/tool_isSubtypeOf.ts

@@ -2,15 +2,21 @@
  * @module node-opcua-address-space
  */
 
+import type {
+    BaseNode,
+    BaseNodeEvents,
+    UADataType,
+    UAObjectType,
+    UAReference,
+    UAReferenceType,
+    UAVariableType
+} from "node-opcua-address-space-base";
 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 { type NodeId, type NodeIdLike, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import type { BaseNodeImpl } from "./base_node_impl";
 import { BaseNode_getCache } from "./base_node_private";
 import { ReferenceImpl } from "./reference_impl";
-import { BaseNodeImpl } from "./base_node_impl";
 
 const HasSubTypeNodeId = resolveNodeId("HasSubtype");
 
@@ -20,7 +26,11 @@ function _filterSubType(reference: UAReference) {
 
 export type BaseNodeConstructor<T extends BaseNode> = new () => T;
 
-function _slow_isSubtypeOf<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)) {
@@ -42,10 +52,10 @@ function _slow_isSubtypeOf<T extends UAType>(this: T, Class: typeof BaseNodeImpl
 
     for (const subType1 of subTypes) {
         const subTypeId = subType1.nodeId;
-        const subTypeNode = this.addressSpace.findNode(subTypeId) as any as T;
+        const subTypeNode = this.addressSpace.findNode(subTypeId) as unknown as T;
         // c8 ignore next
         if (!subTypeNode) {
-            throw new Error("Cannot find object with nodeId " + subTypeId.toString());
+            throw new Error(`Cannot find object with nodeId ${subTypeId.toString()}`);
         }
         if (sameNodeId(subTypeNode.nodeId, baseType.nodeId)) {
             return true;
@@ -60,10 +70,9 @@ function _slow_isSubtypeOf<T extends UAType>(this: T, Class: typeof BaseNodeImpl
 
 export type MemberFuncValue<T, P, R> = (this: T, param: P) => R;
 
+const g_WeakMap = new WeakMap<object, Map<string, unknown>>();
 
-const g_WeakMap = new WeakMap<Object, Map<string, unknown>>();
-
-export function wipeMemorizedStuff(node: Object) {
+export function wipeMemorizedStuff(node: object) {
     if (g_WeakMap.has(node)) {
         g_WeakMap.delete(node);
     }
@@ -71,40 +80,46 @@ export function wipeMemorizedStuff(node: Object) {
 
 //  http://jsperf.com/underscore-js-memoize-refactor-test
 //  http://addyosmani.com/blog/faster-javascript-memoization/
-function wrap_memoize<T, P, R>(
+function wrap_memoize<T extends object, P, R>(
     func: MemberFuncValue<T, P, R>,
-    hashFunc?: (this: T, param: any) => string
+    hashFunc?: (this: T, param: P) => string
 ): MemberFuncValue<T, P, R> {
-    if (undefined === hashFunc) {
-        hashFunc = (_p: T) => (_p as any).toString();
-    }
-    return function memoize(this: any, param: any) {
-        const self = this;
-        if (!g_WeakMap.has(self)) {
-            g_WeakMap.set(self,new Map());
+    const effectiveHashFunc: (this: T, param: P) => string =
+        hashFunc ??
+        function (this: T, param: P) {
+            return (param as unknown as object).toString();
+        };
+    return function memoize(this: T, param: P): R {
+        let memoMap = g_WeakMap.get(this) as Map<string, R> | undefined;
+        if (!memoMap) {
+            memoMap = new Map<string, R>();
+            g_WeakMap.set(this, memoMap as Map<string, unknown>);
         }
-        const memoMap = g_WeakMap.get(self)!;
 
-        const hash = hashFunc!.call(this, param);
+        const hash = effectiveHashFunc.call(this, param);
         if (memoMap.has(hash)) {
             return memoMap.get(hash) as R;
         }
         const cache_value = func.call(this, param);
-        memoMap.set(hash,cache_value);
-        return cache_value as R;
+        memoMap.set(hash, cache_value);
+        return cache_value;
     };
 }
 
-function hashBaseNode(e: BaseNode): string {
-    return e.nodeId.toString();
+function hashBaseNode(e: BaseNode | NodeIdLike): string {
+    if (e && typeof e === "object" && "nodeId" in e) {
+        return (e as BaseNode).nodeId.toString();
+    }
+    return resolveNodeId(e as NodeIdLike).toString();
 }
 
 export type IsSubtypeOfFunc<T extends UAType> = (this: T, baseType: T) => boolean;
 
 export type UAType = UAReferenceType | UADataType | UAObjectType | UAVariableType;
 
-export function construct_isSubtypeOf<T extends UAType>(Class: typeof BaseNodeImpl): IsSubtypeOfFunc<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(
@@ -117,7 +132,7 @@ export function construct_isSubtypeOf<T extends UAType>(Class: typeof BaseNodeIm
             );
         }
         if (!(this instanceof Class)) {
-            throw new Error("expecting this to be " + Class.name + " but got " + baseType.toString());
+            throw new Error(`expecting this to be ${Class.name} but got ${baseType.toString()}`);
         }
         return _slow_isSubtypeOf.call(this, Class, baseType as T);
     }, hashBaseNode);
@@ -137,16 +152,16 @@ export function get_subtypeOf<T extends BaseNode>(this: T): NodeId | null {
     return s ? s.nodeId : null;
 }
 
-export function get_subtypeOfObj(this: BaseNode): BaseNode | null {
+export function get_subtypeOfObj<T extends BaseNode>(this: T): T | null {
     const _cache = BaseNode_getCache(this);
 
-    if (_cache._subtypeOfObj == undefined) {
+    if (_cache._subtypeOfObj === undefined) {
         const is_subtype_of_ref = this.findReference("HasSubtype", false);
-        if (is_subtype_of_ref ) {
+        if (is_subtype_of_ref) {
             _cache._subtypeOfObj = ReferenceImpl.resolveReferenceNode(this.addressSpace, is_subtype_of_ref);
         } else {
             _cache._subtypeOfObj = null;
         }
     }
-    return _cache._subtypeOfObj;
+    return (_cache._subtypeOfObj as T) || null;
 }

package/src/ua_condition_type.ts

@@ -1,4 +1,4 @@
-import { UAMethod, UAObjectType } from "node-opcua-address-space-base";
+import type { UAMethod, UAObjectType } from "node-opcua-address-space-base";
 
 export interface UAConditionType extends UAObjectType {
     disable: UAMethod;

package/src/ua_data_type_impl.ts

@@ -37,7 +37,6 @@ import { construct_isSubtypeOf, get_subtypeOf, get_subtypeOfObj } from "./tool_i
 const debugLog = make_debugLog("DATA_TYPE");
 const doDebug = checkDebugFlag("DATA_TYPE");
 
-
 export interface StructureFieldOptionsEx extends StructureFieldOptions {
     allowSubTypes: boolean;
 }
@@ -374,24 +373,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
@@ -435,10 +434,10 @@ function makeStructureDefinition(
             ? StructureType.UnionWithSubtypedValues
             : StructureType.Union
         : hasOptionalFields
-            ? StructureType.StructureWithOptionalFields
-            : hasSubtypedFields
-                ? StructureType.StructureWithSubtypedValues
-                : StructureType.Structure;
+          ? StructureType.StructureWithOptionalFields
+          : hasSubtypedFields
+            ? StructureType.StructureWithSubtypedValues
+            : StructureType.Structure;
 
     // note:  https://reference.opcfoundation.org/Core/Part3/v105/docs/8.51
     // field.isOptional has a special behavior depending on the structure type

package/src/ua_method_impl.ts

@@ -15,6 +15,7 @@ import {
     type MethodFunctorC,
     makeDefaultCloneExtraInfo,
     type UAMethod,
+    type UAMethodEvents, 
     type UAObject,
     type UAObjectType,
     type UAVariable
@@ -31,7 +32,7 @@ import { type CallMethodResultOptions, PermissionType } from "node-opcua-types";
 import { DataType, Variant, type VariantLike } from "node-opcua-variant";
 import type { SessionContext } from "../source/session_context";
 import type { AddressSpacePrivate } from "./address_space_private";
-import { BaseNodeImpl } from "./base_node_impl";
+import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl";
 import { _clone } from "./base_node_private";
 import { _handle_hierarchy_parent } from "./namespace_impl";
 
@@ -40,10 +41,14 @@ const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
 
 function default_check_valid_argument(arg: unknown): boolean {
-    return (arg as any) instanceof Argument;
+    return (arg as object) instanceof Argument;
 }
 
-export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
+export interface IMethodOptons extends InternalBaseNodeOptions {
+    value: unknown;
+    methodDeclarationId: NodeId;
+}
+export class UAMethodImpl extends BaseNodeImpl<UAMethodEvents> implements UAMethod {
     public static checkValidArgument(args: unknown): boolean {
         return default_check_valid_argument(args);
     }
@@ -58,13 +63,13 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
         return super.parent as UAObject;
     }
 
-    public value?: any;
+    public value?: unknown;
     public methodDeclarationId: NodeId;
     public _getExecutableFlag?: (this: UAMethod, context: ISessionContext | null) => boolean;
 
     public _asyncExecutionFunction?: MethodFunctor;
 
-    constructor(options: any) {
+    constructor(options: IMethodOptons) {
         super(options);
         this.value = options.value;
         this.methodDeclarationId = options.methodDeclarationId;
@@ -175,11 +180,11 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
         if (object.nodeClass !== NodeClass.Object && object.nodeClass !== NodeClass.ObjectType) {
             warningLog(
                 "Method " +
-                this.nodeId.toString() +
-                " " +
-                this.browseName.toString() +
-                " called for a node that is not a Object/ObjectType but " +
-                NodeClass[context.object?.nodeClass as number]
+                    this.nodeId.toString() +
+                    " " +
+                    this.browseName.toString() +
+                    " called for a node that is not a Object/ObjectType but " +
+                    NodeClass[context.object?.nodeClass as number]
             );
             return callback(null, { statusCode: StatusCodes.BadNodeIdInvalid });
         }
@@ -264,7 +269,7 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
 
                         // ── afterCall event ──
                         try {
-                            this.emit("afterCall", context, coercedInputArguments, callMethodResult);
+                            (this as UAMethod).emit("afterCall", context, coercedInputArguments, callMethodResult);
                         } catch (afterCallErr) {
                             if (afterCallErr instanceof Error) {
                                 warningLog(chalk.red("ERR in afterCall listener"), afterCallErr.message);
@@ -314,7 +319,7 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
         clonedMethod._getExecutableFlag = this._getExecutableFlag;
 
         if (options.componentOf) {
-            const m = options.componentOf.getMethodByName(clonedMethod.browseName.name!);
+            const m = options.componentOf.getMethodByName(clonedMethod.browseName.name || "");
             assert(m);
         }
         return clonedMethod as UAMethod;

package/src/ua_object_impl.ts

@@ -1,48 +1,50 @@
 /**
  * @module node-opcua-address-space
  */
-import chalk from "chalk";
 
+import chalk from "chalk";
+import {
+    type BaseNode,
+    type CloneExtraInfo,
+    type CloneFilter,
+    type CloneOptions,
+    defaultCloneFilter,
+    EventNotifierFlags,
+    type EventTypeLike,
+    type IEventData,
+    type ISessionContext,
+    type ListenerSignature,
+    makeDefaultCloneExtraInfo,
+    type RaiseEventData,
+    type UAEventType,
+    type UAMethod,
+    type UAObject,
+    type UAObjectEvents,
+    type UAObjectType
+} from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { isValidByte } from "node-opcua-basic-types";
-import { NodeClass, QualifiedNameLike, QualifiedNameOptions } from "node-opcua-data-model";
-import { AttributeIds } from "node-opcua-data-model";
-import { DataValue, DataValueLike } from "node-opcua-data-value";
+import { AttributeIds, NodeClass, type QualifiedNameLike, type QualifiedNameOptions } from "node-opcua-data-model";
+import { DataValue, type DataValueLike } from "node-opcua-data-value";
 import { getCurrentClock } from "node-opcua-date-time";
+import { make_errorLog } from "node-opcua-debug";
 import { NodeId } from "node-opcua-nodeid";
-import { NumericRange } from "node-opcua-numeric-range";
+import type { NumericRange } from "node-opcua-numeric-range";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType } from "node-opcua-variant";
-import {
-    EventTypeLike,
-    RaiseEventData,
-    ISessionContext,
-    UAMethod,
-    UAObject,
-    UAObjectType,
-    CloneOptions,
-    CloneFilter,
-    CloneExtraInfo,
-    BaseNode,
-    UAEventType,
-    IEventData,
-    defaultCloneFilter,
-    makeDefaultCloneExtraInfo,
-    EventNotifierFlags
-} from "node-opcua-address-space-base";
-import { make_errorLog } from "node-opcua-debug";
-
-import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
+import { apply_condition_refresh, type ConditionRefreshCache } from "./apply_condition_refresh";
+import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl";
 import { _clone, ToStringBuilder, UAObject_toString } from "./base_node_private";
-import { apply_condition_refresh, ConditionRefreshCache } from "./apply_condition_refresh";
 
 const errorLog = make_errorLog(__filename);
 
-export class UAObjectImpl extends BaseNodeImpl implements UAObject {
+export class UAObjectImpl<T extends UAObjectEvents & ListenerSignature<T> = UAObjectEvents>
+    extends BaseNodeImpl<T>
+    implements UAObject<T>
+{
     private _eventNotifier: EventNotifierFlags;
     public readonly nodeClass = NodeClass.Object;
     public get eventNotifier(): EventNotifierFlags {
-
         // ensure eventNotifier is set if the node has some event
 
         if (!this._eventNotifier) {
@@ -105,12 +107,12 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         options = {
             eventNotifier: this.eventNotifier,
             symbolicName: this.symbolicName || undefined,
-            ...options,
+            ...options
         };
 
         const cloneObject = _clone(
             this,
-            UAObjectImpl,
+            UAObjectImpl<T>,
             options,
             optionalFilter || defaultCloneFilter,
             extraInfo || makeDefaultCloneExtraInfo(this)
@@ -130,7 +132,7 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
     public getMethodByName(methodName: QualifiedNameOptions): UAMethod | null;
     public getMethodByName(methodName: string, namespaceIndex?: number): UAMethod | null;
     public getMethodByName(methodName: QualifiedNameLike, namespaceIndex?: number): UAMethod | null {
-        return super.getMethodByName(methodName as any, namespaceIndex);
+        return super.getMethodByName(methodName as string, namespaceIndex);
     }
 
     public getMethods(): UAMethod[] {
@@ -150,7 +152,7 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         if (typeof eventType === "string") {
             const eventTypeFound = addressSpace.findEventType(eventType);
             if (!eventTypeFound) {
-                throw new Error("raiseEvent: eventType cannot find event Type " + eventType.toString());
+                throw new Error(`raiseEvent: eventType cannot find event Type ${eventType.toString()}`);
             }
             eventType = eventTypeFound;
             if (!eventType || eventType.nodeClass !== NodeClass.ObjectType) {
@@ -159,11 +161,11 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         } else if (eventType instanceof NodeId) {
             const eventTypeFound = addressSpace.findNode(eventType) as BaseNode;
             if (!eventTypeFound) {
-                throw new Error("raiseEvent: eventType cannot find event Type " + eventType.toString());
+                throw new Error(`raiseEvent: eventType cannot find event Type ${eventType.toString()}`);
             }
-            eventType = eventTypeFound!;
+            eventType = eventTypeFound;
             if (!eventType || eventType.nodeClass !== NodeClass.ObjectType) {
-                throw new Error("eventType must exist and be an UAObjectType" + eventType.toString());
+                throw new Error(`eventType must exist and be an UAObjectType: ${eventType.toString()}`);
             }
         }
 
@@ -172,12 +174,12 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         let eventTypeNode: UAEventType = eventType as UAEventType;
         // c8 ignore next
         if (!eventTypeNode) {
-            throw new Error("UAObject#raiseEventType : Cannot find event type :" + eventType.toString());
+            throw new Error(`UAObject#raiseEventType : Cannot find event type : ${eventType.toString()}`);
         }
 
         // coerce EventType
         eventTypeNode = addressSpace.findEventType(eventType as UAEventType) as UAEventType;
-        const baseEventType = addressSpace.findEventType("BaseEventType")!;
+        const _baseEventType = addressSpace.findEventType("BaseEventType");
 
         data.$eventDataSource = eventTypeNode;
         data.sourceNode = data.sourceNode || { dataType: DataType.NodeId, value: this.nodeId };
@@ -190,9 +192,9 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
     public _bubble_up_event(eventData: IEventData): void {
         const addressSpace = this.addressSpace;
 
-        const queue: any[] = [];
+        const queue: BaseNode[] = [];
         // walk up the hasNotify / hasEventSource chain
-        const m: any = {};
+        const m: Record<string, BaseNode> = {};
 
         // all events are notified to the server object
         // emit on server object
@@ -222,6 +224,9 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
 
         while (queue.length) {
             const obj = queue.pop();
+            if (!obj) {
+                continue;
+            }
             // emit on object
             obj.emit("event", eventData);
 
@@ -241,4 +246,33 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         UAObject_toString.call(this, options);
         return options.toString();
     }
+
+    public toJSON(): Record<string, unknown> {
+        return {
+            ...super.toJSON(),
+            typeDefinition: this.typeDefinitionObj ? this.typeDefinitionObj.browseName.toString() : undefined,
+            eventNotifier: this._eventNotifier
+        };
+    }
+
+    public [Symbol.for("nodejs.util.inspect.custom")](depth: number | null, inspectOptions: { colors?: boolean }): string {
+        const c = inspectOptions?.colors === false ? plainChalk : chalk;
+        const typeName = this.typeDefinitionObj?.browseName.toString() ?? "?";
+        const displayName = this.displayName.length ? this.displayName.map((d) => d.text).join(" | ") : "";
+        if (depth !== null && depth <= 0) {
+            return `${c.cyan("UAObject<")}${c.green(this.browseName.toString())}${c.grey(` ${this.nodeId.toString()}`)}${c.cyan(">")}`;
+        }
+        const lines = [
+            `${c.cyan("UAObject ")}${c.green(this.browseName.toString())}${c.grey(` ${this.nodeId.toString()}`)}`,
+            c.yellow("  typeDefinition : ") + typeName,
+            c.yellow("  displayName    : ") + displayName,
+            c.yellow("  eventNotifier  : ") + this._eventNotifier
+        ];
+        if (this.description?.text) {
+            lines.push(c.yellow("  description    : ") + this.description.text);
+        }
+        return lines.join("\n");
+    }
 }
+
+const plainChalk = new Proxy(chalk, { get: () => (s: string) => s }) as typeof chalk;

package/src/ua_object_type_impl.ts

@@ -1,36 +1,33 @@
 /**
  * @module node-opcua-address-space
  */
-import { assert } from "node-opcua-assert";
-import { NodeClass } from "node-opcua-data-model";
-import { AttributeIds } from "node-opcua-data-model";
-import { DataValue, DataValueLike } from "node-opcua-data-value";
-import { NodeId } from "node-opcua-nodeid";
-import { StatusCodes } from "node-opcua-status-code";
-import { isNullOrUndefined } from "node-opcua-utils";
-import { DataType } from "node-opcua-variant";
-import {
+
+import type {
     AddObjectOptions,
+    BaseNodeEvents,
     InstantiateObjectOptions,
     ISessionContext,
     UAObject,
     UAObjectType,
     UAReference
 } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { AttributeIds, NodeClass } from "node-opcua-data-model";
+import { DataValue, type DataValueLike } from "node-opcua-data-value";
+import type { NodeId } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
+import { isNullOrUndefined } from "node-opcua-utils";
+import { DataType } from "node-opcua-variant";
 
 import { SessionContext } from "../source/session_context";
+import { initialize_properties_and_components } from "./_instantiate_helpers";
+import type { AddressSpacePrivate } from "./address_space_private";
 import { BaseNodeImpl } from "./base_node_impl";
 import { ToStringBuilder, UAObjectType_toString } from "./base_node_private";
 import { construct_isSubtypeOf, get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
-import { } from "./tool_isSubtypeOf";
-import {
-    assertUnusedChildBrowseName,
-    topMostParentIsObjectTypeOrVariableType
-} from "./ua_variable_type_impl";
-import { AddressSpacePrivate } from "./address_space_private";
-import { initialize_properties_and_components } from "./_instantiate_helpers";
+import { assertUnusedChildBrowseName, topMostParentIsObjectTypeOrVariableType } from "./ua_variable_type_impl";
 
-export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
+export class UAObjectTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements UAObjectType {
     public readonly nodeClass = NodeClass.ObjectType;
     public readonly isAbstract: boolean;
     /**
@@ -43,12 +40,10 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
         return get_subtypeOf.call(this);
     }
 
-
     public get subtypeOfObj(): UAObjectType | null {
-        return get_subtypeOfObj.call(this) as any as UAObjectType;
+        return get_subtypeOfObj.call(this) as unknown as UAObjectType;
     }
 
-
     public isSubtypeOf = construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
     /** @deprecated - use  isSubtypeOf instead */
     public isSupertypeOf = construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
@@ -112,12 +107,12 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
             "expecting a browse name"
         );
 
-        assert(!Object.prototype.hasOwnProperty.call(options, "propertyOf"), "an Object shall not be a PropertyOf an other object");
-        assert(!Object.prototype.hasOwnProperty.call(options, "optional"), "do you mean optionals ?");
+        assert(!Object.hasOwn(options, "propertyOf"), "an Object shall not be a PropertyOf an other object");
+        assert(!Object.hasOwn(options, "optional"), "do you mean optionals ?");
 
         assertUnusedChildBrowseName(addressSpace, options);
 
-        const baseObjectType = addressSpace.findObjectType("BaseObjectType")!;
+        const baseObjectType = addressSpace.findObjectType("BaseObjectType") as UAObjectType;
         assert(baseObjectType, "BaseObjectType must be defined in the address space");
 
         const references: UAReference[] = [];
@@ -151,8 +146,13 @@ export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
 
         const copyAlsoAllOptionals = options.copyAlsoAllOptionals || false;
         initialize_properties_and_components(
-            instance, baseObjectType, this, 
-            copyAlsoModellingRules, copyAlsoAllOptionals, options.optionals);
+            instance,
+            baseObjectType,
+            this,
+            copyAlsoModellingRules,
+            copyAlsoAllOptionals,
+            options.optionals
+        );
 
         assert(instance.typeDefinition.toString() === this.nodeId.toString());