node-opcua-address-space 2.168.0 → 2.170.1

package/src/event_data.ts

@@ -1,80 +1,83 @@
 /**
  * @module node-opcua-address-space.Private
  */
+
+import type { BaseNode, IEventData } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { coerceExpandedNodeId, NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import { BrowsePath, BrowsePathResult } from "node-opcua-types";
-import { Variant, VariantLike } from "node-opcua-variant";
-
-import { BaseNode, IEventData } from "node-opcua-address-space-base";
+import { type BrowsePath, BrowsePathResult } from "node-opcua-types";
 import { lowerFirstLetter } from "node-opcua-utils";
+import { Variant, type VariantLike } from "node-opcua-variant";
 
 type NodeIdString = string;
 type FullBrowsePath = string;
 
-
 /**
  */
 export class EventData implements IEventData {
-    public eventId: NodeId;
-    public $eventDataSource: BaseNode;
+  public eventId: NodeId;
+  #eventDataSource: BaseNode;
+  #cache: {
+    __values: { [key: NodeIdString]: Variant };
+    __nodeIdToNode: { [key: NodeIdString]: BaseNode };
+    __pathToNodeId: { [key: FullBrowsePath]: NodeId };
+    __nodeIdToFullPath: { [key: NodeIdString]: FullBrowsePath };
+  };
 
-    public $cache: {
-        __values: { [key: NodeIdString]: Variant };
-        __nodeIdToNode: { [key: NodeIdString]: BaseNode };
-        __pathToNodeId: { [key: FullBrowsePath]: NodeId };
-        __nodeIdToFullPath: { [key: NodeIdString]: FullBrowsePath };
+  constructor(eventTypeNode: BaseNode) {
+    this.#cache = {
+      __values: {},
+      __nodeIdToNode: {},
+      __pathToNodeId: {},
+      __nodeIdToFullPath: {}
     };
 
-    constructor(eventTypeNode: BaseNode) {
-        this.$cache = {
-            __values: {},
-            __nodeIdToNode: {},
-            __pathToNodeId: {},
-            __nodeIdToFullPath: {}
-        };
+    this.eventId = new NodeId();
+    this.#eventDataSource = eventTypeNode;
+  }
 
-        this.eventId = new NodeId();
-        this.$eventDataSource = eventTypeNode;
-    }
+  public getEventDataSource(): BaseNode {
+    return this.#eventDataSource;
+  }
+  public _createValue(fullBrowsePath: string, node: BaseNode, variant: VariantLike): void {
+    const eventData = this as Record<string, unknown>;
+    assert(!eventData[fullBrowsePath], `already exists ${fullBrowsePath}`);
 
-    public _createValue(fullBrowsePath: string, node: BaseNode, variant: VariantLike): void {
-        const eventData = this as any;
-        assert(!eventData[fullBrowsePath], "already exists " + fullBrowsePath);
+    const lowerName = fullBrowsePath.split(".").map(lowerFirstLetter).join(".");
 
-        const lowerName = fullBrowsePath.split(".").map(lowerFirstLetter).join(".");
+    eventData[lowerName] = Variant.coerce(variant);
 
-        eventData[lowerName] = Variant.coerce(variant);
+    this.#cache.__pathToNodeId[fullBrowsePath] = node.nodeId;
+    this.#cache.__nodeIdToNode[node.nodeId.toString()] = node;
+    this.#cache.__nodeIdToFullPath[node.nodeId.toString()] = fullBrowsePath;
+    this.#cache.__values[node.nodeId.toString()] = eventData[lowerName] as Variant;
+  }
 
-        this.$cache.__pathToNodeId[fullBrowsePath] = node.nodeId;
-        this.$cache.__nodeIdToNode[node.nodeId.toString()] = node;
-        this.$cache.__nodeIdToFullPath[node.nodeId.toString()] = fullBrowsePath;
-        this.$cache.__values[node.nodeId.toString()] = eventData[lowerName];
+  public _browse(browsePath: BrowsePath): BrowsePathResult | null {
+    if (!sameNodeId(browsePath.startingNode, this.#eventDataSource.nodeId)) {
+      return null;
     }
-
-    public _browse(browsePath: BrowsePath): BrowsePathResult | null {
-        if (!sameNodeId(browsePath.startingNode, this.$eventDataSource.nodeId)) {
-            return null;
+    const fullBrowsePath = (browsePath.relativePath.elements || []).map((b) => b.targetName.toString()).join(".");
+    const nodeId = this.#cache.__pathToNodeId[fullBrowsePath];
+    if (!nodeId) return null;
+    return new BrowsePathResult({
+      statusCode: StatusCodes.Good,
+      targets: [
+        {
+          remainingPathIndex: 0,
+          targetId: coerceExpandedNodeId(nodeId)
         }
-        const fullBrowsePath = (browsePath.relativePath.elements || []).map((b=>b.targetName.toString())).join(".");
-        const nodeId = this.$cache.__pathToNodeId[fullBrowsePath];
-        if (!nodeId) return null;
-        return new BrowsePathResult({
-            statusCode: StatusCodes.Good,
-            targets: [{
-                remainingPathIndex: 0,
-                targetId: coerceExpandedNodeId(nodeId),
-            }]
-        })
-    }
+      ]
+    });
+  }
 
-    public _readValue(nodeId: NodeId): Variant | null {
-        const key = nodeId.toString();
-        const cached_value = this.$cache.__values[key];
-        if (cached_value) {
-            return cached_value;
-        }
-        return null;
+  public _readValue(nodeId: NodeId): Variant | null {
+    const key = nodeId.toString();
+    const cached_value = this.#cache.__values[key];
+    if (cached_value) {
+      return cached_value;
     }
-}
+    return null;
+  }
+}

package/src/namespace_impl.ts

@@ -287,6 +287,22 @@ export class NamespaceImpl implements NamespacePrivate {
         return this.index === 0 ? this : this.addressSpace.getDefaultNamespace();
     }
 
+    public toJSON(): Record<string, string | number | undefined> {
+        return {
+            index: this.index,
+            namespaceUri: this.namespaceUri,
+            version: this.version
+        };
+    }
+
+    public toString(): string {
+        return `Namespace({ index: ${this.index}, namespaceUri: "${this.namespaceUri}" })`;
+    }
+
+    public [Symbol.for("nodejs.util.inspect.custom")](): string {
+        return this.toString();
+    }
+
     public dispose(): void {
         for (const node of this.nodeIterator()) {
             (<BaseNodeImpl>node).dispose();

package/src/ua_method_impl.ts

@@ -1,41 +1,39 @@
 /**
  * @module node-opcua-address-space
  */
-import { callbackify } from "util";
-import chalk from "chalk";
-import { assert } from "node-opcua-assert";
 
-import { AttributeIds, QualifiedNameLike } from "node-opcua-data-model";
-import { DiagnosticInfo, NodeClass } from "node-opcua-data-model";
-import { DataValue, DataValueLike } from "node-opcua-data-value";
-import { make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
-import { NodeId } from "node-opcua-nodeid";
-import { NumericRange } from "node-opcua-numeric-range";
-import { Argument } from "node-opcua-service-call";
-import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
-import { CallMethodResultOptions, PermissionType } from "node-opcua-types";
-import { Variant } from "node-opcua-variant";
-import { DataType, VariantLike } from "node-opcua-variant";
+import { callbackify } from "node:util";
+import chalk from "chalk";
 import {
-    MethodFunctor,
-    MethodFunctorA,
-    MethodFunctorC,
-    UAMethod,
-    UAObject,
-    CloneExtraInfo,
-    CloneFilter,
-    CloneOptions,
-    UAObjectType,
-    ISessionContext,
-    UAVariable,
+    type CloneExtraInfo,
+    type CloneFilter,
+    type CloneOptions,
     defaultCloneFilter,
-    makeDefaultCloneExtraInfo
+    type ISessionContext,
+    type MethodFunctor,
+    type MethodFunctorA,
+    type MethodFunctorC,
+    makeDefaultCloneExtraInfo,
+    type UAMethod,
+    type UAObject,
+    type UAObjectType,
+    type UAVariable
 } from "node-opcua-address-space-base";
-import { SessionContext } from "../source/session_context";
+import { assert } from "node-opcua-assert";
+import { AttributeIds, type DiagnosticInfo, NodeClass, type QualifiedNameLike } from "node-opcua-data-model";
+import { DataValue, type DataValueLike } from "node-opcua-data-value";
+import { make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
+import type { NodeId } from "node-opcua-nodeid";
+import type { NumericRange } from "node-opcua-numeric-range";
+import { Argument } from "node-opcua-service-call";
+import { type CallbackT, type StatusCode, StatusCodes } from "node-opcua-status-code";
+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 { _clone } from "./base_node_private";
 import { _handle_hierarchy_parent } from "./namespace_impl";
-import { BaseNodeImpl } from "./base_node_impl";
-import { AddressSpacePrivate } from "./address_space_private";
 
 const warningLog = make_warningLog(__filename);
 const debugLog = make_debugLog(__filename);
@@ -135,7 +133,7 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
         if (async_func.length === 2) {
             async_func = callbackify(async_func as MethodFunctorA) as MethodFunctorC;
         }
-        assert(async_func.length === 3, " a method with callback should have 3 arguments : got " + async_func.length);
+        assert(async_func.length === 3, ` a method with callback should have 3 arguments : got ${async_func.length}`);
         this._asyncExecutionFunction = async_func;
     }
     public execute(
@@ -181,17 +179,17 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
                 " " +
                 this.browseName.toString() +
                 " called for a node that is not a Object/ObjectType but " +
-                NodeClass[context.object!.nodeClass]
+                NodeClass[context.object?.nodeClass as number]
             );
             return callback(null, { statusCode: StatusCodes.BadNodeIdInvalid });
         }
         if (!this._asyncExecutionFunction) {
-            warningLog("Method " + this.nodeId.toString() + " " + this.browseName.toString() + " has not been bound");
+            warningLog(`Method ${this.nodeId.toString()} ${this.browseName.toString()} has not been bound`);
             return callback(null, { statusCode: StatusCodes.BadInternalError });
         }
 
         if (!this.getExecutableFlag(context)) {
-            warningLog("Method " + this.nodeId.toString() + " " + this.browseName.toString() + " is not executable");
+            warningLog(`Method ${this.nodeId.toString()} ${this.browseName.toString()} is not executable`);
             return callback(null, { statusCode: StatusCodes.BadNotExecutable });
         }
 
@@ -212,7 +210,7 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
         // ── method call interceptors ──
         const addressSpace = this.addressSpace as AddressSpacePrivate;
         const interceptors = addressSpace._methodCallInterceptors;
-        const self = this;
+
         const coercedInputArguments = inputArguments as Variant[];
         const callObject = object;
 
@@ -221,13 +219,13 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
             for (const interceptor of interceptors) {
                 let status: StatusCode;
                 try {
-                    status = await interceptor(context, callObject, self, coercedInputArguments);
+                    status = await interceptor(context, callObject, this, coercedInputArguments);
                 } catch (err) {
                     if (err instanceof Error) {
                         warningLog(chalk.red("ERR in method interceptor"), err.message);
                     }
                     const callMethodResponse = { statusCode: StatusCodes.BadInternalError };
-                    callback!(err as Error, callMethodResponse);
+                    callback?.(err as Error, callMethodResponse);
                     return;
                 }
                 if (status !== StatusCodes.Good) {
@@ -237,14 +235,14 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
                         inputArgumentResults: coercedInputArguments?.map(() => status) || [],
                         inputArgumentDiagnosticInfos
                     };
-                    return callback!(null, callMethodResult);
+                    return callback?.(null, callMethodResult);
                 }
             }
 
             // All interceptors passed — execute the method body
             try {
-                self._asyncExecutionFunction!.call(
-                    self as UAMethodImpl,
+                this._asyncExecutionFunction?.call(
+                    this as UAMethodImpl,
                     coercedInputArguments,
                     context,
                     (err: Error | null, callMethodResult?: CallMethodResultOptions) => {
@@ -266,14 +264,14 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
 
                         // ── afterCall event ──
                         try {
-                            self.emit("afterCall", context, coercedInputArguments, callMethodResult);
+                            this.emit("afterCall", context, coercedInputArguments, callMethodResult);
                         } catch (afterCallErr) {
                             if (afterCallErr instanceof Error) {
                                 warningLog(chalk.red("ERR in afterCall listener"), afterCallErr.message);
                             }
                         }
 
-                        callback!(err, callMethodResult);
+                        callback?.(err, callMethodResult);
                     }
                 );
             } catch (err) {
@@ -282,7 +280,7 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
                     warningLog(err.stack);
                 }
                 const callMethodResponse = { statusCode: StatusCodes.BadInternalError };
-                callback!(err as Error, callMethodResponse);
+                callback?.(err as Error, callMethodResponse);
             }
         };
 
@@ -291,7 +289,7 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
                 warningLog(chalk.red("ERR in method interceptor"), err.message);
             }
             const callMethodResponse = { statusCode: StatusCodes.BadInternalError };
-            callback!(err as Error, callMethodResponse);
+            callback?.(err as Error, callMethodResponse);
         });
     }
 
@@ -310,13 +308,7 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
         if (!extraInfo) {
             extraInfo = makeDefaultCloneExtraInfo(this);
         }
-        const clonedMethod = _clone(
-            this,
-            UAMethodImpl,
-            options,
-            optionalFilter || defaultCloneFilter,
-            extraInfo
-        ) as UAMethodImpl;
+        const clonedMethod = _clone(this, UAMethodImpl, options, optionalFilter || defaultCloneFilter, extraInfo) as UAMethodImpl;
 
         clonedMethod._asyncExecutionFunction = this._asyncExecutionFunction;
         clonedMethod._getExecutableFlag = this._getExecutableFlag;
@@ -351,4 +343,5 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
 // tslint:disable:no-var-requires
 // tslint:disable:max-line-length
 import { withCallback } from "thenify-ex";
+
 UAMethodImpl.prototype.execute = withCallback(UAMethodImpl.prototype.execute);

package/src/ua_object_impl.ts

@@ -5,36 +5,36 @@ import chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
 import { isValidByte } from "node-opcua-basic-types";
-import { NodeClass, QualifiedNameLike, QualifiedNameOptions } from "node-opcua-data-model";
+import { NodeClass, type QualifiedNameLike, type QualifiedNameOptions } from "node-opcua-data-model";
 import { AttributeIds } from "node-opcua-data-model";
-import { DataValue, DataValueLike } from "node-opcua-data-value";
+import { DataValue, type DataValueLike } from "node-opcua-data-value";
 import { getCurrentClock } from "node-opcua-date-time";
 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,
+    type EventTypeLike,
+    type RaiseEventData,
+    type ISessionContext,
+    type UAMethod,
+    type UAObject,
+    type UAObjectType,
+    type CloneOptions,
+    type CloneFilter,
+    type CloneExtraInfo,
+    type BaseNode,
+    type UAEventType,
+    type 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 { 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";
+import { apply_condition_refresh, type ConditionRefreshCache } from "./apply_condition_refresh";
 
 const errorLog = make_errorLog(__filename);
 
@@ -159,11 +159,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!;
             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,14 +172,14 @@ 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.$eventDataSource =eventTypeNode;
         data.sourceNode = data.sourceNode || { dataType: DataType.NodeId, value: this.nodeId };
 
         const eventData1 = addressSpace.constructEventData(eventTypeNode, data);
@@ -241,4 +241,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

@@ -112,12 +112,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[] = [];

package/src/ua_variable_impl.ts

@@ -76,7 +76,7 @@ import { UAHistoricalDataConfiguration } from "node-opcua-nodeset-ua";
 import { SessionContext } from "../source/session_context";
 import { convertToCallbackFunction1 } from "../source/helpers/multiform_func";
 import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
-import { _clone, ToStringBuilder, UAVariable_toString } from "./base_node_private";
+import { _clone, ToStringBuilder, UAVariable_toString, valueRankToString } from "./base_node_private";
 import { EnumerationInfo, IEnumItem, UADataTypeImpl } from "./ua_data_type_impl";
 import { apply_condition_refresh, ConditionRefreshCache } from "./apply_condition_refresh";
 import {
@@ -101,6 +101,8 @@ const warningLog = make_warningLog(__filename);
 const doDebug = checkDebugFlag(__filename);
 const errorLog = make_errorLog(__filename);
 
+const plainChalk = new Proxy(chalk, { get: () => (s: string) => s }) as typeof chalk;
+
 export function adjust_accessLevel(accessLevel: string | number | null): AccessLevelFlag {
     accessLevel = isNullOrUndefined(accessLevel) ? "CurrentRead | CurrentWrite" : accessLevel;
     accessLevel = makeAccessLevelFlag(accessLevel);
@@ -239,7 +241,9 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             // this could happen in faulty external nodeset and has been seen once
             // in an nano server
             warningLog(super.typeDefinitionObj.toString());
-            return this.addressSpace.findVariableType("BaseVariableType")!;
+            const baseVariableType= this.addressSpace.findVariableType("BaseVariableType");
+            if (!baseVariableType) throw new Error("Cannot find BaseVariableType in address space");
+            return baseVariableType;
         }
         return super.typeDefinitionObj as UAVariableType;
     }
@@ -1522,6 +1526,79 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         return options.toString();
     }
 
+    public toJSON(): Record<string, unknown> {
+        let value: unknown;
+        let statusCode: string | undefined;
+        try {
+            const dv = this.$dataValue;
+            if (dv) {
+                statusCode = dv.statusCode?.toString();
+                if (dv.value && !(dv.value.value instanceof OpaqueStructure)) {
+                    value = dv.value.value;
+                }
+            }
+        } catch {
+            // ignore — value access may fail for bound variables
+        }
+        return {
+            ...super.toJSON(),
+            typeDefinition: this.typeDefinitionObj?.browseName.toString(),
+            dataType: this.dataType?.toString(),
+            valueRank: this.valueRank,
+            arrayDimensions: this.arrayDimensions,
+            accessLevel: AccessLevelFlag[this.accessLevel],
+            statusCode,
+            value
+        };
+    }
+
+    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("UAVariable<")}${c.green(this.browseName.toString())}${c.grey(` ${this.nodeId.toString()}`)}${c.cyan(">")}`;
+        }
+        const dt = this.dataType?.toString() ?? "?";
+        let valueStr = "";
+        let statusStr = "";
+        try {
+            const dv = this.$dataValue;
+            if (dv) {
+                if (dv.statusCode) statusStr = dv.statusCode.toString();
+                if (dv.value && dv.value.value !== undefined && dv.value.value !== null && !(dv.value.value instanceof OpaqueStructure)) {
+                    const v = dv.value.value;
+                    valueStr = typeof v === "object" ? Object.prototype.toString.call(v) : String(v);
+                    if (valueStr.length > 80) valueStr = `${valueStr.slice(0, 77)}...`;
+                }
+            }
+        } catch {
+            // ignore
+        }
+        const lines = [
+            `${c.cyan("UAVariable ")}${c.green(this.browseName.toString())}${c.grey(` ${this.nodeId.toString()}`)}`,
+            c.yellow("  typeDefinition : ") + typeName,
+            c.yellow("  displayName    : ") + displayName,
+            c.yellow("  dataType       : ") + dt,
+            c.yellow("  valueRank      : ") + valueRankToString(this.valueRank),
+            c.yellow("  accessLevel    : ") + AccessLevelFlag[this.accessLevel]
+        ];
+        if (this.arrayDimensions?.length) {
+            lines.push(c.yellow("  arrayDimensions: ") + JSON.stringify(this.arrayDimensions));
+        }
+        if (valueStr) {
+            lines.push(c.yellow("  value          : ") + valueStr);
+        }
+        if (statusStr && statusStr !== "Good (0x00000000)") {
+            lines.push(c.yellow("  statusCode     : ") + statusStr);
+        }
+        if (this.description?.text) {
+            lines.push(c.yellow("  description    : ") + this.description.text);
+        }
+        return lines.join("\n");
+    }
+
+
     // ---------------------------------------------------------------------------------------------------
     // History
     // ---------------------------------------------------------------------------------------------------