node-opcua-client 2.178.0 → 2.179.0

package/source/private/client_session_impl.ts

@@ -2,8 +2,8 @@
  * @module node-opcua-client-private
  */
 
+import { EventEmitter } from "node:events";
 import chalk from "chalk";
-import { EventEmitter } from "events";
 import { assert } from "node-opcua-assert";
 import type { DateTime } from "node-opcua-basic-types";
 import {
@@ -33,7 +33,12 @@ import {
     readNamespaceArray
 } from "node-opcua-pseudo-session";
 import type { AnyConstructorFunc } from "node-opcua-schemas";
-import { ClientSecureChannelLayer, requestHandleNotSetValue, type SignatureData } from "node-opcua-secure-channel";
+import {
+    type ServiceFaultAnnotatedError as ChannelServiceFaultAnnotatedError,
+    ClientSecureChannelLayer,
+    requestHandleNotSetValue,
+    type SignatureData
+} from "node-opcua-secure-channel";
 import { BrowseDescription, BrowseRequest, BrowseResponse, BrowseResult } from "node-opcua-service-browse";
 import { CallMethodRequest, type CallMethodResult, CallRequest, CallResponse } from "node-opcua-service-call";
 import type { EndpointDescription } from "node-opcua-service-endpoints";
@@ -137,15 +142,15 @@ import { ClientSubscriptionImpl } from "./client_subscription_impl";
 import type { IClientBase } from "./i_private_client";
 import { repair_client_session } from "./reconnection/reconnection";
 
-const helpAPIChange = process.env.DEBUG && process.env.DEBUG.match(/API/);
+const helpAPIChange = process.env.DEBUG?.match(/API/);
 const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);
 const warningLog = make_warningLog(__filename);
-const errorLog = make_errorLog(__filename);
+const _errorLog = make_errorLog(__filename);
 
 let pendingTransactionMessageDisplayed = false;
 
-function coerceBrowseDescription(data: any): BrowseDescription {
+function coerceBrowseDescription(data: BrowseDescriptionLike | NodeId): BrowseDescription {
     if (typeof data === "string" || data instanceof NodeId) {
         return coerceBrowseDescription({
             browseDirection: BrowseDirection.Forward,
@@ -156,13 +161,14 @@ function coerceBrowseDescription(data: any): BrowseDescription {
             resultMask: 63
         });
     } else {
-        data.nodeId = resolveNodeId(data.nodeId);
-        data.referenceTypeId = data.referenceTypeId ? resolveNodeId(data.referenceTypeId) : null;
-        return new BrowseDescription(data);
+        const options = data as { nodeId: NodeIdLike; referenceTypeId?: NodeIdLike | null };
+        options.nodeId = resolveNodeId(options.nodeId);
+        options.referenceTypeId = options.referenceTypeId ? resolveNodeId(options.referenceTypeId) : null;
+        return new BrowseDescription(options);
     }
 }
 
-function coerceReadValueId(node: any): ReadValueId {
+function coerceReadValueId(node: unknown): ReadValueId {
     if (typeof node === "string" || node instanceof NodeId) {
         return new ReadValueId({
             attributeId: AttributeIds.Value,
@@ -172,7 +178,7 @@ function coerceReadValueId(node: any): ReadValueId {
         });
     } else {
         assert(node instanceof Object);
-        return new ReadValueId(node);
+        return new ReadValueId(node as ReadValueIdOptions);
     }
 }
 
@@ -180,6 +186,31 @@ const emptyUint32Array = new Uint32Array(0);
 
 type EmptyCallback = (err?: Error) => void;
 
+// re-exported from node-opcua-secure-channel, where the annotation is produced
+// (see process_request_callback): response / request / serviceDiagnostics / diagnosticsInfo.
+type ServiceFaultAnnotatedError = ChannelServiceFaultAnnotatedError;
+
+/**
+ * attach the server side diagnostics to an error, so that a caller can inspect them without
+ * having to know how the channel delivered the failure.
+ *
+ * For a ServiceFault there is no `response` argument at all - the channel moved the decoded
+ * fault onto `err.response` - so fall back to it, otherwise the diagnostics of the most
+ * interesting case would always be dropped.
+ */
+function annotateWithDiagnostics(err: Error, response?: Response): Error {
+    const annotatedError = err as ServiceFaultAnnotatedError;
+    const source = response ?? annotatedError.response;
+    if (source?.responseHeader.serviceDiagnostics) {
+        annotatedError.serviceDiagnostics = source.responseHeader.serviceDiagnostics;
+    }
+    const responseWithDiagnosticInfos = source as unknown as { diagnosticInfos?: unknown } | undefined;
+    if (responseWithDiagnosticInfos?.diagnosticInfos) {
+        annotatedError.diagnosticsInfo = responseWithDiagnosticInfos.diagnosticInfos;
+    }
+    return annotatedError;
+}
+
 export interface Reconnectable {
     _reconnecting: {
         reconnecting: boolean;
@@ -212,7 +243,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
     public _reconnecting: {
         reconnecting: boolean;
         pendingCallbacks: EmptyCallback[];
-        pendingTransactions: any[];
+        pendingTransactions: { request: Request; callback: (err: Error | null, response?: Response) => void }[];
     };
 
     /**
@@ -250,7 +281,10 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
     }
 
     getTransportSettings(): IBasicTransportSettings {
-        return this._client!.getTransportSettings();
+        if (!this._client) {
+            throw new Error("session has been closed - no transport settings available");
+        }
+        return this._client.getTransportSettings();
     }
     /**
      * the endpoint on which this session is operating
@@ -258,7 +292,10 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
      * @type {EndpointDescription}
      */
     get endpoint(): EndpointDescription {
-        return this._client!.endpoint!;
+        if (!this._client?.endpoint) {
+            throw new Error("session has been closed - no endpoint available");
+        }
+        return this._client.endpoint;
     }
 
     get subscriptionCount(): number {
@@ -290,31 +327,32 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
         if (!this._publishEngine) {
             this._publishEngine = new ClientSidePublishEngine(this);
         }
-        return this._publishEngine!;
+        return this._publishEngine;
     }
 
     public changeUser(userIdentityInfo: UserIdentityInfo): Promise<StatusCode>;
     public changeUser(userIdentityInfo: UserIdentityInfo, callback: CallbackT<StatusCode>): void;
-    public changeUser(userIdentityInfo: UserIdentityInfo, callback?: CallbackT<StatusCode>): any {
+    public changeUser(userIdentityInfo: UserIdentityInfo, callback?: CallbackT<StatusCode>): unknown {
         userIdentityInfo = userIdentityInfo || {
             type: UserTokenType.Anonymous
         };
         if (!this._client || !this.userIdentityInfo) {
             warningLog("changeUser: invalid session");
-            return callback!(null, StatusCodes.BadInternalError);
+            return callback?.(null, StatusCodes.BadInternalError);
         }
 
         const old_userIdentity: UserIdentityInfo = this.userIdentityInfo;
 
-        this._client._activateSession(this, userIdentityInfo, (err1: Error | null, session2?: ClientSessionImpl) => {
+        this._client._activateSession(this, userIdentityInfo, (err1: Error | null, _session2?: ClientSessionImpl) => {
             if (err1) {
                 this.userIdentityInfo = old_userIdentity;
                 warningLog("activate session error = ", err1.message);
-                return callback!(null, StatusCodes.BadUserAccessDenied);
+                return callback?.(null, StatusCodes.BadUserAccessDenied);
             }
             this.userIdentityInfo = userIdentityInfo;
-            callback!(null, StatusCodes.Good);
+            callback?.(null, StatusCodes.Good);
         });
+        return undefined;
     }
     /**
      *
@@ -385,22 +423,24 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
      * @internal
      * @param args
      */
-    public browse(...args: any[]): any {
+    public browse(...args: unknown[]): unknown {
         const arg0 = args[0];
         const isArray = Array.isArray(arg0);
-        const callback: ResponseCallback<BrowseResult[] | BrowseResult> = args[1];
+        const callback = args[1] as ResponseCallback<BrowseResult[] | BrowseResult>;
         assert(typeof callback === "function");
 
-        assert(isFinite(this.requestedMaxReferencesPerNode));
+        assert(Number.isFinite(this.requestedMaxReferencesPerNode));
 
-        const nodesToBrowse: BrowseDescription[] = (isArray ? arg0 : [arg0 as BrowseDescription]).map(coerceBrowseDescription);
+        const nodesToBrowse: BrowseDescription[] = (
+            isArray ? (arg0 as BrowseDescriptionLike[]) : [arg0 as BrowseDescriptionLike]
+        ).map(coerceBrowseDescription);
 
         const request = new BrowseRequest({
             nodesToBrowse,
             requestedMaxReferencesPerNode: this.requestedMaxReferencesPerNode
         });
 
-        this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
+        return this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             if (err) {
                 return callback(err);
             }
@@ -423,8 +463,8 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
                                 " BrowseResponse : the server didn't take into" +
                                 " account our requestedMaxReferencesPerNode "
                         );
-                        warningLog("        this.requestedMaxReferencesPerNode= " + this.requestedMaxReferencesPerNode);
-                        warningLog("        got " + r.references.length + "for " + nodesToBrowse[i].nodeId.toString());
+                        warningLog(`        this.requestedMaxReferencesPerNode= ${this.requestedMaxReferencesPerNode}`);
+                        warningLog(`        got ${r.references.length}for ${nodesToBrowse[i].nodeId.toString()}`);
                         warningLog("        continuationPoint ", r.continuationPoint);
                     }
                 }
@@ -451,21 +491,21 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
 
     public async browseNext(continuationPoint: Buffer, releaseContinuationPoints: boolean): Promise<BrowseResult>;
     public async browseNext(continuationPoints: Buffer[], releaseContinuationPoints: boolean): Promise<BrowseResult[]>;
-    public browseNext(...args: any[]): any {
+    public browseNext(...args: unknown[]): unknown {
         const arg0 = args[0];
         const isArray = Array.isArray(arg0);
         const releaseContinuationPoints = args[1] as boolean;
-        const callback: any = args[2];
+        const callback = args[2] as ResponseCallback<BrowseResult[] | BrowseResult>;
         assert(typeof callback === "function", "expecting a callback function here");
 
-        const continuationPoints: Buffer[] = isArray ? arg0 : [arg0 as Buffer];
+        const continuationPoints: Buffer[] = isArray ? (arg0 as Buffer[]) : [arg0 as Buffer];
 
         const request = new BrowseNextRequest({
             continuationPoints,
             releaseContinuationPoints
         });
 
-        this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
+        return this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err);
@@ -525,13 +565,13 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
      * @internal
      * @param args
      */
-    public readVariableValue(...args: any[]): any {
-        const callback = args[1];
+    public readVariableValue(...args: unknown[]): unknown {
+        const callback = args[1] as ResponseCallback<DataValue[] | DataValue>;
         assert(typeof callback === "function");
 
         const isArray = Array.isArray(args[0]);
 
-        const nodes = isArray ? args[0] : [args[0]];
+        const nodes: unknown[] = isArray ? (args[0] as unknown[]) : [args[0]];
 
         const nodesToRead = nodes.map(coerceReadValueId);
 
@@ -540,7 +580,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
             timestampsToReturn: TimestampsToReturn.Neither
         });
 
-        this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
+        return this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err);
@@ -631,33 +671,34 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
         end: DateTime,
         parameters: ExtraReadHistoryValueParameters
     ): Promise<HistoryReadResult>;
-    public readHistoryValue(...args: any[]): any {
-        const startTime = args[1];
-        const endTime = args[2];
+    public readHistoryValue(...args: unknown[]): unknown {
+        const startTime = args[1] as DateTime;
+        const endTime = args[2] as DateTime;
 
         let options: ExtraReadHistoryValueParameters = {};
         let callback = args[3];
         if (typeof callback !== "function") {
-            options = args[3];
+            options = args[3] as ExtraReadHistoryValueParameters;
             callback = args[4];
         }
         assert(typeof callback === "function");
+        const cb = callback as (err: Error | null, results?: HistoryReadResult[] | HistoryReadResult) => void;
 
         // adjust parameters
         options.numValuesPerNode = options.numValuesPerNode || 0;
-        options.returnBounds = options.returnBounds || options.returnBounds === undefined ? true : false;
+        options.returnBounds = !!(options.returnBounds || options.returnBounds === undefined);
         options.isReadModified = options.isReadModified || false;
         options.timestampsToReturn = options.timestampsToReturn ?? TimestampsToReturn.Both;
 
         const arg0 = args[0];
         const isArray = Array.isArray(arg0);
 
-        const nodes = isArray ? arg0 : [arg0];
+        const nodes: unknown[] = isArray ? (arg0 as unknown[]) : [arg0];
 
         const nodesToRead: HistoryReadValueIdOptions[] = [];
 
-        for (const node of nodes) {
-            if (!node.nodeId) {
+        for (const node of nodes as (NodeIdLike | HistoryReadValueIdOptions2)[]) {
+            if (!(node as HistoryReadValueIdOptions2).nodeId) {
                 nodesToRead.push({
                     continuationPoint: undefined,
                     dataEncoding: undefined, // {namespaceIndex: 0, name: undefined},
@@ -687,30 +728,30 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
         request.nodesToRead = request.nodesToRead || [];
 
         assert(nodes.length === request.nodesToRead.length);
-        this.historyRead(request, (err: Error | null, response?: HistoryReadResponse) => {
+        return this.historyRead(request, (err: Error | null, response?: HistoryReadResponse) => {
             /* c8 ignore next */
             if (err) {
-                return callback(err);
+                return cb(err);
             }
             /* c8 ignore next */
             if (!response || !(response instanceof HistoryReadResponse)) {
-                return callback(new Error("Internal Error"));
+                return cb(new Error("Internal Error"));
             }
             response.results = response.results || [];
             assert(nodes.length === response.results.length);
-            callback(null, isArray ? response.results : response.results[0]);
+            cb(null, isArray ? response.results : response.results[0]);
         });
     }
 
     public historyRead(request: HistoryReadRequest, callback: Callback<HistoryReadResponse>): void;
     public historyRead(request: HistoryReadRequest): Promise<HistoryReadResponse>;
-    public historyRead(request: HistoryReadRequest, callback?: CallbackT<HistoryReadResponse>): any {
+    public historyRead(request: HistoryReadRequest, callback?: CallbackT<HistoryReadResponse>): unknown {
         /* c8 ignore next */
         if (!callback) {
             throw new Error("expecting a callback");
         }
 
-        this.performMessageTransaction(request, (err: Error | null, response) => {
+        return this.performMessageTransaction(request, (err: Error | null, response) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err);
@@ -814,9 +855,9 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
         endTime: DateTime,
         aggregateFn: AggregateFunction[] | AggregateFunction,
         processingInterval: number,
-        ...args: any[]
-    ): any {
-        const callback = typeof args[0] === "function" ? args[0] : args[1];
+        ...args: unknown[]
+    ): unknown {
+        const callback = (typeof args[0] === "function" ? args[0] : args[1]) as Callback<HistoryReadResult[] | HistoryReadResult>;
         assert(typeof callback === "function");
         const defaultAggregateFunction = {
             percentDataBad: 100,
@@ -825,7 +866,9 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
             useServerCapabilitiesDefaults: true,
             useSlopedExtrapolation: false
         };
-        const aggregateConfiguration = typeof args[0] === "function" ? defaultAggregateFunction : args[0];
+        const aggregateConfiguration = (
+            typeof args[0] === "function" ? defaultAggregateFunction : args[0]
+        ) as AggregateConfigurationOptions;
 
         const isArray = Array.isArray(arg0);
 
@@ -854,8 +897,8 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
             timestampsToReturn: TimestampsToReturn.Both
         });
 
-        assert(nodesToRead.length === request.nodesToRead!.length);
-        this.performMessageTransaction(request, (err: Error | null, response) => {
+        assert(nodesToRead.length === request.nodesToRead?.length);
+        return this.performMessageTransaction(request, (err: Error | null, response) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err);
@@ -984,17 +1027,17 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
      * @internal
      * @param args
      */
-    public write(...args: any[]): any {
+    public write(...args: unknown[]): unknown {
         const arg0 = args[0];
         const isArray = Array.isArray(arg0);
-        const nodesToWrite = isArray ? arg0 : [arg0];
+        const nodesToWrite: WriteValueOptions[] = isArray ? (arg0 as WriteValueOptions[]) : [arg0 as WriteValueOptions];
 
-        const callback = args[1];
+        const callback = args[1] as (err: Error | null, results?: StatusCode[] | StatusCode | Response) => void;
         assert(typeof callback === "function");
 
         const request = new WriteRequest({ nodesToWrite });
 
-        this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
+        return this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err, response);
@@ -1051,10 +1094,10 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
 
     public writeSingleNode(nodeId: NodeIdLike, value: VariantLike): Promise<StatusCode>;
 
-    public writeSingleNode(...args: any[]): any {
+    public writeSingleNode(...args: unknown[]): unknown {
         const nodeId = args[0] as NodeIdLike;
         const value = args[1] as VariantLike;
-        const callback = args[2];
+        const callback = args[2] as ResponseCallback<StatusCode>;
 
         assert(typeof callback === "function");
 
@@ -1065,7 +1108,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
             value: new DataValue({ value })
         });
 
-        this.write(nodeToWrite, (err, statusCode) => {
+        return this.write(nodeToWrite, (err, statusCode) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err);
@@ -1100,11 +1143,11 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
 
     public readAllAttributes(nodes: NodeIdLike[], callback: (err: Error | null, data?: NodeAttributes[]) => void): void;
 
-    public readAllAttributes(...args: any[]): void {
+    public readAllAttributes(...args: unknown[]): void {
         const nodes = args[0] as NodeIdLike[];
         const callback = args[1] as (err: Error | null, data?: NodeAttributes[]) => void;
         readAllAttributes(this, nodes)
-            .then((data: any) => callback(null, data))
+            .then((data: NodeAttributes[]) => callback(null, data))
             .catch((err: Error) => callback(err));
     }
 
@@ -1172,28 +1215,31 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
      * @internal
      * @param args
      */
-    public read(...args: any[]): any {
+    public read(...args: unknown[]): unknown {
         if (args.length === 2) {
-            return this.read(args[0], 0, args[1]);
+            return this.read(args[0] as ReadValueIdOptions, 0, args[1] as ResponseCallback<DataValue>);
         }
         assert(args.length === 3);
 
         const isArray = Array.isArray(args[0]);
 
-        const nodesToRead = isArray ? args[0] : [args[0]];
+        const nodesToRead: ReadValueIdOptions[] = isArray ? (args[0] as ReadValueIdOptions[]) : [args[0] as ReadValueIdOptions];
 
         assert(Array.isArray(nodesToRead));
 
-        const maxAge = args[1];
+        const maxAge = args[1] as number;
 
-        const callback = args[2];
+        const callback = args[2] as (err: Error | null, results?: DataValue[] | DataValue | Response) => void;
         assert(typeof callback === "function");
 
         /* c8 ignore next */
         if (helpAPIChange) {
             // the read method deprecation detection and warning
             if (
-                !(getFunctionParameterNames(callback)[1] === "dataValues" || getFunctionParameterNames(callback)[1] === "dataValue")
+                !(
+                    getFunctionParameterNames(callback as unknown as (...args: unknown[]) => void)[1] === "dataValues" ||
+                    getFunctionParameterNames(callback as unknown as (...args: unknown[]) => void)[1] === "dataValue"
+                )
             ) {
                 warningLog(chalk.red("[NODE-OPCUA-E04] the ClientSession#read  API has changed !!, please fix the client code"));
                 warningLog(chalk.red("   replace ..:"));
@@ -1206,7 +1252,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
                         "please make sure to refactor your code and check that " +
                             "the second argument of your callback function is named"
                     ),
-                    chalk.cyan("dataValue" + (isArray ? "s" : ""))
+                    chalk.cyan(`dataValue${isArray ? "s" : ""}`)
                 );
                 warningLog(chalk.cyan("to make this exception disappear"));
                 throw new Error("ERROR ClientSession#read  API has changed !!, please fix the client code");
@@ -1215,7 +1261,9 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
 
         // coerce nodeIds
         for (const node of nodesToRead) {
-            node.nodeId = this.resolveNodeId(node.nodeId);
+            if (node.nodeId) {
+                node.nodeId = this.resolveNodeId(node.nodeId);
+            }
         }
 
         const request = new ReadRequest({
@@ -1224,7 +1272,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
             timestampsToReturn: TimestampsToReturn.Both
         });
 
-        this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
+        return this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err, response);
@@ -1236,7 +1284,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
             }
 
             // perform ExtensionObject resolution
-            promoteOpaqueStructure(this, response.results!)
+            promoteOpaqueStructure(this, response.results || [])
                 .then(() => {
                     response.results = response.results || /* c8 ignore next */ [];
                     callback(null, isArray ? response.results : response.results[0]);
@@ -1249,17 +1297,20 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
 
     public emitCloseEvent(statusCode: StatusCode): void {
         if (!this._closeEventHasBeenEmitted) {
-            debugLog("ClientSession#emitCloseEvent");
+            // c8 ignore next
+            doDebug && debugLog("ClientSession#emitCloseEvent");
             this._closeEventHasBeenEmitted = true;
             this.emit("session_closed", statusCode);
         }
     }
 
+    public createSubscription(options: CreateSubscriptionRequestLike, callback: ResponseCallback<CreateSubscriptionResponse>): void;
+    public createSubscription(options: CreateSubscriptionRequestLike): Promise<CreateSubscriptionResponse>;
     public createSubscription(
         options: CreateSubscriptionRequestLike,
         callback?: ResponseCallback<CreateSubscriptionResponse>
-    ): any {
-        this._defaultRequest(CreateSubscriptionRequest, CreateSubscriptionResponse, options, callback);
+    ): unknown {
+        return this._defaultRequest(CreateSubscriptionRequest, CreateSubscriptionResponse, options, callback);
     }
 
     /**
@@ -1279,12 +1330,11 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
         createSubscriptionRequest: CreateSubscriptionRequestLike,
         callback: (err: Error | null, subscription?: ClientSubscription) => void
     ): void;
-    public createSubscription2(...args: any[]): any {
+    public createSubscription2(...args: unknown[]): unknown {
         const createSubscriptionRequest = args[0] as CreateSubscriptionRequestLike;
-        let callback = args[1];
+        let callback = args[1] as ((err: Error | null, subscription?: ClientSubscription) => void) | null;
         const subscription = new ClientSubscriptionImpl(this, createSubscriptionRequest);
 
-        // tslint:disable-next-line:no-empty
         subscription.on("error", (err) => {
             if (callback) {
                 callback(err);
@@ -1298,17 +1348,18 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
                 callback = null;
             }
         });
+        return undefined;
     }
 
     public deleteSubscriptions(
         options: DeleteSubscriptionsRequestLike,
         callback?: ResponseCallback<DeleteSubscriptionsResponse>
-    ): any {
-        this._defaultRequest(DeleteSubscriptionsRequest, DeleteSubscriptionsResponse, options, callback);
+    ): unknown {
+        return this._defaultRequest(DeleteSubscriptionsRequest, DeleteSubscriptionsResponse, options, callback);
     }
 
-    public setTriggering(request: SetTriggeringRequestOptions, callback?: ResponseCallback<SetTriggeringResponse>): any {
-        this._defaultRequest(SetTriggeringRequest, SetTriggeringResponse, request, callback);
+    public setTriggering(request: SetTriggeringRequestOptions, callback?: ResponseCallback<SetTriggeringResponse>): unknown {
+        return this._defaultRequest(SetTriggeringRequest, SetTriggeringResponse, request, callback);
     }
 
     /**
@@ -1316,22 +1367,27 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
     public transferSubscriptions(
         options: TransferSubscriptionsRequestLike,
         callback?: ResponseCallback<TransferSubscriptionsResponse>
-    ): any {
-        this._defaultRequest(TransferSubscriptionsRequest, TransferSubscriptionsResponse, options, callback);
+    ): unknown {
+        return this._defaultRequest(TransferSubscriptionsRequest, TransferSubscriptionsResponse, options, callback);
     }
 
+    public createMonitoredItems(
+        options: CreateMonitoredItemsRequestLike,
+        callback: ResponseCallback<CreateMonitoredItemsResponse>
+    ): void;
+    public createMonitoredItems(options: CreateMonitoredItemsRequestLike): Promise<CreateMonitoredItemsResponse>;
     public createMonitoredItems(
         options: CreateMonitoredItemsRequestLike,
         callback?: ResponseCallback<CreateMonitoredItemsResponse>
-    ): any {
-        this._defaultRequest(CreateMonitoredItemsRequest, CreateMonitoredItemsResponse, options, callback);
+    ): unknown {
+        return this._defaultRequest(CreateMonitoredItemsRequest, CreateMonitoredItemsResponse, options, callback);
     }
 
     public modifyMonitoredItems(
         options: ModifyMonitoredItemsRequestLike,
         callback?: ResponseCallback<ModifyMonitoredItemsResponse>
-    ): any {
-        this._defaultRequest(ModifyMonitoredItemsRequest, ModifyMonitoredItemsResponse, options, callback);
+    ): unknown {
+        return this._defaultRequest(ModifyMonitoredItemsRequest, ModifyMonitoredItemsResponse, options, callback);
     }
 
     /**
@@ -1340,12 +1396,15 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
     public modifySubscription(
         options: ModifySubscriptionRequestLike,
         callback?: ResponseCallback<ModifySubscriptionResponse>
-    ): any {
-        this._defaultRequest(ModifySubscriptionRequest, ModifySubscriptionResponse, options, callback);
+    ): unknown {
+        return this._defaultRequest(ModifySubscriptionRequest, ModifySubscriptionResponse, options, callback);
     }
 
-    public setMonitoringMode(options: SetMonitoringModeRequestLike, callback?: ResponseCallback<SetMonitoringModeResponse>): any {
-        this._defaultRequest(SetMonitoringModeRequest, SetMonitoringModeResponse, options, callback);
+    public setMonitoringMode(
+        options: SetMonitoringModeRequestLike,
+        callback?: ResponseCallback<SetMonitoringModeResponse>
+    ): unknown {
+        return this._defaultRequest(SetMonitoringModeRequest, SetMonitoringModeResponse, options, callback);
     }
 
     /**
@@ -1389,11 +1448,11 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
     /**
      * @internal
      */
-    public setPublishingMode(...args: any[]): any {
-        const publishingEnabled = args[0];
+    public setPublishingMode(...args: unknown[]): unknown {
+        const publishingEnabled = args[0] as boolean;
         const isArray = Array.isArray(args[1]);
-        const subscriptionIds = isArray ? args[1] : [args[1]];
-        const callback = args[2];
+        const subscriptionIds: SubscriptionId[] = isArray ? (args[1] as SubscriptionId[]) : [args[1] as SubscriptionId];
+        const callback = args[2] as (err: Error | null, statusCode?: StatusCode[] | StatusCode) => void;
 
         assert(typeof callback === "function");
         assert(publishingEnabled === true || publishingEnabled === false);
@@ -1403,7 +1462,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
             subscriptionIds
         });
 
-        this._defaultRequest(
+        return this._defaultRequest(
             SetPublishingModeRequest,
             SetPublishingModeResponse,
             options,
@@ -1434,16 +1493,16 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
      * @internal
      * @param args
      */
-    public translateBrowsePath(...args: any[]): any {
+    public translateBrowsePath(...args: unknown[]): unknown {
         const isArray = Array.isArray(args[0]);
-        const browsePaths = isArray ? args[0] : [args[0]];
+        const browsePaths: BrowsePath[] = isArray ? (args[0] as BrowsePath[]) : [args[0] as BrowsePath];
 
-        const callback = args[1];
+        const callback = args[1] as (err: Error | null, results?: BrowsePathResult[] | BrowsePathResult | Response) => void;
         assert(typeof callback === "function");
 
         const request = new TranslateBrowsePathsToNodeIdsRequest({ browsePaths });
 
-        this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
+        return this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err, response);
@@ -1459,33 +1518,41 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
     }
 
     public channelId(): number {
-        return this._client !== null && this._client._secureChannel !== null && this._client._secureChannel.isOpened()
-            ? this._client._secureChannel!.channelId
-            : -1;
+        const secureChannel = this._client?._secureChannel;
+        return secureChannel?.isOpened() ? secureChannel.channelId : -1;
     }
     public isChannelValid(): boolean {
         /* c8 ignore next */
         if (!this._client) {
-            debugLog(chalk.red("Warning SessionClient is null ?"));
+            // c8 ignore next
+            doDebug && debugLog(chalk.red("Warning SessionClient is null ?"));
         }
 
-        return this._client !== null && this._client._secureChannel !== null && this._client._secureChannel.isOpened();
+        return !!this._client?._secureChannel?.isOpened();
     }
 
     public performMessageTransaction(request: Request, callback: (err: Error | null, response?: Response) => void): void {
         if (!this._client) {
             // session may have been closed by user ... but is still in used !!
-            return callback(new Error("Session has been closed and should not be used to perform a transaction anymore"));
+            callback(new Error("Session has been closed and should not be used to perform a transaction anymore"));
+            return;
         }
         if (
             request instanceof PublishRequest ||
             request instanceof ActivateSessionRequest ||
             request instanceof CloseSessionRequest
         ) {
-            return this._performMessageTransaction(request, callback);
+            this._performMessageTransaction(request, callback);
+            return;
         }
 
-        if (this._reconnecting.pendingTransactions.length > 0) {
+        // Hold the transaction only while the channel is genuinely down and a repair is under
+        // way. The repair restores the session *after* the secure channel is back up
+        // (_repairConnection: _recreate_secure_channel, then _finalReconnectionStep), so its own
+        // traffic - including the plain Read that readOperationLimits issues - always sees a
+        // valid channel and passes straight through. Queueing on "reconnecting" alone would
+        // park the repair's requests behind the repair that is waiting for them.
+        if (!this.isChannelValid() && (this._reconnecting.reconnecting || this._client.isReconnecting)) {
             /* c8 ignore next */
             if (this._reconnecting.pendingTransactions.length > 10) {
                 if (!pendingTransactionMessageDisplayed) {
@@ -1493,7 +1560,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
                     warningLog(
                         "[NODE-OPCUA-W21]",
                         "Pending transactions: ",
-                        this._reconnecting.pendingTransactions.map((a: any) => a.request.constructor.name).join(" ")
+                        this._reconnecting.pendingTransactions.map((a) => a.request.constructor.name).join(" ")
                     );
                     warningLog(
                         "[NODE-OPCUA-W22]",
@@ -1506,12 +1573,14 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
                     );
                 }
             } else if (this._reconnecting.pendingTransactions.length > 3) {
-                debugLog(
-                    chalk.yellow(
-                        "Warning : your client is sending multiple requests simultaneously to the server",
-                        request.constructor.name
-                    )
-                );
+                // c8 ignore next
+                doDebug &&
+                    debugLog(
+                        chalk.yellow(
+                            "Warning : your client is sending multiple requests simultaneously to the server",
+                            request.constructor.name
+                        )
+                    );
             }
             this._reconnecting.pendingTransactions.push({ request, callback });
             return;
@@ -1522,7 +1591,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
         attemptCount > 0 &&
             warningLog("reprocessRequest => ", request.constructor.name, this._reconnecting.pendingTransactions.length);
         this._performMessageTransaction(request, (err: null | Error, response?: Response) => {
-            if (err && err.message.match(/BadSessionIdInvalid/) && request.constructor.name !== "ActivateSessionRequest") {
+            if (err?.message.match(/BadSessionIdInvalid/) && request.constructor.name !== "ActivateSessionRequest") {
                 warningLog(
                     "Transaction on Invalid Session ",
                     request.constructor.name,
@@ -1534,62 +1603,105 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
                 );
                 request.requestHeader.requestHandle = requestHandleNotSetValue;
                 if (this.isReconnecting) {
-                    this.once("session_restored", () => {
-                        warningLog("redoing", request.constructor.name, this.isReconnecting);
-                        this.#reprocessRequest(attemptCount + 1, request, callback);
-                    });
+                    // Hand it back to the queue rather than parking it on a one-shot
+                    // session_restored listener: that event is emitted only when a repair
+                    // succeeds, so a repair that gave up - or a dispose, which drops every
+                    // listener - left the caller waiting for an answer that could never come.
+                    // flushPendingTransactions is called on every exit from a repair, so the
+                    // transaction is always resolved one way or the other.
+                    // c8 ignore next
+                    doDebug && debugLog("holding for replay after repair:", request.constructor.name, "attempt", attemptCount);
+                    this._reconnecting.pendingTransactions.push({ request, callback });
                 } else {
                     this.#_recreate_session_and_reperform_transaction(request, callback);
                 }
                 return;
             }
+            // the queue is owned by flushPendingTransactions, which the repair calls on every
+            // exit: draining one entry from here would send it before the session is restored,
+            // and would race with that flush.
             callback(err, response);
-            const length = this._reconnecting.pendingTransactions.length; // record length before callback is called !
-            if (length > 0) {
-                debugLog("reprocessRequest => ", this._reconnecting.pendingTransactions.length, " transaction(s) left in queue");
-                // tslint:disable-next-line: no-shadowed-variable
-                const { request, callback } = this._reconnecting.pendingTransactions.shift();
-                this.#reprocessRequest(0, request, callback);
-            }
         });
     }
 
+    /**
+     * record that the server has answered.
+     *
+     * A transaction that failed on a timeout or on a broken channel comes back with no response
+     * at all and must not refresh lastResponseReceivedTime, or the keep-alive manager would never
+     * notice that the server is gone (see #1569). A ServiceFault does count - the round trip
+     * completed - but the channel reports it as an Error carrying the decoded fault on
+     * err.response, so the response argument alone does not tell the two cases apart.
+     *
+     * @internal
+     */
+    /**
+     * resolve every transaction that was held while the connection was down: replay them when the
+     * session is usable again, fail them when the repair gave up.
+     *
+     * Every exit from a repair must call this, otherwise a held caller waits for an answer that
+     * can never come - and the session is disposed with a queue that nobody drained.
+     *
+     * @internal
+     */
+    public flushPendingTransactions(err: Error | null): void {
+        const heldTransactions = this._reconnecting.pendingTransactions.splice(0);
+        if (heldTransactions.length === 0) {
+            return;
+        }
+        // c8 ignore next
+        doDebug && debugLog("flushPendingTransactions", heldTransactions.length, err ? `failing: ${err.message}` : "replaying");
+        pendingTransactionMessageDisplayed = false;
+        for (const pending of heldTransactions) {
+            if (err) {
+                pending.callback(err);
+            } else {
+                this.#reprocessRequest(0, pending.request, pending.callback);
+            }
+        }
+    }
+
+    public noteServerAnswer(err: Error | null, response?: Response): void {
+        if (response || (err as ServiceFaultAnnotatedError)?.response) {
+            this.lastResponseReceivedTime = new Date();
+        }
+    }
+
     public _performMessageTransaction(request: Request, callback: (err: Error | null, response?: Response) => void): void {
         assert(typeof callback === "function");
 
         /* c8 ignore next */
         if (!this._client) {
             // session may have been closed by user ... but is still in used !!
-            return callback(new Error("Session has been closed and should not be used to perform a transaction anymore"));
+            callback(new Error("Session has been closed and should not be used to perform a transaction anymore"));
+            return;
         }
 
         if (!this.isChannelValid()) {
             // the secure channel is broken, may be the server has crashed or the network cable has been disconnected
             // for a long time
             // we may need to queue this transaction, as a secure token may be being reprocessed
-            debugLog(chalk.bgWhite.red("!!! Performing transaction on invalid channel !!! ", request.constructor.name));
-            return callback(new Error("Invalid Channel BadConnectionClosed"));
+            // c8 ignore next
+            doDebug && debugLog(chalk.bgWhite.red("!!! Performing transaction on invalid channel !!! ", request.constructor.name));
+            callback(new Error("Invalid Channel BadConnectionClosed"));
+            return;
         }
 
         // is this stuff useful?
         if (request.requestHeader) {
-            request.requestHeader.authenticationToken = this.authenticationToken!;
+            if (!this.authenticationToken) {
+                throw new Error("internal error: authenticationToken should be set on an active session");
+            }
+            request.requestHeader.authenticationToken = this.authenticationToken;
         }
 
         this.lastRequestSentTime = new Date();
 
         this._client.performMessageTransaction(request, (err: Error | null, response?: Response) => {
-            this.lastResponseReceivedTime = new Date();
+            this.noteServerAnswer(err, response);
 
-            /* c8 ignore next */
             if (err) {
-                if (response && response.responseHeader.serviceDiagnostics) {
-                    (err as any).serviceDiagnostics = response.responseHeader.serviceDiagnostics;
-                }
-                if (response && (response as any).diagnosticInfos) {
-                    (err as any).diagnosticsInfo = (response as any).diagnosticInfos;
-                }
-                return callback(err);
+                return callback(annotateWithDiagnostics(err, response));
             }
 
             /* c8 ignore next */
@@ -1597,22 +1709,14 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
                 return callback(new Error("internal Error"));
             }
 
-            /* c8 ignore next */
             if (response.responseHeader.serviceResult.isNot(StatusCodes.Good)) {
-                err = new Error(
+                const serviceResultError = new Error(
                     " ServiceResult is " +
                         response.responseHeader.serviceResult.toString() +
                         " request was " +
                         request.constructor.name
                 );
-
-                if (response && response.responseHeader.serviceDiagnostics) {
-                    (err as any).serviceDiagnostics = response.responseHeader.serviceDiagnostics;
-                }
-                if (response && (response as any).diagnosticInfos) {
-                    (err as any).diagnosticsInfo = (response as any).diagnosticInfos;
-                }
-                return callback(err, response);
+                return callback(annotateWithDiagnostics(serviceResultError, response), response);
             }
             return callback(null, response);
         });
@@ -1644,7 +1748,12 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
      */
     public evaluateRemainingLifetime(): number {
         const now = Date.now();
-        const expiryTime = this.lastRequestSentTime.getTime() + this.timeout;
+        // anchored on the last answer, not the last send: the server restarts its session
+        // watchdog when it *receives* a request, and the only proof the client has that a
+        // request arrived is an answer coming back. Anchoring on the send made this return a
+        // full lifetime throughout an outage - a client that keeps trying keeps refreshing the
+        // send timestamp - which is precisely when the caller needs the truth (see #1569).
+        const expiryTime = this.lastResponseReceivedTime.getTime() + this.timeout;
         return Math.max(0, expiryTime - now);
     }
 
@@ -1668,29 +1777,32 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
      * @internal
      * @param args
      */
-    public close(...args: any[]): any {
-        if (arguments.length === 1) {
-            return this.close(true, args[0]);
+    public close(...args: unknown[]): unknown {
+        if (args.length === 1) {
+            return this.close(true, args[0] as ErrorCallback);
         }
 
         const deleteSubscription = args[0];
-        const callback = args[1];
+        const callback = args[1] as ErrorCallback;
 
         assert(typeof callback === "function");
         assert(typeof deleteSubscription === "boolean");
 
         /* c8 ignore next */
         if (!this._client) {
-            debugLog("ClientSession#close : warning, client is already closed");
+            // c8 ignore next
+            doDebug && debugLog("ClientSession#close : warning, client is already closed");
             return callback(); // already close ?
         }
         assert(this._client);
 
         this._terminatePublishEngine();
-        this._client.closeSession(this, deleteSubscription, (err?: Error) => {
-            debugLog("session Close err ", err ? err.message : "null");
+        this._client.closeSession(this, deleteSubscription as boolean, (err?: Error) => {
+            // c8 ignore next
+            doDebug && debugLog("session Close err ", err ? err.message : "null");
             callback();
         });
+        return undefined;
     }
 
     /**
@@ -1709,12 +1821,14 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
      * @internal
      * @param args
      */
-    public call(...args: any[]): any {
+    public call(...args: unknown[]): unknown {
         const isArray = Array.isArray(args[0]);
-        const methodsToCall = isArray ? args[0] : [args[0]];
+        const methodsToCall: CallMethodRequestLike[] = isArray
+            ? (args[0] as CallMethodRequestLike[])
+            : [args[0] as CallMethodRequestLike];
         assert(Array.isArray(methodsToCall));
 
-        const callback = args[1];
+        const callback = args[1] as ResponseCallback<CallMethodResult[] | CallMethodResult>;
 
         // Note : The client has no explicit address space and therefore will struggle to
         //        access the method arguments signature.
@@ -1724,7 +1838,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
         // const request = this._client.factory.constructObjectId("CallRequest",{ methodsToCall: methodsToCall});
         const request = new CallRequest({ methodsToCall });
 
-        this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
+        return this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err);
@@ -1734,11 +1848,12 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
             if (!response || !(response instanceof CallResponse)) {
                 return callback(new Error("internal error"));
             }
-            response.results = response.results || [];
+            const results: CallMethodResult[] = response.results || [];
+            response.results = results;
 
-            promoteOpaqueStructureForCall(this, response.results)
+            promoteOpaqueStructureForCall(this, results)
                 .then(() => {
-                    callback(null, isArray ? response.results : response.results![0]);
+                    callback(null, isArray ? results : results[0]);
                 })
                 .catch((err) => {
                     callback(err);
@@ -1757,9 +1872,9 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
 
     public async getMonitoredItems(subscriptionId: SubscriptionId): Promise<MonitoredItemData>;
     public getMonitoredItems(subscriptionId: SubscriptionId, callback: ResponseCallback<MonitoredItemData>): void;
-    public getMonitoredItems(...args: any[]): any {
+    public getMonitoredItems(...args: unknown[]): unknown {
         const subscriptionId = args[0] as SubscriptionId;
-        const callback = args[1];
+        const callback = args[1] as ResponseCallback<MonitoredItemData>;
         // <UAObject NodeId="i=2253"  BrowseName="Server">
         // <UAMethod NodeId="i=11492" BrowseName="GetMonitoredItems"
         //                                         ParentNodeId="i=2253" MethodDeclarationId="i=11489">
@@ -1773,7 +1888,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
             objectId: coerceNodeId("ns=0;i=2253") // ObjectId.Server
         });
 
-        this.call(methodsToCall, (err?: Error | null, result?: CallMethodResult) => {
+        return this.call(methodsToCall, (err?: Error | null, result?: CallMethodResult) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err);
@@ -1816,13 +1931,13 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
     /**
      * @internal
      */
-    public getArgumentDefinition(...args: any[]): any {
+    public getArgumentDefinition(...args: unknown[]): unknown {
         const methodId = args[0] as MethodId;
         const callback = args[1] as ResponseCallback<ArgumentDefinition>;
         assert(typeof callback === "function");
         return getArgumentDefinitionHelper(this, methodId)
             .then((result) => {
-                callback!(null, result);
+                callback?.(null, result);
             })
             .catch((err) => {
                 callback(err);
@@ -1831,7 +1946,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
 
     public async registerNodes(nodesToRegister: NodeIdLike[]): Promise<NodeId[]>;
     public registerNodes(nodesToRegister: NodeIdLike[], callback: (err: Error | null, registeredNodeIds?: NodeId[]) => void): void;
-    public registerNodes(...args: any[]): any {
+    public registerNodes(...args: unknown[]): unknown {
         const nodesToRegister = args[0] as NodeIdLike[];
         const callback = args[1] as (err: Error | null, registeredNodeIds?: NodeId[]) => void;
 
@@ -1842,7 +1957,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
             nodesToRegister: nodesToRegister.map((n) => this.resolveNodeId(n))
         });
 
-        this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
+        return this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err);
@@ -1860,7 +1975,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
 
     public async unregisterNodes(nodesToUnregister: NodeIdLike[]): Promise<void>;
     public unregisterNodes(nodesToUnregister: NodeIdLike[], callback: (err?: Error) => void): void;
-    public unregisterNodes(...args: any[]): any {
+    public unregisterNodes(...args: unknown[]): unknown {
         const nodesToUnregister = args[0] as NodeIdLike[];
         const callback = args[1] as (err?: Error) => void;
 
@@ -1871,7 +1986,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
             nodesToUnregister: nodesToUnregister.map((n) => this.resolveNodeId(n))
         });
 
-        this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
+        return this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err);
@@ -1887,14 +2002,14 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
     public async queryFirst(queryFirstRequest: QueryFirstRequestLike): Promise<QueryFirstResponse>;
 
     public queryFirst(queryFirstRequest: QueryFirstRequestLike, callback: ResponseCallback<QueryFirstResponse>): void;
-    public queryFirst(...args: any[]): any {
+    public queryFirst(...args: unknown[]): unknown {
         const queryFirstRequest = args[0] as QueryFirstRequestLike;
         const callback = args[1] as ResponseCallback<QueryFirstResponse>;
 
         assert(typeof callback === "function");
         const request = new QueryFirstRequest(queryFirstRequest);
 
-        this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
+        return this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             /* c8 ignore next */
             if (err) {
                 return callback(err);
@@ -1944,11 +2059,8 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
         this.stopKeepAliveManager();
         this.removeAllListeners();
         //
-        const privateThis = this as any;
-        if (!(!privateThis.pendingTransactions || privateThis.pendingTransactions.length === 0)) {
-            // tslint:disable-next-line: no-console
-            warningLog("dispose when pendingTransactions is not empty ");
-        }
+        // never strand a held caller: the session is going away, so nothing will ever replay them
+        this.flushPendingTransactions(new Error("Session has been disposed while the transaction was waiting for reconnection"));
     }
 
     public toString(): string {
@@ -1959,41 +2071,43 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
 
         const timeoutInfo =
             timeoutDelay < 0
-                ? chalk.red(" expired since " + -timeoutDelay / 1000 + " seconds")
-                : chalk.green(" timeout in " + timeoutDelay / 1000 + " seconds");
+                ? chalk.red(` expired since ${-timeoutDelay / 1000} seconds`)
+                : chalk.green(` timeout in ${timeoutDelay / 1000} seconds`);
 
         let str = "";
-        str += " name..................... " + this.name;
-        str += "\n sessionId................ " + this.sessionId.toString();
-        str += "\n authenticationToken...... " + (this.authenticationToken ? this.authenticationToken!.toString() : "");
-        str += "\n timeout.................. " + this.timeout + "ms" + timeoutInfo;
-        str += "\n serverNonce.............. " + (this.serverNonce ? this.serverNonce!.toString("hex") : "");
-        str += "\n serverCertificate........ " + buffer_ellipsis(this.serverCertificate);
-        str += "\n serverSignature.......... " + this.serverSignature;
-        str += "\n lastRequestSentTime...... " + new Date(this.lastRequestSentTime).toISOString() + "  (" + lap1 + ")";
-        str += "\n lastResponseReceivedTime. " + new Date(this.lastResponseReceivedTime).toISOString() + " (" + lap2 + ")";
-        str += "\n isReconnecting........... " + this.isReconnecting;
-        str += "\n isValidChannel........... " + this.isChannelValid() + " has been closed  " + this.hasBeenClosed();
-        str += "\n channelId................ " + this.channelId();
-        str += "\n remaining life time...... " + this.evaluateRemainingLifetime();
-        str += "\n subscription count....... " + this.subscriptionCount;
-        if (this._client && this._client._secureChannel) {
+        str += ` name..................... ${this.name}`;
+        str += `\n sessionId................ ${this.sessionId.toString()}`;
+        str += `\n authenticationToken...... ${this.authenticationToken ? this.authenticationToken?.toString() : ""}`;
+        str += `\n timeout.................. ${this.timeout}ms${timeoutInfo}`;
+        str += `\n serverNonce.............. ${this.serverNonce ? this.serverNonce?.toString("hex") : ""}`;
+        str += `\n serverCertificate........ ${buffer_ellipsis(this.serverCertificate)}`;
+        str += `\n serverSignature.......... ${this.serverSignature}`;
+        str += `\n lastRequestSentTime...... ${new Date(this.lastRequestSentTime).toISOString()}  (${lap1})`;
+        str += `\n lastResponseReceivedTime. ${new Date(this.lastResponseReceivedTime).toISOString()} (${lap2})`;
+        str += `\n isReconnecting........... ${this.isReconnecting}`;
+        str += `\n isValidChannel........... ${this.isChannelValid()} has been closed  ${this.hasBeenClosed()}`;
+        str += `\n channelId................ ${this.channelId()}`;
+        str += `\n remaining life time...... ${this.evaluateRemainingLifetime()}`;
+        str += `\n subscription count....... ${this.subscriptionCount}`;
+        if (this._client?._secureChannel) {
             if (this._client._secureChannel.activeSecurityToken) {
-                str += "\n reviseTokenLifetime...... " + this._client._secureChannel.activeSecurityToken.revisedLifetime;
+                str += `\n reviseTokenLifetime...... ${this._client._secureChannel.activeSecurityToken.revisedLifetime}`;
             }
         }
-        str += "\n keepAlive ................ " + this._keepAliveManager ? true : false;
         if (this._keepAliveManager) {
-            str += "\n keepAlive checkInterval.. " + this._keepAliveManager.checkInterval + " ms";
-            str += "\n (defaultTransportTimeout)." + ClientSecureChannelLayer.defaultTransportTimeout + " ms";
-            str += "\n session timeout           " + this.timeout + " ms";
+            str += `\n keepAlive ................ ${this._keepAliveManager}`;
+            str += `\n keepAlive checkInterval.. ${this._keepAliveManager.checkInterval} ms`;
+            str += `\n (defaultTransportTimeout).${ClientSecureChannelLayer.defaultTransportTimeout} ms`;
+            str += `\n session timeout           ${this.timeout} ms`;
         }
         return str;
     }
 
-    public getBuiltInDataType(...args: any[]): any {
-        const nodeId = args[0];
-        const callback = args[1];
+    public getBuiltInDataType(nodeId: NodeId): Promise<DataType>;
+    public getBuiltInDataType(nodeId: NodeId, callback: (err: Error | null, dataType?: DataType) => void): void;
+    public getBuiltInDataType(...args: unknown[]): unknown {
+        const nodeId = args[0] as NodeId;
+        const callback = args[1] as (err: Error | null, dataType?: DataType) => void;
         return getBuiltInDataType(this, nodeId)
             .then((dataType: DataType) => callback(null, dataType))
             .catch(callback);
@@ -2001,21 +2115,24 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
 
     public async readNamespaceArray(): Promise<string[]>;
     public readNamespaceArray(callback: (err: Error | null, namespaceArray?: string[]) => void): void;
-    public readNamespaceArray(...args: any[]): any {
-        const callback = args[0];
+    public readNamespaceArray(...args: unknown[]): unknown {
+        const callback = args[0] as (err: Error | null, namespaceArray?: string[]) => void;
         readNamespaceArray(this)
             .then((namespaceArray) => callback(null, namespaceArray))
             .catch((err) => {
                 callback(err);
             });
+        return undefined;
     }
 
     public getNamespaceIndex(namespaceUri: string): number {
         assert(this.$$namespaceArray, "please make sure that readNamespaceArray has been called");
-        return this.$$namespaceArray!.indexOf(namespaceUri);
+        if (!this.$$namespaceArray) {
+            throw new Error("please make sure that readNamespaceArray has been called");
+        }
+        return this.$$namespaceArray.indexOf(namespaceUri);
     }
 
-    // tslint:disable:no-empty
     // ---------------------------------------- Alarm & condition stub
     public disableCondition(): void {
         /** empty */
@@ -2025,39 +2142,66 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
         /** empty */
     }
 
+    public addCommentCondition(
+        conditionId: NodeIdLike,
+        eventId: Buffer,
+        comment: LocalizedTextLike,
+        callback: Callback<StatusCode>
+    ): void;
+    public addCommentCondition(conditionId: NodeIdLike, eventId: Buffer, comment: LocalizedTextLike): Promise<StatusCode>;
     public addCommentCondition(
         _conditionId: NodeIdLike,
         _eventId: Buffer,
         _comment: LocalizedTextLike,
         _callback?: Callback<StatusCode>
-    ): any {
+    ): unknown {
         /** empty */
+        return undefined;
     }
 
+    public confirmCondition(
+        conditionId: NodeIdLike,
+        eventId: Buffer,
+        comment: LocalizedTextLike,
+        callback: Callback<StatusCode>
+    ): void;
+    public confirmCondition(conditionId: NodeIdLike, eventId: Buffer, comment: LocalizedTextLike): Promise<StatusCode>;
     public confirmCondition(
         _conditionId: NodeIdLike,
         _eventId: Buffer,
         _comment: LocalizedTextLike,
         _callback?: Callback<StatusCode>
-    ): any {
+    ): unknown {
         /** empty */
+        return undefined;
     }
 
+    public acknowledgeCondition(
+        conditionId: NodeId,
+        eventId: Buffer,
+        comment: LocalizedTextLike,
+        callback: Callback<StatusCode>
+    ): void;
+    public acknowledgeCondition(conditionId: NodeId, eventId: Buffer, comment: LocalizedTextLike): Promise<StatusCode>;
     public acknowledgeCondition(
         _conditionId: NodeId,
         _eventId: Buffer,
         _comment: LocalizedTextLike,
         _callback?: Callback<StatusCode>
-    ): any {
+    ): unknown {
         /** empty */
+        return undefined;
     }
 
     /**
      * @deprecated
      * @private
      */
-    public findMethodId(_nodeId: NodeIdLike, _methodName: string, _callback?: ResponseCallback<NodeId>): any {
+    public findMethodId(nodeId: NodeIdLike, methodName: string, callback: ResponseCallback<NodeId>): void;
+    public findMethodId(nodeId: NodeIdLike, methodName: string): Promise<NodeId>;
+    public findMethodId(_nodeId: NodeIdLike, _methodName: string, _callback?: ResponseCallback<NodeId>): unknown {
         /** empty */
+        return undefined;
     }
 
     public _callMethodCondition(
@@ -2081,41 +2225,53 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
      * @param dataType
      * @param pojo
      */
-    public async constructExtensionObject(dataType: NodeId, pojo: Record<string, any>): Promise<ExtensionObject> {
+    public async constructExtensionObject(dataType: NodeId, pojo: Record<string, unknown>): Promise<ExtensionObject> {
         const Constructor = await this.getExtensionObjectConstructor(dataType);
         return new Constructor(pojo);
     }
 
-    private _defaultRequest(requestClass: any, _responseClass: any, options: any, callback: any) {
+    private _defaultRequest<TRequestOptions, TResponse extends Response>(
+        requestClass: new (options: TRequestOptions) => Request,
+        _responseClass: unknown,
+        options: TRequestOptions,
+        callback?: (err: Error | null, response?: TResponse) => void
+    ): unknown {
         assert(typeof callback === "function");
+        if (!callback) {
+            throw new Error("_defaultRequest: expecting a callback function here");
+        }
 
-        const request = options instanceof requestClass ? options : new requestClass(options);
+        const request: Request = options instanceof requestClass ? options : new requestClass(options);
 
         /* c8 ignore next */
         if (doDebug) {
-            request.trace = new Error("").stack;
+            (request as unknown as { trace?: string }).trace = new Error("").stack;
         }
 
         /* c8 ignore next */
         if (this._closeEventHasBeenEmitted) {
-            debugLog("ClientSession#_defaultRequest => session has been closed !!", request.toString());
+            // c8 ignore next
+            doDebug && debugLog("ClientSession#_defaultRequest => session has been closed !!", request.toString());
             setImmediate(() => {
                 callback(new Error("ClientSession is closed !"));
             });
-            return;
+            return undefined;
         }
 
-        this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
+        return this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             if (this._closeEventHasBeenEmitted) {
-                debugLog(
-                    "ClientSession#_defaultRequest ... err =",
-                    err ? err.message : "null",
-                    response ? response.toString() : " null"
-                );
+                // c8 ignore next
+                doDebug &&
+                    debugLog(
+                        "ClientSession#_defaultRequest ... err =",
+                        err ? err.message : "null",
+                        response ? response.toString() : " null"
+                    );
             }
             /* c8 ignore next */
             if (err) {
-                debugLog("Client session : performMessageTransaction error = ", err.message);
+                // c8 ignore next
+                doDebug && debugLog("Client session : performMessageTransaction error = ", err.message);
                 // let intercept interesting error message
                 if (err.message.match(/BadSessionClosed/)) {
                     // the session has been closed by Server
@@ -2143,6 +2299,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
                     //  DO NOT TERMINATE SESSION, as we will need a publishEngine when we
                     //  reconnect this._terminatePublishEngine();
 
+                    // biome-ignore lint/correctness/noConstantCondition: deliberate debug on/off toggle, not dead code
                     if (false) {
                         // ER 10.2019
                         /**
@@ -2152,21 +2309,23 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession, Re
                         this.emitCloseEvent(StatusCodes.BadSessionClosed);
                     }
                 }
-                return callback(err, response);
+                return callback(err, response as TResponse | undefined);
             }
-            callback(null, response);
+            callback(null, response as TResponse | undefined);
         });
     }
     #_recreate_session_and_reperform_transaction(request: Request, callback: (err: Error | null, response?: Response) => void) {
         warningLog("attempt to recreate session to reperform a transaction ", request.constructor.name);
         if (this.recursive_repair_detector >= 1) {
-            // tslint:disable-next-line: no-console
             warningLog("recreate_session_and_reperform_transaction => Already in Progress");
             return callback(new Error("Cannot recreate session"));
         }
+        if (!this._client) {
+            return callback(new Error("Cannot recreate session: session has no client"));
+        }
         this.recursive_repair_detector += 1;
         warningLog(chalk.red("----------------> Repairing Client Session as Server believes it is invalid now "));
-        repair_client_session(this._client!, this, (err?: Error) => {
+        repair_client_session(this._client, this, (err?: Error) => {
             this.recursive_repair_detector -= 1;
             if (err) {
                 warningLog(chalk.red("----------------> session Repaired has failed with error", err.message));
@@ -2182,7 +2341,7 @@ async function promoteOpaqueStructureForCallMethodResult(
     session: IBasicSessionAsync2,
     callMethodResult: CallMethodResult
 ): Promise<void> {
-    if (!callMethodResult || !callMethodResult.outputArguments || callMethodResult.outputArguments.length === 0) {
+    if (!callMethodResult?.outputArguments || callMethodResult.outputArguments.length === 0) {
         return;
     }
     await promoteOpaqueStructure(
@@ -2217,8 +2376,6 @@ async function promoteOpaqueStructureForCall(session: IBasicSessionAsync2, callM
     await Promise.all(promises);
 }
 
-// tslint:disable:no-var-requires
-// tslint:disable:max-line-length
 import { withCallback } from "thenify-ex";
 
 const opts = { multiArgs: false };