appium-xcuitest-driver 10.13.4 → 10.14.1

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/{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/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';