appium-xcuitest-driver 10.14.1 → 10.14.3

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
- */

package/lib/commands/permissions.ts

@@ -0,0 +1,90 @@
+import _ from 'lodash';
+import {PermissionService} from './enum';
+import {assertSimulator as _assertSimulator} from '../utils';
+import type {XCUITestDriver} from '../driver';
+import type {PermissionState} from './types';
+import type {Simulator} from 'appium-ios-simulator';
+
+/**
+ * Resets the given permission for the active application under test.
+ * Works for both Simulator and real devices using Xcode SDK 11.4+
+ *
+ * @param service - One of the available service names. This could also be an integer protected resource identifier; see [this list](https://developer.apple.com/documentation/xctest/xcuiprotectedresource?language=objc)
+ * @throws If permission reset fails on the device.
+ */
+export async function mobileResetPermission(
+  this: XCUITestDriver,
+  service: PermissionService | number,
+): Promise<void> {
+  if (!service) {
+    throw new Error(`The 'service' option is expected to be present`);
+  }
+  let resource: number;
+  if (_.isString(service)) {
+    resource = PermissionService[_.toLower(service) as keyof typeof PermissionService];
+    if (!resource) {
+      throw new Error(
+        `The 'service' value must be one of ` + `${JSON.stringify(_.keys(PermissionService))}`,
+      );
+    }
+  } else if (_.isInteger(service)) {
+    resource = service;
+  } else {
+    throw new Error(
+      `The 'service' value must be either a string or an integer. ` +
+        `'${service}' is passed instead`,
+    );
+  }
+
+  await this.proxyCommand('/wda/resetAppAuth', 'POST', {resource});
+}
+
+/**
+ * Gets application permission state on a simulated device.
+ *
+ * **This method requires [WIX applesimutils](https://github.com/wix/AppleSimulatorUtils) to be installed on the Appium server host.**
+ *
+ * @param bundleId - Bundle identifier of the target application
+ * @param service - Service name
+ * @returns Either 'yes', 'no', 'unset' or 'limited'
+ * @throws If permission getting fails or the device is not a Simulator.
+ * @group Simulator Only
+ */
+export async function mobileGetPermission(
+  this: XCUITestDriver,
+  bundleId: string,
+  service: PermissionService,
+): Promise<PermissionState> {
+  if (!service) {
+    throw new Error(`The 'service' option is expected to be present`);
+  }
+  assertSimulator(this);
+
+  return await (this.device as Simulator).getPermission(
+    bundleId, String(service)
+  ) as PermissionState;
+}
+
+/**
+ * Set application permission state on Simulator.
+ *
+ * @param access - One or more access rules to set.
+ * @param bundleId - Bundle identifier of the target application
+ * @since Xcode SDK 11.4
+ * @throws If permission setting fails or the device is not a Simulator.
+ * @group Simulator Only
+ */
+export async function mobileSetPermissions(
+  this: XCUITestDriver,
+  access: Record<string, PermissionState>,
+  bundleId: string,
+): Promise<void> {
+  if (!_.isPlainObject(access)) {
+    throw new Error(`The 'access' option is expected to be a map`);
+  }
+  assertSimulator(this);
+
+  await (this.device as Simulator).setPermissions(bundleId, access);
+}
+
+const assertSimulator = (driver: XCUITestDriver) => _assertSimulator.call(driver, 'Permission-related operations');

package/lib/commands/{proxy-helper.js → proxy-helper.ts}

@@ -1,12 +1,13 @@
 import {errors, routeToCommandName} from 'appium/driver';
 import B from 'bluebird';
+import type {XCUITestDriver} from '../driver';
 
 const GET = 'GET';
 const POST = 'POST';
 const DELETE = 'DELETE';
-const SUPPORTED_METHODS = Object.freeze(new Set(/** @type {const} */ ([GET, POST, DELETE])));
+const SUPPORTED_METHODS = Object.freeze(new Set([GET, POST, DELETE] as const));
 
-const WDA_ROUTES = /** @type {const} */ ({
+const WDA_ROUTES = {
   '/wda/screen': {
     GET: 'getScreenInfo',
   },
@@ -43,22 +44,30 @@ const WDA_ROUTES = /** @type {const} */ ({
   '/wda/locked': {
     GET: 'isLocked',
   },
-});
+} as const;
+
+export type AllowedHttpMethod = 'GET' | 'POST' | 'DELETE';
 
 /**
  * Proxies a command to WebDriverAgent
- * @template [TReq=any]
- * @template [TRes=unknown]
- * @param {string} url
- * @param {AllowedHttpMethod} method
- * @param {TReq} [body]
- * @param {boolean} isSessionCommand
- * @this {import('../driver').XCUITestDriver}
- * @returns {Promise<TRes>}
+ *
+ * @template TReq - Request body type
+ * @template TRes - Response type
+ * @param url - The endpoint URL
+ * @param method - HTTP method to use
+ * @param body - Optional request body
+ * @param isSessionCommand - Whether this is a session command (default: true)
+ * @returns Promise resolving to the response
  */
-export async function proxyCommand(url, method, body, isSessionCommand = true) {
+export async function proxyCommand<TReq = any, TRes = unknown>(
+  this: XCUITestDriver,
+  url: string,
+  method: AllowedHttpMethod,
+  body?: TReq,
+  isSessionCommand: boolean = true,
+): Promise<TRes> {
   if (this.shutdownUnexpectedly) {
-    return /** @type {TRes} */ (undefined);
+    return undefined as TRes;
   }
 
   if (!url) {
@@ -83,12 +92,12 @@ export async function proxyCommand(url, method, body, isSessionCommand = true) {
   }
 
   if (!timeout) {
-    return /** @type {TRes} */ (await proxy.command(url, method, body));
+    return await proxy.command(url, method, body) as TRes;
   }
 
   this.log.debug(`Setting custom timeout to ${timeout} ms for '${cmdName}' command`);
   try {
-    return /** @type {TRes} */ (await B.resolve(proxy.command(url, method, body)).timeout(timeout));
+    return await B.resolve(proxy.command(url, method, body)).timeout(timeout) as TRes;
   } catch (e) {
     if (!(e instanceof B.Promise.TimeoutError)) {
       throw e;
@@ -102,18 +111,9 @@ export async function proxyCommand(url, method, body, isSessionCommand = true) {
   }
 }
 
-/**
- * @param {string} endpoint
- * @param {AllowedHttpMethod} method
- * @returns {string|undefined}
- */
-function wdaRouteToCommandName(endpoint, method) {
+function wdaRouteToCommandName(endpoint: string, method: AllowedHttpMethod): string | undefined {
   if (endpoint in WDA_ROUTES) {
-    return WDA_ROUTES[endpoint][method];
+    return WDA_ROUTES[endpoint as keyof typeof WDA_ROUTES]?.[method];
   }
 }
 
-/**
- * @typedef {import('../driver').XCUITestDriver} XCUITestDriver
- * @typedef {'GET'|'POST'|'DELETE'} AllowedHttpMethod
- */