node-opcua-address-space-base 2.169.0 → 2.172.0

package/source/i_event_data.ts

@@ -1,17 +1,16 @@
-import { NodeId } from "node-opcua-nodeid";
-import { BrowsePath, BrowsePathResult } from "node-opcua-types";
-import { Variant, VariantLike } from "node-opcua-variant";
-import { BaseNode } from "./base_node";
+import type { NodeId } from "node-opcua-nodeid";
+import type { BrowsePath, BrowsePathResult } from "node-opcua-types";
+import type { Variant, VariantLike } from "node-opcua-variant";
+import type { BaseNode } from "./base_node";
 
 export interface IEventData {
-    /**
-     * the event type node
-     */
-    $eventDataSource?: BaseNode;
     /**
      *
      */
     eventId: NodeId;
+
+    getEventDataSource(): BaseNode;
+
     _createValue(fullBrowsePath: string, node: BaseNode, variant: VariantLike): void;
     _readValue(nodeId: NodeId): Variant | null;
     _browse(browsePath: BrowsePath): BrowsePathResult | null;

package/source/index.ts

@@ -13,12 +13,12 @@ export * from "./ua_data_type";
 export * from "./ua_dynamic_variable_array";
 export * from "./ua_event_type";
 export * from "./ua_method";
-export * from "./ua_object_type";
 export * from "./ua_object";
+export * from "./ua_object_type";
 export * from "./ua_property";
-export * from "./ua_reference_type";
 export * from "./ua_reference";
+export * from "./ua_reference_type";
+export * from "./ua_variable";
 export * from "./ua_variable_t";
 export * from "./ua_variable_type";
-export * from "./ua_variable";
 export * from "./ua_view";

package/source/instantiate_options.ts

@@ -1,9 +1,8 @@
-import { QualifiedNameLike, LocalizedTextLike } from "node-opcua-data-model";
-import { NodeIdLike } from "node-opcua-nodeid";
-
-import { BaseNode } from "./base_node";
-import { ModellingRuleType } from "./modelling_rule_type";
-import { INamespace } from "./namespace";
+import type { LocalizedTextLike, QualifiedNameLike } from "node-opcua-data-model";
+import type { NodeIdLike } from "node-opcua-nodeid";
+import type { BaseNode } from "./base_node";
+import type { ModellingRuleType } from "./modelling_rule_type";
+import type { INamespace } from "./namespace";
 
 export interface InstantiateOptions {
     /**

package/source/namespace.ts

@@ -229,7 +229,7 @@ export interface VariableStuff {
     dataValue?: DataValueOptions;
 }
 
-export interface AddVariableOptionsWithoutValue extends AddBaseNodeOptions, VariableStuff { }
+export interface AddVariableOptionsWithoutValue extends AddBaseNodeOptions, VariableStuff {}
 export interface AddVariableOptions extends AddVariableOptionsWithoutValue {
     // default value is "BaseVariableType";
     typeDefinition?: string | NodeId | UAVariableType;

package/source/ua_data_type.ts

@@ -1,11 +1,10 @@
-import { NodeClass } from "node-opcua-data-model";
-import { ExpandedNodeId, NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { DataType } from "node-opcua-variant";
-import { DataTypeDefinition, EnumDefinition, StructureDefinition } from "node-opcua-types";
+import type { NodeClass } from "node-opcua-data-model";
+import type { ExpandedNodeId, NodeId, NodeIdLike } from "node-opcua-nodeid";
+import type { DataTypeDefinition, EnumDefinition, StructureDefinition } from "node-opcua-types";
+import type { DataType } from "node-opcua-variant";
+import type { BaseNode, BaseNodeEvents } from "./base_node";
 
-import { BaseNode } from "./base_node";
-
-export interface UADataType extends BaseNode {
+export interface UADataType extends BaseNode<BaseNodeEvents> {
     readonly nodeClass: NodeClass.DataType;
 
     readonly subtypeOfObj: UADataType | null;

package/source/ua_dynamic_variable_array.ts

@@ -1,9 +1,9 @@
-import { QualifiedName } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
-import { ExtensionObject } from "node-opcua-extension-object";
-import { UADataType } from "./ua_data_type";
-import { UAVariable } from "./ua_variable";
-import { UAVariableType } from "./ua_variable_type";
+import type { QualifiedName } from "node-opcua-data-model";
+import type { DataValue } from "node-opcua-data-value";
+import type { ExtensionObject } from "node-opcua-extension-object";
+import type { UADataType } from "./ua_data_type";
+import type { UAVariable } from "./ua_variable";
+import type { UAVariableType } from "./ua_variable_type";
 
 // {{ Dynamic Array Variable
 export interface UADynamicVariableArray<T extends ExtensionObject = ExtensionObject> extends UAVariable {

package/source/ua_event_type.ts

@@ -1,3 +1,3 @@
-import { UAObjectType } from "./ua_object_type";
+import type { UAObjectType } from "./ua_object_type";
 // tslint:disable:no-empty-interface
 export interface UAEventType extends UAObjectType {}

package/source/ua_method.ts

@@ -1,15 +1,14 @@
-import { NodeClass } from "node-opcua-data-model";
-import { NodeId } from "node-opcua-nodeid";
-import { Argument, CallMethodResultOptions } from "node-opcua-types";
-import { Variant, VariantLike } from "node-opcua-variant";
-import { CallbackT } from "node-opcua-status-code";
-//
-import { BaseNode } from "./base_node";
-import { ISessionContext } from "./session_context";
-import { UAObject } from "./ua_object";
-import { UAObjectType } from "./ua_object_type";
-import { UAVariable } from "./ua_variable";
-import { CloneExtraInfo, CloneFilter, CloneOptions } from "./clone_options";
+import type { NodeClass } from "node-opcua-data-model";
+import type { NodeId } from "node-opcua-nodeid";
+import type { CallbackT } from "node-opcua-status-code";
+import type { Argument, CallMethodResultOptions } from "node-opcua-types";
+import type { Variant, VariantLike } from "node-opcua-variant";
+import type { BaseNode, BaseNodeEvents, ListenerSignature } from "./base_node";
+import type { CloneExtraInfo, CloneFilter, CloneOptions } from "./clone_options";
+import type { ISessionContext } from "./session_context";
+import type { UAObject } from "./ua_object";
+import type { UAObjectType } from "./ua_object_type";
+import type { UAVariable } from "./ua_variable";
 
 export declare type MethodFunctorC = (
     this: UAMethod,
@@ -25,46 +24,51 @@ export declare type MethodFunctorA = (
 
 export type MethodFunctor = MethodFunctorC | MethodFunctorA;
 
-export declare class UAMethod extends BaseNode {
-    public readonly nodeClass: NodeClass.Method;
-    public readonly typeDefinition: NodeId;
-    public readonly typeDefinitionObj: UAObjectType;
 
-    public readonly parent: UAObject | null;
+export interface UAMethodEvents extends BaseNodeEvents {
+    "method_executed": (inputArguments: Variant[], context: ISessionContext, callMethodResult: CallMethodResultOptions) => void;
+    "afterCall": (context: ISessionContext,inputArguments: Variant[], callMethodResult: CallMethodResultOptions) => void;
+}
+export interface UAMethod<T extends UAMethodEvents & ListenerSignature<T>   = UAMethodEvents> extends BaseNode<T> {
+    readonly nodeClass: NodeClass.Method;
+    readonly typeDefinition: NodeId;
+    readonly typeDefinitionObj: UAObjectType;
+
+    readonly parent: UAObject | null;
 
-    public readonly inputArguments?: UAVariable;
-    public readonly outputArguments?: UAVariable;
+    readonly inputArguments?: UAVariable;
+    readonly outputArguments?: UAVariable;
 
-    public readonly methodDeclarationId: NodeId;
+    readonly methodDeclarationId: NodeId;
 
     /**
      *
      */
-    public _getExecutableFlag?: (sessionContext: ISessionContext | null) => boolean;
+    _getExecutableFlag?: (sessionContext: ISessionContext | null) => boolean;
 
-    public bindMethod(methodFunction: MethodFunctor): void;
+    bindMethod(methodFunction: MethodFunctor): void;
 
-    public getExecutableFlag(context: ISessionContext): boolean;
+    getExecutableFlag(context: ISessionContext): boolean;
 
-    public getInputArguments(): Argument[];
+    getInputArguments(): Argument[];
 
-    public getOutputArguments(): Argument[];
+    getOutputArguments(): Argument[];
 
     /**
      */
-    public execute(
+    execute(
         object: UAObject | UAObjectType | null,
         inputArguments: VariantLike[] | null,
         context: ISessionContext,
         callback: CallbackT<CallMethodResultOptions>
     ): void;
-    public execute(
+    execute(
         object: UAObject | UAObjectType | null,
         inputArguments: null | VariantLike[],
         context: ISessionContext
     ): Promise<CallMethodResultOptions>;
 
-    public clone(options: CloneOptions, optionalFilter?: CloneFilter, extraInfo?: CloneExtraInfo): UAMethod;
+    clone(options: CloneOptions, optionalFilter?: CloneFilter, extraInfo?: CloneExtraInfo): UAMethod;
 
-    public isBound(): boolean;
+    isBound(): boolean;
 }

package/source/ua_object.ts

@@ -1,17 +1,15 @@
-import { NodeId } from "node-opcua-nodeid";
-import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
-import { Byte, DateTime, Int16, Int32, SByte, UAString, UInt16, UInt32 } from "node-opcua-basic-types";
-import { StatusCode } from "node-opcua-status-code";
-import { LocalizedTextLike, NodeClass, QualifiedNameOptions } from "node-opcua-data-model";
-
-import { ExtensionObject } from "node-opcua-extension-object";
-import { CloneOptions, CloneFilter, CloneExtraInfo } from "./clone_options";
-import { BaseNode, IPropertyAndComponentHolder } from "./base_node";
-import { UAObjectType } from "./ua_object_type";
-import { IEventData } from "./i_event_data";
-import { UAEventType } from "./ua_event_type";
-import { UAMethod } from "./ua_method";
-import { EventNotifierFlags } from "./event_notifier_flags";
+import type { Byte, DateTime, Int16, Int32, SByte, UAString, UInt16, UInt32 } from "node-opcua-basic-types";
+import type { LocalizedTextLike, NodeClass, QualifiedNameOptions } from "node-opcua-data-model";
+import type { ExtensionObject } from "node-opcua-extension-object";
+import type { NodeId } from "node-opcua-nodeid";
+import type { StatusCode } from "node-opcua-status-code";
+import type { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+import type { BaseNode, BaseNodeEvents, IPropertyAndComponentHolder, ListenerSignature } from "./base_node";
+import type { CloneExtraInfo, CloneFilter, CloneOptions } from "./clone_options";
+import type { EventNotifierFlags } from "./event_notifier_flags";
+import type { UAEventType } from "./ua_event_type";
+import type { UAMethod } from "./ua_method";
+import type { UAObjectType } from "./ua_object_type";
 
 export type EventTypeLike = string | NodeId | UAEventType;
 
@@ -144,6 +142,7 @@ export type PseudoVariant =
     | PseudoVariantExtensionObjectArray
     | PseudoVariantVariant
     | PseudoVariantVariantArray;
+
 export interface RaiseEventData {
     $eventDataSource?: UAEventType;
 
@@ -155,10 +154,18 @@ export interface EventRaiser {
     raiseEvent(eventType: EventTypeLike, eventData: RaiseEventData): void;
 }
 
+export interface UAObjectEvents extends BaseNodeEvents {    
+
+    "event_raised":()=>void;
+}
+
 /**
  * @interface UAObject
  */
-export interface UAObject extends BaseNode, EventRaiser, IPropertyAndComponentHolder {
+export interface UAObject<T extends UAObjectEvents & ListenerSignature<T>  = UAObjectEvents>
+    extends BaseNode<T>,
+        EventRaiser,
+        IPropertyAndComponentHolder {
     readonly nodeClass: NodeClass.Object;
     get parent(): BaseNode | null;
     get typeDefinitionObj(): UAObjectType;
@@ -180,11 +187,6 @@ export interface UAObject extends BaseNode, EventRaiser, IPropertyAndComponentHo
 
     raiseEvent(eventType: EventTypeLike | BaseNode, eventData: RaiseEventData): void;
 
-    on(eventName: "event", eventHandler: (eventData: IEventData) => void): this;
-    on(eventName: "dispose", eventHandler: () => void): this;
-    once(eventName: "event", eventHandler: (eventData: IEventData) => void): this;
-    once(eventName: "dispose", eventHandler: () => void): this;
-
     setEventNotifier(eventNotifierFlags: EventNotifierFlags): void;
 
     clone(options: CloneOptions, optionalFilter?: CloneFilter, extraInfo?: CloneExtraInfo): UAObject;

package/source/ua_object_type.ts

@@ -1,12 +1,11 @@
-import { QualifiedNameLike, QualifiedNameOptions } from "node-opcua-data-model";
-import { NodeClass } from "node-opcua-types";
-import { NodeId, NodeIdLike } from "node-opcua-nodeid";
-
-import { InstantiateOptions } from "./instantiate_options";
-import { BaseNode, IPropertyAndComponentHolder } from "./base_node";
-import { UAObject } from "./ua_object";
-import { UAMethod } from "./ua_method";
-import { EventNotifierFlags } from "./event_notifier_flags";
+import type { QualifiedNameLike, QualifiedNameOptions } from "node-opcua-data-model";
+import type { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import type { NodeClass } from "node-opcua-types";
+import type { BaseNode, BaseNodeEvents, IPropertyAndComponentHolder } from "./base_node";
+import type { EventNotifierFlags } from "./event_notifier_flags";
+import type { InstantiateOptions } from "./instantiate_options";
+import type { UAMethod } from "./ua_method";
+import type { UAObject } from "./ua_object";
 
 export interface InstantiateObjectOptions extends InstantiateOptions {
     //
@@ -22,7 +21,7 @@ export interface InstantiateObjectOptions extends InstantiateOptions {
     addInOf?: NodeId | BaseNode;
 }
 
-export declare interface UAObjectType extends BaseNode, IPropertyAndComponentHolder {
+export declare interface UAObjectType extends BaseNode<BaseNodeEvents>, IPropertyAndComponentHolder {
     readonly nodeClass: NodeClass.ObjectType;
     readonly subtypeOf: NodeId | null;
     readonly subtypeOfObj: UAObjectType | null;

package/source/ua_property.ts

@@ -1,5 +1,5 @@
-import { DataType } from "node-opcua-variant";
-import { UAVariableT } from "./ua_variable_t";
+import type { DataType } from "node-opcua-variant";
+import type { UAVariableT } from "./ua_variable_t";
 /**
  * |                |                                                  |
  * |----------------|--------------------------------------------------|
@@ -10,5 +10,7 @@ import { UAVariableT } from "./ua_variable_t";
  * |dataType Name   |undefined ns=0;i=0                                |
  * |isAbstract      |false                                             |
  */
-export interface UAProperty_Base<T, DT extends DataType> {}
+export interface UAProperty_Base<T, DT extends DataType> extends UAVariableT<T, DT> {
+    /** A property is a variable that describes an attribute of another variable or object. */
+}
 export interface UAProperty<T, DT extends DataType> extends UAVariableT<T, /*m*/ DT>, UAProperty_Base<T, DT /*A*/> {}

package/source/ua_reference.ts

@@ -1,6 +1,6 @@
-import { NodeId } from "node-opcua-nodeid";
-import { IAddressSpace } from "./address_space";
-import { BaseNode } from "./base_node";
+import type { NodeId } from "node-opcua-nodeid";
+import type { IAddressSpace } from "./address_space";
+import type { BaseNode } from "./base_node";
 
 export interface UAReference {
     readonly nodeId: NodeId;

package/source/ua_reference_type.ts

@@ -1,25 +1,25 @@
-import { LocalizedText, NodeClass } from "node-opcua-data-model";
-import { NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { BaseNode } from "./base_node";
-import { UAReference } from "./ua_reference";
+import type { LocalizedText, NodeClass } from "node-opcua-data-model";
+import type { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import type { BaseNode } from "./base_node";
+import type { UAReference } from "./ua_reference";
 
-export declare class UAReferenceType extends BaseNode {
-    public readonly nodeClass: NodeClass.ReferenceType;
-    public readonly subtypeOfObj: UAReferenceType | null;
-    public readonly subtypeOf: NodeId | null;
-    public readonly isAbstract: boolean;
-    public readonly inverseName: LocalizedText;
+export interface UAReferenceType extends BaseNode {
+    readonly nodeClass: NodeClass.ReferenceType;
+    readonly subtypeOfObj: UAReferenceType | null;
+    readonly subtypeOf: NodeId | null;
+    readonly isAbstract: boolean;
+    readonly inverseName: LocalizedText;
 
-    public isSubtypeOf(baseType: UAReferenceType | NodeIdLike): boolean;
+    isSubtypeOf(baseType: UAReferenceType | NodeIdLike): boolean;
 
     /** @deprecated - use  isSubtypeOf instead */
-    public isSupertypeOf(baseType: UAReferenceType | NodeIdLike): boolean;
+    isSupertypeOf(baseType: UAReferenceType | NodeIdLike): boolean;
 
-    public getAllSubtypes(): UAReferenceType[];
+    getAllSubtypes(): UAReferenceType[];
 
     /**
      *
      * @param reference
      */
-    public checkHasSubtype(referenceType: NodeId | UAReference): boolean;
+    checkHasSubtype(referenceType: NodeId | UAReference): boolean;
 }

package/source/ua_variable.ts

@@ -1,28 +1,35 @@
-import { AttributeIds, CallbackT, DataType, PreciseClock, StatusCode, StatusCodeCallback, UInt32 } from "node-opcua-basic-types";
-import { NodeClass, QualifiedNameLike } from "node-opcua-data-model";
-import { NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { DataValue } from "node-opcua-data-value";
-import { ExtensionObject } from "node-opcua-extension-object";
-import { NumericRange } from "node-opcua-numeric-range";
-
-import {
-    WriteValueOptions,
+import type {
+    AttributeIds,
+    CallbackT,
+    DataType,
+    PreciseClock,
+    StatusCode,
+    StatusCodeCallback,
+    UInt32
+} from "node-opcua-basic-types";
+import type { NodeClass, QualifiedNameLike } from "node-opcua-data-model";
+import type { DataValue } from "node-opcua-data-value";
+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 {
     HistoryReadDetails,
     HistoryReadResult,
-    ReadRawModifiedDetails,
+    ReadAtTimeDetails,
     ReadEventDetails,
     ReadProcessedDetails,
-    ReadAtTimeDetails
+    ReadRawModifiedDetails,
+    WriteValueOptions
 } from "node-opcua-types";
-import { Variant, VariantLike } from "node-opcua-variant";
-
+import type { VariantLike } from "node-opcua-variant";
+import type { BaseNode, BaseNodeEvents, IPropertyAndComponentHolder, ListenerSignature } from "./base_node";
+import type { BindVariableOptions } from "./bind_variable";
 //
-import { CloneOptions, CloneFilter, CloneExtraInfo } from "./clone_options";
-import { BaseNode, IPropertyAndComponentHolder } from "./base_node";
-import { ISessionContext, ContinuationData } from "./session_context";
-import { UADataType } from "./ua_data_type";
-import { UAVariableType } from "./ua_variable_type";
-import { BindVariableOptions } from "./bind_variable";
+import type { CloneExtraInfo, CloneFilter, CloneOptions } from "./clone_options";
+import type { ContinuationData, ISessionContext } from "./session_context";
+import type { UADataType } from "./ua_data_type";
+import type { UAVariableType } from "./ua_variable_type";
 
 export interface IVariableHistorian {
     /**
@@ -81,7 +88,15 @@ export interface BindExtensionObjectOptions {
 export interface IVariableDataTypeChange {
     changeDataType(newDataType: NodeIdLike, newValue?: VariantLike): void;
 }
-export interface UAVariable extends BaseNode, VariableAttributes, IVariableDataTypeChange,  IPropertyAndComponentHolder {
+export interface UAVariableEvents extends BaseNodeEvents {
+    value_changed: (newDataValue: DataValue, index_range?: NumericRange |null) => void;
+    semantic_changed: () => void;
+}
+export interface UAVariable<T extends UAVariableEvents & ListenerSignature<T> = UAVariableEvents>
+    extends BaseNode<T>,
+        VariableAttributes,
+        IVariableDataTypeChange,
+        IPropertyAndComponentHolder {
     readonly nodeClass: NodeClass.Variable;
     readonly parent: BaseNode | null;
     readonly dataTypeObj: UADataType;
@@ -395,14 +410,4 @@ export interface UAVariable extends BaseNode, VariableAttributes, IVariableDataT
     ): void;
 
     clone(options: CloneOptions, optionalFilter?: CloneFilter, extraInfo?: CloneExtraInfo): UAVariable;
-
-    // ----------------- Event handlers
-
-    on(eventName: "semantic_changed", eventHandler: () => void): this;
-
-    on(eventName: "value_changed", eventHandler: (dataValue: DataValue) => void): this;
-
-    once(eventName: "semantic_changed", eventHandler: () => void): this;
-
-    once(eventName: "value_changed", eventHandler: (dataValue: DataValue) => void): this;
 }

package/source/ua_variable_t.ts

@@ -1,10 +1,10 @@
-import { QualifiedNameLike } from "node-opcua-data-model";
-import { DataValueOptionsT, DataValueT } from "node-opcua-data-value";
-import { NumericRange } from "node-opcua-numeric-range";
-import { CallbackT, StatusCode, StatusCodeCallback } from "node-opcua-status-code";
-import { DataType } from "node-opcua-variant";
-import { ISessionContext } from "./session_context";
-import { UAVariable } from "./ua_variable";
+import type { QualifiedNameLike } from "node-opcua-data-model";
+import type { DataValueT } from "node-opcua-data-value";
+import type { NumericRange } from "node-opcua-numeric-range";
+import type { CallbackT, StatusCode, StatusCodeCallback } from "node-opcua-status-code";
+import type { DataType } from "node-opcua-variant";
+import type { ISessionContext } from "./session_context";
+import type { UAVariable } from "./ua_variable";
 
 export interface UAVariableT<T, DT extends DataType> extends UAVariable {
     readValue(

package/source/ua_variable_type.ts

@@ -1,17 +1,16 @@
-import { NodeClass } from "node-opcua-data-model";
-import { NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { UInt32 } from "node-opcua-basic-types";
-import { DataType } from "node-opcua-variant";
-import { ExtensionObject } from "node-opcua-extension-object";
-
-import { BaseNode } from "./base_node";
-import { InstantiateOptions } from "./instantiate_options";
-import { UAObject } from "./ua_object";
-import { UAObjectType } from "./ua_object_type";
-import { UAVariable, VariableAttributes } from "./ua_variable";
-import { UAVariableT } from "./ua_variable_t";
-import { BindVariableOptions } from "./bind_variable";
-import { UAMethod } from "./ua_method";
+import type { UInt32 } from "node-opcua-basic-types";
+import type { NodeClass } from "node-opcua-data-model";
+import type { ExtensionObject } from "node-opcua-extension-object";
+import type { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import type { DataType } from "node-opcua-variant";
+import type { BaseNode } from "./base_node";
+import type { BindVariableOptions } from "./bind_variable";
+import type { InstantiateOptions } from "./instantiate_options";
+import type { UAMethod } from "./ua_method";
+import type { UAObject } from "./ua_object";
+import type { UAObjectType } from "./ua_object_type";
+import type { UAVariable, VariableAttributes } from "./ua_variable";
+import type { UAVariableT } from "./ua_variable_t";
 
 export interface InstantiateVariableOptions extends InstantiateOptions {
     arrayDimensions?: number[] | null;
@@ -37,26 +36,26 @@ export interface InstantiateVariableOptions extends InstantiateOptions {
      */
     valueRank?: number;
 }
-export declare class UAVariableType extends BaseNode implements VariableAttributes {
-    public readonly nodeClass: NodeClass.VariableType;
-    public readonly subtypeOfObj: UAVariableType | null;
-    public readonly subtypeOf: NodeId | null;
+export interface UAVariableType extends BaseNode, VariableAttributes {
+    readonly nodeClass: NodeClass.VariableType;
+    readonly subtypeOfObj: UAVariableType | null;
+    readonly subtypeOf: NodeId | null;
 
-    public dataType: NodeId;
-    public valueRank: number;
-    public minimumSamplingInterval: number;
-    public arrayDimensions: UInt32[] | null;
-    public historizing: boolean;
+    dataType: NodeId;
+    valueRank: number;
+    minimumSamplingInterval: number;
+    arrayDimensions: UInt32[] | null;
+    historizing: boolean;
 
-    public isAbstract: boolean;
+    isAbstract: boolean;
 
-    public isSubtypeOf(type: UAVariableType | NodeIdLike): boolean;
+    isSubtypeOf(type: UAVariableType | NodeIdLike): boolean;
 
     /** @deprecated - use isSubtypeOf instead */
-    public isSupertypeOf(type: UAVariableType | NodeIdLike): boolean;
+    isSupertypeOf(type: UAVariableType | NodeIdLike): boolean;
 
-    public instantiate(options: InstantiateVariableOptions): UAVariable;
-    public getBasicDataType(): DataType;
+    instantiate(options: InstantiateVariableOptions): UAVariable;
+    getBasicDataType(): DataType;
 }
 
 export interface UAVariableTypeT<T, DT extends DataType> extends UAVariableType {

package/source/ua_view.ts

@@ -1,6 +1,6 @@
-import { NodeClass } from "node-opcua-data-model";
-import { BaseNode } from "./base_node";
-import { EventNotifierFlags } from "./event_notifier_flags";
+import type { NodeClass } from "node-opcua-data-model";
+import type { BaseNode } from "./base_node";
+import type { EventNotifierFlags } from "./event_notifier_flags";
 
 export interface UAView extends BaseNode {
     readonly nodeClass: NodeClass.View;