appium-xcuitest-driver 10.14.0 → 10.14.2

package/lib/commands/{record-audio.js → record-audio.ts}

@@ -2,6 +2,8 @@ import {fs, tempDir, logger, util} from 'appium/support';
 import {SubProcess} from 'teen_process';
 import {encodeBase64OrUpload} from '../utils';
 import {waitForCondition} from 'asyncbox';
+import type {XCUITestDriver} from '../driver';
+import type {AudioRecorderOptions} from './types';
 
 const MAX_RECORDING_TIME_SEC = 43200;
 const AUDIO_RECORD_FEAT_NAME = 'audio_record';
@@ -13,7 +15,13 @@ const FFMPEG_BINARY = 'ffmpeg';
 const ffmpegLogger = logger.getLogger(FFMPEG_BINARY);
 
 export class AudioRecorder {
-  constructor(input, log, audioPath, opts = {}) {
+  private readonly input: string | number;
+  private readonly log: any;
+  private readonly audioPath: string;
+  private readonly opts: AudioRecorderOptions;
+  private mainProcess: SubProcess | null;
+
+  constructor(input: string | number, log: any, audioPath: string, opts: AudioRecorderOptions = {} as AudioRecorderOptions) {
     this.input = input;
     this.log = log;
     this.audioPath = audioPath;
@@ -21,7 +29,7 @@ export class AudioRecorder {
     this.mainProcess = null;
   }
 
-  async start(timeoutSeconds) {
+  async start(timeoutSeconds: number): Promise<void> {
     try {
       await fs.which(FFMPEG_BINARY);
     } catch {
@@ -39,7 +47,7 @@ export class AudioRecorder {
       '-f',
       audioSource,
       '-i',
-      this.input,
+      String(this.input),
       '-c:a',
       audioCodec,
       '-b:a',
@@ -90,7 +98,7 @@ export class AudioRecorder {
     );
     this.mainProcess.once('exit', (code, signal) => {
       // ffmpeg returns code 255 if SIGINT arrives
-      if ([0, 255].includes(code)) {
+      if ([0, 255].includes(code ?? 0)) {
         this.log.info(`The recording session on audio input '${this.input}' has been finished`);
       } else {
         this.log.debug(
@@ -101,17 +109,17 @@ export class AudioRecorder {
     });
   }
 
-  isRecording() {
+  isRecording(): boolean {
     return !!this.mainProcess?.isRunning;
   }
 
-  async interrupt(force = false) {
+  async interrupt(force = false): Promise<boolean> {
     if (this.isRecording()) {
       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'} ${FFMPEG_BINARY}. ` +
             `Original error: ${e.message}`,
@@ -123,12 +131,12 @@ export class AudioRecorder {
     return true;
   }
 
-  async finish() {
+  async finish(): Promise<string> {
     await this.interrupt();
     return this.audioPath;
   }
 
-  async cleanup() {
+  async cleanup(): Promise<void> {
     if (await fs.exists(this.audioPath)) {
       await fs.rimraf(this.audioPath);
     }
@@ -140,27 +148,25 @@ export class AudioRecorder {
  *
  * **To use this command, the `audio_record` security feature must be enabled _and_ [FFMpeg](https://ffmpeg.org/) must be installed on the Appium server.**
  *
- * @param {string|number} audioInput - The name of the corresponding audio input device to use for the capture. The full list of capture devices could be shown by executing `ffmpeg -f avfoundation -list_devices true -i ""`
- * @param {string|number} timeLimit - The maximum recording time, in seconds.
- * @param {string} audioCodec - The name of the audio codec.
- * @param {string} audioBitrate - The bitrate of the resulting audio stream.
- * @param {string|number} audioChannels - The count of audio channels in the resulting stream. Setting it to `1` will create a single channel (mono) audio stream.
- * @param {string|number} audioRate - The sampling rate of the resulting audio stream (in Hz).
- * @param {boolean} forceRestart - Whether to restart audio capture process forcefully when `mobile: startRecordingAudio` is called (`true`) or ignore the call until the current audio recording is completed (`false`).
+ * @param audioInput - The name of the corresponding audio input device to use for the capture. The full list of capture devices could be shown by executing `ffmpeg -f avfoundation -list_devices true -i ""`
+ * @param timeLimit - The maximum recording time, in seconds.
+ * @param audioCodec - The name of the audio codec.
+ * @param audioBitrate - The bitrate of the resulting audio stream.
+ * @param audioChannels - The count of audio channels in the resulting stream. Setting it to `1` will create a single channel (mono) audio stream.
+ * @param audioRate - The sampling rate of the resulting audio stream (in Hz).
+ * @param forceRestart - Whether to restart audio capture process forcefully when `mobile: startRecordingAudio` is called (`true`) or ignore the call until the current audio recording is completed (`false`).
  * @group Real Device Only
- * @this {XCUITestDriver}
- * @returns {Promise<void>}
- * @privateRemarks Using string literals for the default parameters makes better documentation.
  */
 export async function startAudioRecording(
-  audioInput,
-  timeLimit = 180,
+  this: XCUITestDriver,
+  audioInput: string | number,
+  timeLimit: string | number = 180,
   audioCodec = 'aac',
   audioBitrate = '128k',
-  audioChannels = 2,
-  audioRate = 44100,
+  audioChannels: string | number = 2,
+  audioRate: string | number = 44100,
   forceRestart = false,
-) {
+): Promise<void> {
   if (!this.isFeatureEnabled(AUDIO_RECORD_FEAT_NAME)) {
     throw this.log.errorWithException(
       `Audio capture feature must be enabled on the server side. ` +
@@ -203,8 +209,8 @@ export async function startAudioRecording(
     audioSource: DEFAULT_SOURCE,
     audioCodec,
     audioBitrate,
-    audioChannels,
-    audioRate,
+    audioChannels: Number(audioChannels),
+    audioRate: Number(audioRate),
   });
 
   const timeoutSeconds = parseInt(String(timeLimit), 10);
@@ -231,18 +237,17 @@ export async function startAudioRecording(
  * If no previously recorded file is found and no active audio recording
  * processes are running then the method returns an empty string.
  *
- * @returns {Promise<string>} Base64-encoded content of the recorded media file or an
+ * @returns Base64-encoded content of the recorded media file or an
  * empty string if no audio recording has been started before.
  * @throws {Error} If there was an error while getting the recorded file.
- * @this {XCUITestDriver}
  */
-export async function stopAudioRecording() {
+export async function stopAudioRecording(this: XCUITestDriver): Promise<string> {
   if (!this._audioRecorder) {
     this.log.info('Audio recording has not been started. There is nothing to stop');
     return '';
   }
 
-  let resultPath;
+  let resultPath: string;
   try {
     resultPath = await this._audioRecorder.finish();
     if (!(await fs.exists(resultPath))) {
@@ -259,6 +264,3 @@ export async function stopAudioRecording() {
   return await encodeBase64OrUpload(resultPath);
 }
 
-/**
- * @typedef {import('../driver').XCUITestDriver} XCUITestDriver
- */

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

@@ -2,19 +2,23 @@ import {retryInterval} from 'asyncbox';
 import _ from 'lodash';
 import {errors} from 'appium/driver';
 import {util, imageUtil} from 'appium/support';
+import type {XCUITestDriver} from '../driver';
+import type {Simulator} from 'appium-ios-simulator';
+import type {Element} from '@appium/types';
 
 /**
- * @this {XCUITestDriver}
- * @returns {Promise<string>}
+ * Takes a screenshot of the current screen.
+ *
+ * @returns Base64-encoded screenshot data
  */
-export async function getScreenshot() {
+export async function getScreenshot(this: XCUITestDriver): Promise<string> {
   if (this.isWebContext()) {
     const webScreenshotMode = (await this.settings.getSettings()).webScreenshotMode;
     switch (_.toLower(webScreenshotMode)) {
       case 'page':
       case 'viewport':
         return await this.remote.captureScreenshot({
-          coordinateSystem: /** @type {'Viewport'|'Page'} */ (_.capitalize(webScreenshotMode)),
+          coordinateSystem: _.capitalize(webScreenshotMode) as 'Viewport' | 'Page',
         });
       case 'native':
       case undefined:
@@ -29,7 +33,7 @@ export async function getScreenshot() {
     }
   }
 
-  const getScreenshotFromWDA = async () => {
+  const getScreenshotFromWDA = async (): Promise<string> => {
     this.log.debug(`Taking screenshot with WDA`);
     const data = await this.proxyCommand('/screenshot', 'GET');
     if (!_.isString(data)) {
@@ -53,14 +57,14 @@ export async function getScreenshot() {
 
   try {
     return await getScreenshotFromWDA();
-  } catch (err) {
+  } catch (err: any) {
     this.log.warn(`Error getting screenshot: ${err.message}`);
   }
 
   // simulator attempt
   if (this.isSimulator()) {
     this.log.info(`Falling back to 'simctl io screenshot' API`);
-    const payload = await /** @type {import('appium-ios-simulator').Simulator} */ (this.device).simctl.getScreenshot();
+    const payload = await (this.device as Simulator).simctl.getScreenshot();
     if (!payload) {
       throw new errors.UnableToCaptureScreen();
     }
@@ -68,13 +72,19 @@ export async function getScreenshot() {
   }
 
   // Retry for real devices only. Fail fast on Simulator if simctl does not work as expected
-  return /** @type {string} */ (await retryInterval(2, 1000, getScreenshotFromWDA));
+  return await retryInterval(2, 1000, getScreenshotFromWDA) as string;
 }
 
 /**
- * @this {XCUITestDriver}
+ * Takes a screenshot of a specific element.
+ *
+ * @param el - Element to capture
+ * @returns Base64-encoded screenshot data
  */
-export async function getElementScreenshot(el) {
+export async function getElementScreenshot(
+  this: XCUITestDriver,
+  el: Element<string> | string,
+): Promise<string> {
   el = util.unwrapElement(el);
   if (this.isWebContext()) {
     const atomsElement = this.getAtomsElement(el);
@@ -96,10 +106,11 @@ export async function getElementScreenshot(el) {
 }
 
 /**
- * @this {XCUITestDriver}
- * @returns {Promise<string>}
+ * Takes a screenshot of the current viewport.
+ *
+ * @returns Base64-encoded screenshot data
  */
-export async function getViewportScreenshot() {
+export async function getViewportScreenshot(this: XCUITestDriver): Promise<string> {
   if (this.isWebContext()) {
     return await this.remote.captureScreenshot();
   }
@@ -130,6 +141,3 @@ export async function getViewportScreenshot() {
   return await imageUtil.cropBase64Image(screenshot, region);
 }
 
-/**
- * @typedef {import('../driver').XCUITestDriver} XCUITestDriver
- */

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

@@ -1,12 +1,16 @@
 import _ from 'lodash';
 import js2xml from 'js2xmlparser2';
+import type {XCUITestDriver} from '../driver';
+import type {SourceFormat} from './types';
 
 const APPIUM_AUT_TAG = 'AppiumAUT';
 
 /**
- * @this {XCUITestDriver}
+ * Retrieves the page source of the current application.
+ *
+ * @returns The page source as XML or HTML string
  */
-export async function getPageSource() {
+export async function getPageSource(this: XCUITestDriver): Promise<string> {
   if (this.isWebContext()) {
     const script = 'return document.documentElement.outerHTML';
     return await this.executeAtom('execute_script', [script, []]);
@@ -28,14 +32,17 @@ export async function getPageSource() {
 /**
  * Retrieve the source tree of the current page in XML or JSON format.
  *
- * @param {import('./types').SourceFormat} format - Page tree source representation format.
- * @param {string} [excludedAttributes] A comma-separated string of attribute names to exclude from the output. Only works if `format` is `xml`.
+ * @param format - Page tree source representation format.
+ * @param excludedAttributes - A comma-separated string of attribute names to exclude from the output. Only works if `format` is `xml`.
  * @privateRemarks Why isn't `excludedAttributes` an array?
- * @returns {Promise<string>} The source tree of the current page in the given format.
- * @this {XCUITestDriver}
+ * @returns The source tree of the current page in the given format.
  */
-export async function mobileGetSource(format = 'xml', excludedAttributes) {
-  const paramsMap = {
+export async function mobileGetSource(
+  this: XCUITestDriver,
+  format: SourceFormat = 'xml',
+  excludedAttributes?: string,
+): Promise<string> {
+  const paramsMap: Record<string, string> = {
     format,
     scope: APPIUM_AUT_TAG,
   };
@@ -45,7 +52,7 @@ export async function mobileGetSource(format = 'xml', excludedAttributes) {
   const query = Object.entries(paramsMap)
     .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
     .join('&');
-  return /** @type {string} */ (await this.proxyCommand(`/source?${query}`, 'GET'));
+  return await this.proxyCommand(`/source?${query}`, 'GET') as string;
 }
 
 /**
@@ -76,15 +83,14 @@ export async function mobileGetSource(format = 'xml', excludedAttributes) {
  *     rawIdentifier: null }
  * ```
  */
-function getTreeForXML(srcTree) {
-  function getTree(element, elementIndex, parentPath) {
-    let curPath = `${parentPath}/${elementIndex}`;
-    let rect = element.rect || {};
+function getTreeForXML(srcTree: any): any {
+  function getTree(element: any, elementIndex: number, parentPath: string): any {
+    const curPath = `${parentPath}/${elementIndex}`;
+    const rect = element.rect || {};
     /**
      * @privateRemarks I don't even want to try to type this right now
-     * @type {any}
      */
-    let subtree = {
+    const subtree: any = {
       '@': {
         type: `XCUIElementType${element.type}`,
         enabled: parseInt(element.isEnabled, 10) === 1,
@@ -114,11 +120,11 @@ function getTreeForXML(srcTree) {
       [`XCUIElementType${element.type}`]: subtree,
     };
   }
-  let tree = getTree(srcTree, 0, '');
+  const tree = getTree(srcTree, 0, '');
   return tree;
 }
 
-function getSourceXml(jsonSource) {
+function getSourceXml(jsonSource: any): string {
   return js2xml('AppiumAUT', jsonSource, {
     wrapArray: {enabled: false, elementName: 'element'},
     declaration: {include: true},
@@ -126,6 +132,3 @@ function getSourceXml(jsonSource) {
   });
 }
 
-/**
- * @typedef {import('../driver').XCUITestDriver} XCUITestDriver
- */

package/lib/commands/types.ts

@@ -646,3 +646,66 @@ export interface LogEntry {
 }
 
 export type LogListener = (logEntry: LogEntry) => any;
+
+/**
+ * Condition inducer profile configuration
+ */
+export interface Profile {
+  name: string;
+  /** The property is profileID used in {@linkcode XCUITestDriver.enableConditionInducer} */
+  identifier: string;
+  /** Configuration details */
+  description: string;
+}
+
+/**
+ * We can use the returned data to determine whether the Condition is enabled and the currently enabled configuration information
+ */
+export interface Condition {
+  profiles: Profile[];
+  /** The property is conditionID used in {@linkcode XCUITestDriver.enableConditionInducer} */
+  identifier: string;
+  profilesSorted: boolean;
+  isDestructive: boolean;
+  isInternal: boolean;
+  /** `true` if this condition identifier is enabled */
+  isActive: boolean;
+  /** Enabled profiles identifier */
+  activeProfile: string;
+}
+
+/**
+ * Information about an XCTest screen recording session
+ */
+export interface XcTestScreenRecordingInfo {
+  /** Unique identifier of the video being recorded */
+  uuid: string;
+  /** FPS value */
+  fps: number;
+  /** Video codec, where 0 is h264 */
+  codec: number;
+  /** The timestamp when the screen recording has started in float Unix seconds */
+  startedAt: number;
+}
+
+/**
+ * XCTest screen recording result with payload
+ */
+export interface XcTestScreenRecording extends XcTestScreenRecordingInfo {
+  /**
+   * Base64-encoded content of the recorded media file if `remotePath` parameter is empty or null or an empty string otherwise.
+   * The media is expected to a be a valid QuickTime movie (.mov).
+   */
+  payload: string;
+}
+
+/**
+ * Options for AudioRecorder
+ */
+export interface AudioRecorderOptions {
+  audioSource: string;
+  audioCodec: string;
+  audioBitrate: string;
+  audioChannels: number;
+  audioRate: number;
+}

package/lib/commands/{xctest-record-screen.js → xctest-record-screen.ts}

@@ -2,6 +2,11 @@ import _ from 'lodash';
 import {fs, util} from 'appium/support';
 import {encodeBase64OrUpload} from '../utils';
 import path from 'node:path';
+import type {XCUITestDriver} from '../driver';
+import type {Simulator} from 'appium-ios-simulator';
+import type {RealDevice} from '../device/real-device-management';
+import type {HTTPHeaders} from '@appium/types';
+import type {XcTestScreenRecordingInfo, XcTestScreenRecording} from './types';
 
 const MOV_EXT = '.mov';
 const FEATURE_NAME = 'xctest_screen_record';
@@ -10,30 +15,9 @@ const DOMAIN_TYPE = 'appDataContainer';
 const USERNAME = 'mobile';
 const SUBDIRECTORY = 'Attachments';
 
-/**
- * @typedef {Object} XcTestScreenRecordingInfo
- * @property {string} uuid Unique identifier of the video being recorded
- * @property {number} fps FPS value
- * @property {number} codec Video codec, where 0 is h264
- * @property {number} startedAt The timestamp when the screen recording has started in float Unix seconds
- */
-
-/**
- * @typedef {Object} XcTestScreenRecordingType
- * @property {string} payload Base64-encoded content of the recorded media
- * file if `remotePath` parameter is empty or null or an empty string otherwise.
- * The media is expected to a be a valid QuickTime movie (.mov).
- * @typedef {XcTestScreenRecordingInfo & XcTestScreenRecordingType} XcTestScreenRecording
- */
-
-/**
- * @this {XCUITestDriver}
- * @param {string} uuid Unique identifier of the video being recorded
- * @returns {Promise<string>} The full path to the screen recording movie
- */
-async function retrieveRecodingFromSimulator(uuid) {
-  const device = /** @type {import('appium-ios-simulator').Simulator} */ (this.device);
-  const dataRoot = /** @type {string} */ (device.getDir());
+async function retrieveRecodingFromSimulator(this: XCUITestDriver, uuid: string): Promise<string> {
+  const device = this.device as Simulator;
+  const dataRoot = device.getDir();
   // On Simulators the path looks like
   // $HOME/Library/Developer/CoreSimulator/Devices/F8E1968A-8443-4A9A-AB86-27C54C36A2F6/data/Containers/Data/InternalDaemon/4E3FE8DF-AD0A-41DA-B6EC-C35E5798C219/Attachments/A044DAF7-4A58-4CD5-95C3-29B4FE80C377
   const internalDaemonRoot = path.resolve(dataRoot, 'Containers', 'Data', 'InternalDaemon');
@@ -52,13 +36,8 @@ async function retrieveRecodingFromSimulator(uuid) {
   return videoPath;
 }
 
-/**
- * @this {XCUITestDriver}
- * @param {string} uuid Unique identifier of the video being recorded
- * @returns {Promise<string>} The full path to the screen recording movie
- */
-async function retrieveRecodingFromRealDevice(uuid) {
-  const device = /** @type {import('../device/real-device-management').RealDevice} */ (this.device);
+async function retrieveRecodingFromRealDevice(this: XCUITestDriver, uuid: string): Promise<string> {
+  const device = this.device as RealDevice;
 
   const fileNames = await device.devicectl.listFiles(DOMAIN_TYPE, DOMAIN_IDENTIFIER, {
     username: USERNAME,
@@ -69,7 +48,10 @@ async function retrieveRecodingFromRealDevice(uuid) {
       `Unable to locate XCTest screen recording identified by '${uuid}' for the device ${this.opts.udid}`
     );
   }
-  const videoPath = path.join(/** @type {string} */ (this.opts.tmpDir), `${uuid}${MOV_EXT}`);
+  if (!this.opts.tmpDir) {
+    throw new Error('tmpDir is not set in driver options');
+  }
+  const videoPath = path.join(this.opts.tmpDir, `${uuid}${MOV_EXT}`);
   await device.devicectl.pullFile(`${SUBDIRECTORY}/${uuid}`, videoPath, {
     username: USERNAME,
     domainIdentifier: DOMAIN_IDENTIFIER,
@@ -80,15 +62,10 @@ async function retrieveRecodingFromRealDevice(uuid) {
   return videoPath;
 }
 
-/**
- * @this {XCUITestDriver}
- * @param {string} uuid Unique identifier of the video being recorded
- * @returns {Promise<string>} The full path to the screen recording movie
- */
-async function retrieveXcTestScreenRecording(uuid) {
+async function retrieveXcTestScreenRecording(this: XCUITestDriver, uuid: string): Promise<string> {
   return this.isRealDevice()
-    ? await retrieveRecodingFromRealDevice.bind(this)(uuid)
-    : await retrieveRecodingFromSimulator.bind(this)(uuid);
+    ? await retrieveRecodingFromRealDevice.call(this, uuid)
+    : await retrieveRecodingFromSimulator.call(this, uuid);
 }
 
 /**
@@ -102,14 +79,16 @@ async function retrieveXcTestScreenRecording(uuid) {
  * If the recording is already running this API is a noop.
  *
  * @since Xcode 15/iOS 17
- * @param {number} [fps] FPS value
- * @param {number} [codec] Video codec, where 0 is h264, 1 is HEVC
- * @returns {Promise<XcTestScreenRecordingInfo>} The information
- * about a newly created or a running the screen recording.
+ * @param fps - FPS value
+ * @param codec - Video codec, where 0 is h264, 1 is HEVC
+ * @returns The information about a newly created or a running the screen recording.
  * @throws {Error} If screen recording has failed to start.
- * @this {XCUITestDriver}
  */
-export async function mobileStartXctestScreenRecording(fps, codec) {
+export async function mobileStartXctestScreenRecording(
+  this: XCUITestDriver,
+  fps?: number,
+  codec?: number,
+): Promise<XcTestScreenRecordingInfo> {
   if (this.isRealDevice()) {
     // This feature might be used to abuse real devices as there is no
     // reliable way (yet) to cleanup video recordings stored there
@@ -117,16 +96,14 @@ export async function mobileStartXctestScreenRecording(fps, codec) {
     this.assertFeatureEnabled(FEATURE_NAME);
   }
 
-  const opts = {};
+  const opts: {codec?: number; fps?: number} = {};
   if (_.isInteger(codec)) {
     opts.codec = codec;
   }
   if (_.isInteger(fps)) {
     opts.fps = fps;
   }
-  const response = /** @type {XcTestScreenRecordingInfo} */ (
-    await this.proxyCommand('/wda/video/start', 'POST', opts)
-  );
+  const response = await this.proxyCommand('/wda/video/start', 'POST', opts) as XcTestScreenRecordingInfo;
   this.log.info(`Started a new screen recording: ${JSON.stringify(response)}`);
   return response;
 }
@@ -134,13 +111,11 @@ export async function mobileStartXctestScreenRecording(fps, codec) {
 /**
  * Retrieves information about the current running screen recording.
  * If no screen recording is running then `null` is returned.
- *
- * @returns {Promise<XcTestScreenRecordingInfo?>}
  */
-export async function mobileGetXctestScreenRecordingInfo() {
-  return /** @type {XcTestScreenRecordingInfo?} */ (
-    await this.proxyCommand('/wda/video', 'GET')
-  );
+export async function mobileGetXctestScreenRecordingInfo(
+  this: XCUITestDriver,
+): Promise<XcTestScreenRecordingInfo | null> {
+  return (await this.proxyCommand('/wda/video', 'GET')) as XcTestScreenRecordingInfo | null;
 }
 
 /**
@@ -157,29 +132,37 @@ export async function mobileGetXctestScreenRecordingInfo() {
  * on the device directly or by doing factory reset.
  *
  * @since Xcode 15/iOS 17
- * @param {string} [remotePath] The path to the remote location, where the resulting video should be
+ * @param remotePath - The path to the remote location, where the resulting video should be
  * uploaded.
  * The following protocols are supported: `http`, `https`, `ftp`. Null or empty
  * string value (the default setting) means the content of resulting file
  * should be encoded as Base64 and passed as the endpoint response value. An
  * exception will be thrown if the generated media file is too big to fit into
  * the available process memory.
- * @param {string} [user] The name of the user for the remote authentication.
+ * @param user - The name of the user for the remote authentication.
  * Only works if `remotePath` is provided.
- * @param {string} [pass] The password for the remote authentication.
+ * @param pass - The password for the remote authentication.
  * Only works if `remotePath` is provided.
- * @param {import('@appium/types').HTTPHeaders} [headers] Additional headers mapping for multipart http(s) uploads
- * @param {string} [fileFieldName] The name of the form field where the file content BLOB should be stored for
+ * @param headers - Additional headers mapping for multipart http(s) uploads
+ * @param fileFieldName - The name of the form field where the file content BLOB should be stored for
  * http(s) uploads
- * @param {Record<string, any> | [string, any][]} [formFields] Additional form fields for multipart http(s) uploads
- * @param {'PUT' | 'POST' | 'PATCH'} [method='PUT'] The http multipart upload method name.
+ * @param formFields - Additional form fields for multipart http(s) uploads
+ * @param method - The http multipart upload method name.
  * Only works if `remotePath` is provided.
- * @returns {Promise<XcTestScreenRecording>}
+ * @returns The resulting movie with base64-encoded content or empty string if uploaded remotely.
  * @throws {Error} If there was an error while retrieving the video
  * file or the file content cannot be uploaded to the remote location.
- * @this {XCUITestDriver}
  */
-export async function mobileStopXctestScreenRecording(remotePath, user, pass, headers, fileFieldName, formFields, method) {
+export async function mobileStopXctestScreenRecording(
+  this: XCUITestDriver,
+  remotePath?: string,
+  user?: string,
+  pass?: string,
+  headers?: HTTPHeaders,
+  fileFieldName?: string,
+  formFields?: Record<string, any> | [string, any][],
+  method: 'PUT' | 'POST' | 'PATCH' = 'PUT',
+): Promise<XcTestScreenRecording> {
   const screenRecordingInfo = await this.mobileGetXctestScreenRecordingInfo();
   if (!screenRecordingInfo) {
     throw new Error('There is no active screen recording. Did you start one beforehand?');
@@ -187,8 +170,11 @@ export async function mobileStopXctestScreenRecording(remotePath, user, pass, he
 
   this.log.debug(`Stopping the active screen recording: ${JSON.stringify(screenRecordingInfo)}`);
   await this.proxyCommand('/wda/video/stop', 'POST', {});
-  const videoPath = await retrieveXcTestScreenRecording.bind(this)(screenRecordingInfo.uuid);
-  const result = /** @type {XcTestScreenRecording} */ (screenRecordingInfo);
+  const videoPath = await retrieveXcTestScreenRecording.call(this, screenRecordingInfo.uuid);
+  const result: XcTestScreenRecording = {
+    ...screenRecordingInfo,
+    payload: '', // Will be set below
+  };
   try {
     result.payload = await encodeBase64OrUpload(videoPath, remotePath, {
       user, pass, headers, fileFieldName, formFields, method
@@ -199,6 +185,3 @@ export async function mobileStopXctestScreenRecording(remotePath, user, pass, he
   return result;
 }
 
-/**
- * @typedef {import('../driver').XCUITestDriver} XCUITestDriver
- */

package/lib/driver.ts

@@ -121,7 +121,7 @@ import type { PerfRecorder } from './commands/performance';
 import type { AudioRecorder } from './commands/record-audio';
 import type { TrafficCapture } from './commands/pcap';
 import type { ScreenRecorder } from './commands/recordscreen';
-import type { DVTServiceWithConnection } from './commands/condition.js';
+import type { DVTServiceWithConnection } from 'appium-ios-remotexpc';
 import type { IOSDeviceLog } from './device/log/ios-device-log';
 import type { IOSSimulatorLog } from './device/log/ios-simulator-log';
 import type { IOSCrashLog } from './device/log/ios-crash-log';
@@ -500,7 +500,7 @@ export class XCUITestDriver
     this.log.debug(`Executing command '${cmd}'`);
 
     if (cmd === 'receiveAsyncResponse') {
-      return await this.receiveAsyncResponse(...args);
+      return await this.receiveAsyncResponse(args[0], args[1]);
     }
     // TODO: once this fix gets into base driver remove from here
     if (cmd === 'getStatus') {