appium-xcuitest-driver 10.14.0 → 10.14.2

package/lib/commands/{condition.js → condition.ts}

@@ -1,24 +1,25 @@
 import {INSTRUMENT_CHANNEL, services} from 'appium-ios-device';
 import _ from 'lodash';
 import { isIos18OrNewer } from '../utils';
+import type {XCUITestDriver} from '../driver';
+import type {DVTServiceWithConnection} from 'appium-ios-remotexpc';
+import type {Condition} from './types';
 
 /**
  * Get all available ConditionInducer configuration information, which can be used with
  * {@linkcode XCUITestDriver.enableConditionInducer}
- * @returns {Promise<Condition[]>}
  * @since 4.9.0
  * @see {@link https://help.apple.com/xcode/mac/current/#/dev308429d42}
- * @this {XCUITestDriver}
  */
-export async function listConditionInducers() {
+export async function listConditionInducers(this: XCUITestDriver): Promise<Condition[]> {
   requireConditionInducerCompatibleDevice.call(this);
 
   if (isIos18OrNewer(this.opts)) {
     const dvtConnection = await startRemoteXPC(this.device.udid);
     try {
       const result = await dvtConnection.conditionInducer.list();
-      return /** @type {Condition[]} */ (result);
-    } catch (err) {
+      return result as Condition[];
+    } catch (err: any) {
       this.log.error(`Failed to list condition inducers via RemoteXPC: ${err.message}`);
       throw err;
     } finally {
@@ -50,15 +51,18 @@ export async function listConditionInducers() {
  * (Note: the socket needs to remain connected during operation)
  * (Note: Device conditions are available only for real devices running iOS 13.0 and later.)
  *
- * @param {string} conditionID - Determine which condition IDs are available with the {@linkcode XCUITestDriver.listConditionInducers} command
- * @param {string} profileID - Determine which profile IDs are available with the {@linkcode XCUITestDriver.listConditionInducers} command
- * @returns {Promise<boolean>} `true` if enabling the condition succeeded
+ * @param conditionID - Determine which condition IDs are available with the {@linkcode XCUITestDriver.listConditionInducers} command
+ * @param profileID - Determine which profile IDs are available with the {@linkcode XCUITestDriver.listConditionInducers} command
+ * @returns `true` if enabling the condition succeeded
  * @throws {Error} If you try to start another Condition and the previous Condition has not stopped
  * @since 4.9.0
  * @see {@link https://help.apple.com/xcode/mac/current/#/dev308429d42}
- * @this {XCUITestDriver}
  */
-export async function enableConditionInducer(conditionID, profileID) {
+export async function enableConditionInducer(
+  this: XCUITestDriver,
+  conditionID: string,
+  profileID: string,
+): Promise<boolean> {
   requireConditionInducerCompatibleDevice.call(this);
 
   if (isIos18OrNewer(this.opts)) {
@@ -76,7 +80,7 @@ export async function enableConditionInducer(conditionID, profileID) {
 
       this.log.info(`Successfully enabled condition profile: ${profileID}`);
       return true;
-    } catch (err) {
+    } catch (err: any) {
       await closeRemoteXPC.call(this);
       throw this.log.errorWithException(`Condition inducer '${profileID}' cannot be enabled: '${err.message}'`);
     }
@@ -109,12 +113,11 @@ export async function enableConditionInducer(conditionID, profileID) {
  * condition inducer will be automatically disabled
  *
  * (Note: this is also automatically called upon session cleanup)
- * @returns {Promise<boolean>} `true` if disable the condition succeeded
+ * @returns `true` if disable the condition succeeded
  * @since 4.9.0
  * @see {@link https://help.apple.com/xcode/mac/current/#/dev308429d42}
- * @this {XCUITestDriver}
  */
-export async function disableConditionInducer() {
+export async function disableConditionInducer(this: XCUITestDriver): Promise<boolean> {
   requireConditionInducerCompatibleDevice.call(this);
 
   if (isIos18OrNewer(this.opts)) {
@@ -127,7 +130,7 @@ export async function disableConditionInducer() {
       await this._remoteXPCConditionInducerConnection.conditionInducer.disable();
       this.log.info('Successfully disabled condition inducer');
       return true;
-    } catch (err) {
+    } catch (err: any) {
       this.log.warn(`Failed to disable condition inducer via RemoteXPC: ${err.message}`);
       return false;
     } finally {
@@ -158,81 +161,22 @@ export async function disableConditionInducer() {
   }
 }
 
-/**
- * @this {XCUITestDriver}
- * @returns {void}
- */
-function requireConditionInducerCompatibleDevice() {
+function requireConditionInducerCompatibleDevice(this: XCUITestDriver): void {
   if (this.isSimulator()) {
     throw this.log.errorWithException('Condition inducer only works on real devices');
   }
 }
 
-/**
- * @param {string} udid
- * @returns {Promise<DVTServiceWithConnection>}
- */
-async function startRemoteXPC(udid) {
+async function startRemoteXPC(udid: string): Promise<DVTServiceWithConnection> {
   const {Services} = await import('appium-ios-remotexpc');
   return Services.startDVTService(udid);
 }
 
-/**
- * @this {XCUITestDriver}
- * @returns {Promise<void>}
- */
-async function closeRemoteXPC() {
+async function closeRemoteXPC(this: XCUITestDriver): Promise<void> {
   if (this._remoteXPCConditionInducerConnection) {
     await this._remoteXPCConditionInducerConnection.remoteXPC.close();
     this._remoteXPCConditionInducerConnection = null;
   }
 }
 
-/**
- * @typedef {import('appium-ios-remotexpc', {with: {'resolution-mode': 'import'}}).DVTServiceWithConnection} DVTServiceWithConnection
- */
-
-/**
- * @typedef {Object} Profile
- * @property {string} name
- * @property {string} identifier the property is profileID used in {@linkcode XCUITestDriver.enableConditionInducer}
- * @property {string} description Configuration details
- */
-
-/**
- * We can use the returned data to determine whether the Condition is enabled and the currently enabled configuration information
- * @typedef {Object} Condition
- * @property {Profile[]} profiles
- * @property {string} identifier the property is conditionID used in {@linkcode XCUITestDriver.enableConditionInducer}
- * @property {boolean} profilesSorted
- * @property {boolean} isDestructive
- * @property {boolean} isInternal
- * @property {boolean} isActive `true` if this condition identifier is enabled
- * @property {string} activeProfile  enabled profiles identifier
- * @example {
- *     "profiles": [
- *          {
- *             "name": "100% packet loss",
- *             "identifier": "SlowNetwork100PctLoss",  // MobileEnableConditionInducer profileID
- *             "description": "Name: 100% Loss Scenario\n
- *                             Downlink Bandwidth: 0 Mbps\n
- *                             Downlink Latency:0 ms\n
- *                             Downlink Packet Loss Ratio: 100%\n
- *                             Uplink Bandwidth: 0 Mbps\n
- *                             Uplink Latency: 0 ms\n
- *                             Uplink Packet Loss Ratio: 100%"
- *         }
- *     ],
- *     "profilesSorted": true,
- *     "identifier": "SlowNetworkCondition",    // MobileEnableConditionInducer conditionID
- *     "isDestructive": false,
- *     "isInternal": false,
- *     "activeProfile": "",
- *     "name": "Network Link",
- *     "isActive": false
- * }
- */
 
-/**
- * @typedef {import('../driver').XCUITestDriver} XCUITestDriver
- */

package/lib/commands/{execute.js → execute.ts}

@@ -2,14 +2,18 @@ import _ from 'lodash';
 import {XCUITestDriver} from '../driver';
 import {errors, errorFromCode, errorFromW3CJsonCode} from 'appium/driver';
 import {util} from 'appium/support';
+import type {Element, StringRecord} from '@appium/types';
 
 /**
  * Collect the response of an async script execution
- * @this {XCUITestDriver}
  * @deprecated
  * @privateRemarks It's unclear what this is for. Don't use it.
  */
-export async function receiveAsyncResponse(status, value) {
+export async function receiveAsyncResponse(
+  this: XCUITestDriver,
+  status: number | null | undefined,
+  value: any,
+): Promise<void> {
   this.log.debug(`Received async response: ${JSON.stringify(value)}`);
   if (!util.hasValue(this.asyncPromise)) {
     this.log.warn(
@@ -33,21 +37,22 @@ export async function receiveAsyncResponse(status, value) {
 }
 
 /**
- * @template {ExecuteMethodArgs} [TArgs = unknown[]]
- * @template [TReturn = unknown]
- * @param {string} script - Either a script to run, or in the case of an Execute Method, the name of the script to execute.
- * @param {TArgs} [args]
- * @this {XCUITestDriver}
- * @returns {Promise<TReturn>}
+ * @template TReturn
+ * @param script - Either a script to run, or in the case of an Execute Method, the name of the script to execute.
+ * @param args
  */
-export async function execute(script, args) {
+export async function execute<TReturn = unknown>(
+  this: XCUITestDriver,
+  script: string,
+  args?: ExecuteMethodArgs,
+): Promise<TReturn> {
   // TODO: create a type that converts args to the parameters of the associated method using the `command` prop of `executeMethodMap`
   script = script.trim().replace(/^mobile:\s*/, 'mobile: ');
   if (isExecuteMethod(script)) {
-    const executeMethodArgs = preprocessExecuteMethodArgs(script, args);
+    const executeMethodArgs = preprocessExecuteMethodArgs(script, args as ExecuteMethodArgs | undefined);
     return await this.executeMethod(script, [executeMethodArgs]);
   } else if (this.isWebContext()) {
-    const atomsArgs = this.convertElementsForAtoms(/** @type {readonly any[]} */ (args));
+    const atomsArgs = this.convertElementsForAtoms(args as readonly any[] | undefined);
     const result = await this.executeAtom('execute_script', [script, atomsArgs]);
     return this.cacheWebElements(result);
   } else {
@@ -56,10 +61,13 @@ export async function execute(script, args) {
 }
 
 /**
- * @this {XCUITestDriver}
  * @group Mobile Web Only
  */
-export async function executeAsync(script, args) {
+export async function executeAsync(
+  this: XCUITestDriver,
+  script: string,
+  args?: readonly any[],
+): Promise<any> {
   if (!this.isWebContext()) {
     throw new errors.NotImplementedError();
   }
@@ -77,16 +85,17 @@ export async function executeAsync(script, args) {
 
 /**
  * Checks if script expects a particular parameter (either optional or required).
- * @template {keyof XCUITestDriver.executeMethodMap} Script
- * @param {Script} script - Script name
- * @param {string} param - Parameter name
+ * @template Script
+ * @param script - Script name
+ * @param param - Parameter name
  * @returns {boolean}
  */
-function executeMethodExpectsParam(script, param) {
-  /** @type {ReadonlyArray<string>|undefined} */
-  let required;
-  /** @type {ReadonlyArray<string>|undefined} */
-  let optional;
+function executeMethodExpectsParam<Script extends keyof typeof XCUITestDriver.executeMethodMap>(
+  script: Script,
+  param: string,
+): boolean {
+  let required: ReadonlyArray<string> | undefined;
+  let optional: ReadonlyArray<string> | undefined;
   const execMethodDef = XCUITestDriver.executeMethodMap[script];
   if ('params' in execMethodDef) {
     if ('required' in execMethodDef.params) {
@@ -101,24 +110,26 @@ function executeMethodExpectsParam(script, param) {
 }
 
 /**
- * @param {any} script
+ * @param script
  * @returns {script is keyof XCUITestDriver.executeMethodMap}
  */
-function isExecuteMethod(script) {
+function isExecuteMethod(script: string): script is keyof typeof XCUITestDriver.executeMethodMap {
   return script in XCUITestDriver.executeMethodMap;
 }
 
 /**
  * Massages the arguments going into an execute method.
- * @param {keyof XCUITestDriver.executeMethodMap} script
- * @param {ExecuteMethodArgs} [args]
- * @returns {StringRecord<unknown>}
+ * @param script
+ * @param args
  */
-function preprocessExecuteMethodArgs(script, args) {
+function preprocessExecuteMethodArgs(
+  script: keyof typeof XCUITestDriver.executeMethodMap,
+  args?: ExecuteMethodArgs,
+): StringRecord<unknown> {
   if (_.isArray(args)) {
     args = _.first(args);
   }
-  const executeMethodArgs = /** @type {StringRecord<unknown>} */ (args ?? {});
+  const executeMethodArgs = (args ?? {}) as StringRecord<unknown>;
   /**
    * Renames the deprecated `element` key to `elementId`.  Historically,
    * all of the pre-Execute-Method-Map execute methods accepted an `element` _or_ and `elementId` param.
@@ -136,18 +147,11 @@ function preprocessExecuteMethodArgs(script, args) {
    */
   if ('elementId' in executeMethodArgs && executeMethodExpectsParam(script, 'elementId')) {
     executeMethodArgs.elementId = util.unwrapElement(
-      /** @type {import('@appium/types').Element|string} */ (executeMethodArgs.elementId),
+      executeMethodArgs.elementId as Element<string> | string,
     );
   }
 
   return executeMethodArgs;
 }
 
-/**
- * @template [T=any]
- * @typedef {import('@appium/types').StringRecord<T>} StringRecord
- */
-
-/**
- * @typedef {readonly any[] | readonly [StringRecord] | Readonly<StringRecord>} ExecuteMethodArgs
- */
+type ExecuteMethodArgs = readonly any[] | readonly [StringRecord<unknown>] | Readonly<StringRecord<unknown>>;

package/lib/commands/{location.js → location.ts}

@@ -3,6 +3,10 @@ import {errors} from 'appium/driver';
 import {util} from 'appium/support';
 import {AuthorizationStatus} from './enum';
 import { isIos17OrNewer } from '../utils';
+import type {XCUITestDriver} from '../driver';
+import type {Location} from '@appium/types';
+import type {LocationWithAltitude, WDALocationInfo} from './types';
+import type {Simulator} from 'appium-ios-simulator';
 
 /**
  * Returns location of the device under test.
@@ -17,12 +21,11 @@ import { isIos17OrNewer } from '../utils';
  * "mobile:getSimulatedLocation" if the simulated location has been previously set
  * "mobile:setSimulatedLocation" already.
  *
- * @returns {Promise<import('./types').LocationWithAltitude>}
+ * @returns Location with altitude
  * @throws {Error} If the device under test returns an error message.
  *                 i.e.: tvOS returns unsupported error
- * @this {XCUITestDriver}
  */
-export async function getGeoLocation() {
+export async function getGeoLocation(this: XCUITestDriver): Promise<LocationWithAltitude> {
   // Currently we proxy the setGeoLocation to mobile:setSimulatedLocation for iOS 17+.
   // It would be helpful to address to use "mobile:getSimulatedLocation" for iOS 17+.
   if (isIos17OrNewer(this.opts)) {
@@ -41,9 +44,7 @@ export async function getGeoLocation() {
   // '/wda/device/location' returns current device location information,
   // but '/wda/simulatedLocation' returns `null` values until the WDA process
   // sets a simulated location. After setting the value, both returns the same values.
-  const {authorizationStatus, latitude, longitude, altitude} = /** @type {WDALocationInfo} */ (
-    await this.proxyCommand('/wda/device/location', 'GET')
-  );
+  const {authorizationStatus, latitude, longitude, altitude} = await this.proxyCommand('/wda/device/location', 'GET') as WDALocationInfo;
 
   // '3' is 'Always' in the privacy
   // https://developer.apple.com/documentation/corelocation/clauthorizationstatus
@@ -66,19 +67,21 @@ export async function getGeoLocation() {
  * iOS 17+ real device environment will be via "mobile:setSimulatedLocation" as
  * setting simulated location for XCTest session.
  *
- * @param {Partial<Location>} location
- * @this {XCUITestDriver}
+ * @param location - Location with latitude and longitude
  */
-export async function setGeoLocation(location) {
-  let {latitude, longitude} = location;
+export async function setGeoLocation(
+  this: XCUITestDriver,
+  location: Partial<Location>,
+): Promise<Location> {
+  const {latitude, longitude} = location;
 
   if (!util.hasValue(latitude) || !util.hasValue(longitude)) {
     throw new errors.InvalidArgumentError(`Both latitude and longitude should be set`);
   }
 
   if (this.isSimulator()) {
-    await /** @type {import('appium-ios-simulator').Simulator} */ (this.device).setGeolocation(`${latitude}`, `${longitude}`);
-    return /** @type {Location} */ ({latitude, longitude, altitude: 0});
+    await (this.device as Simulator).setGeolocation(`${latitude}`, `${longitude}`);
+    return {latitude, longitude, altitude: 0};
   }
 
   if (isIos17OrNewer(this.opts)) {
@@ -88,7 +91,7 @@ export async function setGeoLocation(location) {
     const service = await services.startSimulateLocationService(this.opts.udid);
     try {
       service.setLocation(latitude, longitude);
-    } catch (e) {
+    } catch (e: any) {
       throw this.log.errorWithException(
         `Can't set the location on device '${this.opts.udid}'. Original error: ${e.message}`,
       );
@@ -97,7 +100,7 @@ export async function setGeoLocation(location) {
     }
   }
 
-  return /** @type {Location} */ ({latitude, longitude, altitude: 0});
+  return {latitude, longitude, altitude: 0};
 }
 
 /**
@@ -105,9 +108,8 @@ export async function setGeoLocation(location) {
  *
  * @throws {Error} If the device is simulator and iOS version is below 17,
  * or 'resetLocation' raises an error.
- * @this {XCUITestDriver}
  */
-export async function mobileResetLocationService() {
+export async function mobileResetLocationService(this: XCUITestDriver): Promise<void> {
   if (isIos17OrNewer(this.opts)) {
     this.log.info(`Proxying to mobile:resetSimulatedLocation method for iOS 17+`);
     await this.mobileResetSimulatedLocation();
@@ -121,7 +123,7 @@ export async function mobileResetLocationService() {
   const service = await services.startSimulateLocationService(this.opts.udid);
   try {
     service.resetLocation();
-  } catch (err) {
+  } catch (err: any) {
     throw this.log.errorWithException(
       `Failed to reset the location on the device on device '${this.opts.udid}'. ` +
         `Original error: ${err.message}`,
@@ -131,8 +133,3 @@ export async function mobileResetLocationService() {
   }
 }
 
-/**
- * @typedef {import('../driver').XCUITestDriver} XCUITestDriver
- * @typedef {import('./types').WDALocationInfo} WDALocationInfo
- * @typedef {import('@appium/types').Location} Location
- */

package/lib/commands/{navigation.js → navigation.ts}

@@ -1,15 +1,17 @@
 import {errors} from 'appium/driver';
 import {waitForCondition} from 'asyncbox';
 import { isTvOs } from '../utils';
+import type {XCUITestDriver} from '../driver';
+import type {Element} from '@appium/types';
 
 // these two constitute the wait after closing a window
 const CLOSE_WINDOW_TIMEOUT = 5000;
 const CLOSE_WINDOW_INTERVAL = 100;
 
 /**
- * @this {XCUITestDriver}
+ * Navigate back in the browser history or native app navigation.
  */
-export async function back() {
+export async function back(this: XCUITestDriver): Promise<void> {
   if (!this.isWebContext()) {
     await this.nativeBack();
   } else {
@@ -18,18 +20,22 @@ export async function back() {
 }
 
 /**
- * @this {XCUITestDriver}
+ * Navigate forward in the browser history.
  */
-export async function forward() {
+export async function forward(this: XCUITestDriver): Promise<void> {
   if (!this.isWebContext()) {
+    // No-op for native context
+    return;
   }
   await this.mobileWebNav('forward');
 }
 
 /**
- * @this {XCUITestDriver}
+ * Closes the current window in a web context.
+ *
+ * @returns Promise that resolves when the window is closed
  */
-export async function closeWindow() {
+export async function closeWindow(this: XCUITestDriver): Promise<any> {
   if (!this.isWebContext()) {
     throw new errors.NotImplementedError();
   }
@@ -59,14 +65,16 @@ export async function closeWindow() {
  *
  * (Note: the version of Xcode must be 14.3+ and iOS must be 16.4+)
  *
- * @param {string} url - the URL to be opened, e.g. `myscheme://yolo`
- * @param {string} [bundleId] - the application to open the given URL with. If not provided, then
+ * @param url - the URL to be opened, e.g. `myscheme://yolo`
+ * @param bundleId - the application to open the given URL with. If not provided, then
  * the application assigned by the operating system to handle URLs of the appropriate type
- * @returns {Promise<void>}
  * @since 4.17
- * @this {XCUITestDriver}
  */
-export async function mobileDeepLink(url, bundleId) {
+export async function mobileDeepLink(
+  this: XCUITestDriver,
+  url: string,
+  bundleId?: string,
+): Promise<void> {
   return await this.proxyCommand('/url', 'POST', {
     url,
     bundleId,
@@ -74,9 +82,9 @@ export async function mobileDeepLink(url, bundleId) {
 }
 
 /**
- * @this {XCUITestDriver}
+ * Navigate back in native app navigation by finding and clicking the back button.
  */
-export async function nativeBack() {
+export async function nativeBack(this: XCUITestDriver): Promise<void> {
   if (isTvOs(this.opts.platformName)) {
     this.log.debug(`Sending Menu button as back behavior in tvOS`);
     return await this.mobilePressButton('Menu');
@@ -88,7 +96,7 @@ export async function nativeBack() {
       'XCUIElementTypeNavigationBar',
       false,
     );
-    let dstButton;
+    let dstButton: Element<string>;
     const backButtons = await this.findNativeElementOrElements(
       '-ios predicate string',
       'type == "XCUIElementTypeButton" AND label == "Back"',
@@ -113,19 +121,8 @@ export async function nativeBack() {
     }
 
     await this.nativeClick(dstButton);
-  } catch (err) {
+  } catch (err: any) {
     this.log.error(`Unable to find navigation bar and back button: ${err.message}`);
   }
 }
 
-/**
- * @typedef {import('../driver').XCUITestDriver} XCUITestDriver
- */
-
-/**
- * @typedef {Object} DeepLinkOptions
- * @property {string} url The URL to be opened. This parameter is manadatory
- * @property {string?} bundleId The bundle identifier of an application to open the
- * given url with. If not provided then the default application for the given url scheme
- * is going to be used.
- */

package/lib/commands/{pcap.js → pcap.ts}

@@ -2,27 +2,29 @@ import { Pyidevice } from '../device/clients/py-ios-device-client';
 import {fs, tempDir, util} from 'appium/support';
 import {encodeBase64OrUpload} from '../utils';
 import {errors} from 'appium/driver';
+import type {XCUITestDriver} from '../driver';
+import type {SubProcess} from 'teen_process';
 
 const MAX_CAPTURE_TIME_SEC = 60 * 60 * 12;
 const DEFAULT_EXT = '.pcap';
 
 export class TrafficCapture {
-  /** @type {import('teen_process').SubProcess|null} */
-  mainProcess;
-  constructor(udid, log, resultPath) {
+  private mainProcess: SubProcess | null = null;
+  private readonly udid: string;
+  private readonly log: any;
+  private readonly resultPath: string;
+
+  constructor(udid: string, log: any, resultPath: string) {
     this.udid = udid;
     this.log = log;
     this.resultPath = resultPath;
-    this.mainProcess = null;
   }
 
-  async start(timeoutSeconds) {
-    this.mainProcess = /** @type {import('teen_process').SubProcess} */ (
-      await new Pyidevice({
-        udid: this.udid,
-        log: this.log,
-      }).collectPcap(this.resultPath)
-    );
+  async start(timeoutSeconds: number): Promise<void> {
+    this.mainProcess = await new Pyidevice({
+      udid: this.udid,
+      log: this.log,
+    }).collectPcap(this.resultPath);
     this.mainProcess.on('line-stderr', (line) => this.log.info(`[Pcap] ${line}`));
     this.log.info(
       `Starting network traffic capture session on the device '${this.udid}'. ` +
@@ -37,17 +39,17 @@ export class TrafficCapture {
     });
   }
 
-  isCapturing() {
+  isCapturing(): boolean {
     return !!this.mainProcess?.isRunning;
   }
 
-  async interrupt(force = false) {
+  async interrupt(force = false): Promise<boolean> {
     if (this.isCapturing()) {
       const interruptPromise = this.mainProcess?.stop(force ? 'SIGTERM' : 'SIGINT');
       this.mainProcess = null;
       try {
         await interruptPromise;
-      } catch (e) {
+      } catch (e: any) {
         this.log.warn(
           `Cannot ${force ? 'terminate' : 'interrupt'} the traffic capture session. ` +
             `Original error: ${e.message}`,
@@ -59,12 +61,12 @@ export class TrafficCapture {
     return true;
   }
 
-  async finish() {
+  async finish(): Promise<string> {
     await this.interrupt();
     return this.resultPath;
   }
 
-  async cleanup() {
+  async cleanup(): Promise<void> {
     if (await fs.exists(this.resultPath)) {
       await fs.rimraf(this.resultPath);
     }
@@ -74,13 +76,15 @@ export class TrafficCapture {
 /**
  * Records the given network traffic capture into a .pcap file.
  *
- * @param {number} timeLimitSec - The maximum recording time, in seconds. The maximum value is `43200` (12 hours).
- * @param {boolean} forceRestart - Whether to restart traffic capture process forcefully when startPcap is called (`true`) or ignore the call until the current traffic capture is completed (`false`, the default value).
+ * @param timeLimitSec - The maximum recording time, in seconds. The maximum value is `43200` (12 hours).
+ * @param forceRestart - Whether to restart traffic capture process forcefully when startPcap is called (`true`) or ignore the call until the current traffic capture is completed (`false`, the default value).
  * @throws {Error} If network traffic capture has failed to start.
- * @returns {Promise<void>}
- * @this {XCUITestDriver}
  */
-export async function mobileStartPcap(timeLimitSec = 180, forceRestart = false) {
+export async function mobileStartPcap(
+  this: XCUITestDriver,
+  timeLimitSec = 180,
+  forceRestart = false,
+): Promise<void> {
   if (this.isSimulator()) {
     throw this.log.errorWithException('Network traffic capture only works on real devices');
   }
@@ -135,17 +139,16 @@ export async function mobileStartPcap(timeLimitSec = 180, forceRestart = false)
  * If no previously recorded file is found and no active traffic capture processes are running, then the method returns an empty string.
  *
  * @remarks Network capture files can be viewed in [Wireshark](https://www.wireshark.org/) and other similar applications.
- * @returns {Promise<string>} Base64-encoded content of the recorded pcap file or an empty string if no traffic capture has been started before.
+ * @returns Base64-encoded content of the recorded pcap file or an empty string if no traffic capture has been started before.
  * @throws {Error} If there was an error while getting the capture file.
- * @this {XCUITestDriver}
  */
-export async function mobileStopPcap() {
+export async function mobileStopPcap(this: XCUITestDriver): Promise<string> {
   if (!this._trafficCapture) {
     this.log.info('Network traffic collector has not been started. There is nothing to stop');
     return '';
   }
 
-  let resultPath;
+  let resultPath: string;
   try {
     resultPath = await this._trafficCapture.finish();
     if (!(await fs.exists(resultPath))) {
@@ -163,6 +166,3 @@ export async function mobileStopPcap() {
   return await encodeBase64OrUpload(resultPath);
 }
 
-/**
- * @typedef {import('../driver').XCUITestDriver} XCUITestDriver
- */