@appium/base-driver 9.3.2 → 9.3.4

package/lib/basedriver/commands/timeout.ts

@@ -0,0 +1,155 @@
+import {waitForCondition} from 'asyncbox';
+import _ from 'lodash';
+import {util} from '@appium/support';
+import {errors} from '../../protocol';
+import {BaseDriver} from '../driver';
+import {Constraints, ITimeoutCommands} from '@appium/types';
+import {mixin} from './mixin';
+
+declare module '../driver' {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  interface BaseDriver<C extends Constraints> extends ITimeoutCommands {}
+}
+
+const MIN_TIMEOUT = 0;
+
+const TimeoutCommands: ITimeoutCommands = {
+  async timeouts<C extends Constraints>(this: BaseDriver<C>, type, ms, script, pageLoad, implicit) {
+    if (util.hasValue(type) && util.hasValue(ms)) {
+      this.log.debug(`MJSONWP timeout arguments: ${JSON.stringify({type, ms})}}`);
+
+      switch (type) {
+        case 'command':
+          await this.newCommandTimeout(ms);
+          return;
+        case 'implicit':
+          await this.implicitWaitMJSONWP(ms);
+          return;
+        case 'page load':
+          await this.pageLoadTimeoutMJSONWP(ms);
+          return;
+        case 'script':
+          await this.scriptTimeoutMJSONWP(ms);
+          return;
+        default:
+          throw new Error(`'${type}' type is not supported for MJSONWP timeout`);
+      }
+    }
+
+    // Otherwise assume it is W3C protocol
+    this.log.debug(
+      `W3C timeout argument: ${JSON.stringify({
+        script,
+        pageLoad,
+        implicit,
+      })}}`
+    );
+    if (util.hasValue(script)) {
+      await this.scriptTimeoutW3C(script);
+    }
+    if (util.hasValue(pageLoad)) {
+      await this.pageLoadTimeoutW3C(pageLoad);
+    }
+    if (util.hasValue(implicit)) {
+      await this.implicitWaitW3C(implicit);
+    }
+  },
+
+  async getTimeouts() {
+    return {
+      command: this.newCommandTimeoutMs,
+      implicit: this.implicitWaitMs,
+    };
+  },
+
+  // implicit
+  async implicitWaitW3C<C extends Constraints>(this: BaseDriver<C>, ms) {
+    await this.implicitWait(ms);
+  },
+
+  async implicitWaitMJSONWP<C extends Constraints>(this: BaseDriver<C>, ms) {
+    await this.implicitWait(ms);
+  },
+
+  async implicitWait<C extends Constraints>(this: BaseDriver<C>, ms) {
+    this.setImplicitWait(this.parseTimeoutArgument(ms));
+  },
+
+  // pageLoad
+  async pageLoadTimeoutW3C<C extends Constraints>(this: BaseDriver<C>, ms) {
+    throw new errors.NotImplementedError('Not implemented yet for pageLoad.');
+  },
+
+  async pageLoadTimeoutMJSONWP<C extends Constraints>(this: BaseDriver<C>, ms) {
+    throw new errors.NotImplementedError('Not implemented yet for pageLoad.');
+  },
+
+  // script
+  async scriptTimeoutW3C<C extends Constraints>(this: BaseDriver<C>, ms) {
+    throw new errors.NotImplementedError('Not implemented yet for script.');
+  },
+
+  async scriptTimeoutMJSONWP<C extends Constraints>(this: BaseDriver<C>, ms) {
+    throw new errors.NotImplementedError('Not implemented yet for script.');
+  },
+
+  // command
+  async newCommandTimeout<C extends Constraints>(this: BaseDriver<C>, ms) {
+    this.setNewCommandTimeout(this.parseTimeoutArgument(ms));
+  },
+
+  setImplicitWait<C extends Constraints>(this: BaseDriver<C>, ms: number) {
+    // eslint-disable-line require-await
+    this.implicitWaitMs = ms;
+    this.log.debug(`Set implicit wait to ${ms}ms`);
+    if (this.managedDrivers && this.managedDrivers.length) {
+      this.log.debug('Setting implicit wait on managed drivers');
+      for (const driver of this.managedDrivers) {
+        if (_.isFunction(driver.setImplicitWait)) {
+          driver.setImplicitWait(ms);
+        }
+      }
+    }
+  },
+
+  setNewCommandTimeout<C extends Constraints>(this: BaseDriver<C>, ms: number) {
+    this.newCommandTimeoutMs = ms;
+    this.log.debug(`Set new command timeout to ${ms}ms`);
+    if (this.managedDrivers && this.managedDrivers.length) {
+      this.log.debug('Setting new command timeout on managed drivers');
+      for (const driver of this.managedDrivers) {
+        if (_.isFunction(driver.setNewCommandTimeout)) {
+          driver.setNewCommandTimeout(ms);
+        }
+      }
+    }
+  },
+
+  async implicitWaitForCondition<C extends Constraints>(
+    this: BaseDriver<C>,
+    condFn: (...args: any[]) => Promise<any>
+  ) {
+    this.log.debug(`Waiting up to ${this.implicitWaitMs} ms for condition`);
+    const wrappedCondFn = async (...args: any[]) => {
+      // reset command timeout
+      await this.clearNewCommandTimeout();
+
+      return await condFn(...args);
+    };
+    return await waitForCondition(wrappedCondFn, {
+      waitMs: this.implicitWaitMs,
+      intervalMs: 500,
+      logger: this.log,
+    });
+  },
+
+  parseTimeoutArgument<C extends Constraints>(this: BaseDriver<C>, ms: number | string) {
+    const duration = parseInt(String(ms), 10);
+    if (_.isNaN(duration) || duration < MIN_TIMEOUT) {
+      throw new errors.UnknownError(`Invalid timeout value '${ms}'`);
+    }
+    return duration;
+  },
+};
+
+mixin(TimeoutCommands);

package/lib/basedriver/core.js

@@ -1,7 +1,7 @@
 /* eslint-disable no-unused-vars */
 /* eslint-disable require-await */
 
-import {fs, logger} from '@appium/support';
+import {logger} from '@appium/support';
 import AsyncLock from 'async-lock';
 import {EventEmitter} from 'events';
 import _ from 'lodash';
@@ -9,18 +9,16 @@ import os from 'os';
 import {DEFAULT_BASE_PATH, PROTOCOLS} from '../constants';
 import {errors} from '../protocol';
 import DeviceSettings from './device-settings';
-import helpers from './helpers';
-
-// for compat with running tests transpiled and in-place
-const {version: BASEDRIVER_VER} = fs.readPackageJsonFrom(__dirname);
+import helpers, {BASEDRIVER_VER} from './helpers';
 
 const NEW_COMMAND_TIMEOUT_MS = 60 * 1000;
 
 const ON_UNEXPECTED_SHUTDOWN_EVENT = 'onUnexpectedShutdown';
 
 /**
- * @template {Constraints} [C=BaseDriverCapConstraints]
- * @implements {Core<C>}
+ * @template {Constraints} C
+ * @template {StringRecord} [Settings=StringRecord]
+ * @implements {Core<C, Settings>}
  */
 class DriverCore {
   /**
@@ -29,9 +27,6 @@ class DriverCore {
    */
   static baseVersion = BASEDRIVER_VER;
 
-  /** @type {import('@appium/types').ExecuteMethodMap<DriverCore>} */
-  static executeMethodMap = {};
-
   /**
    * @type {string?}
    */
@@ -43,7 +38,7 @@ class DriverCore {
   opts;
 
   /**
-   * @type {ServerArgs}
+   * @type {import('@appium/types').DriverOpts<C>}
    */
   initialOpts;
 
@@ -101,7 +96,6 @@ class DriverCore {
   _log;
 
   /**
-   * @protected
    * @type {boolean}
    */
   shutdownUnexpectedly;
@@ -122,7 +116,7 @@ class DriverCore {
    * we set it to an empty DeviceSettings instance here to make sure that the
    * default settings are applied even if an extending driver doesn't utilize
    * the settings functionality itself
-   * @type {DeviceSettings}
+   * @type {DeviceSettings<Settings>}
    */
   settings;
 
@@ -187,11 +181,9 @@ class DriverCore {
    * specific driver sessions. This data can be later used to adjust
    * properties for driver instances running in parallel.
    * Override it in inherited driver classes if necessary.
-   *
-   * @return {Record<string,unknown>} Driver properties mapping
    */
   get driverData() {
-    return {};
+    return /** @type {import('@appium/types').DriverData} */ ({});
   }
 
   /**
@@ -263,7 +255,7 @@ class DriverCore {
    * @returns {Core<C> | null}
    */
   driverForSession(sessionId) {
-    return this;
+    return /** @type {Core<C> | null} */ (this);
   }
 
   isMjsonwpProtocol() {
@@ -451,19 +443,10 @@ export {DriverCore};
  * @typedef {import('@appium/types').BaseDriverCapConstraints} BaseDriverCapConstraints
  */
 
-/**
- * @template {Constraints} [C=BaseDriverCapConstraints]
- * @template {StringRecord|void} [Extra=void]
- * @typedef {import('@appium/types').Capabilities<C, Extra>} Capabilities
- */
-/**
- * @template {StringRecord} [T={}]
- * @typedef {import('@appium/types').W3CCapabilities<T>} W3CCapabilities
- */
-
 /**
  * @template {Constraints} C
- * @typedef {import('@appium/types').Core<C>} Core
+ * @template {StringRecord} [S=StringRecord]
+ * @typedef {import('@appium/types').Core<C, S>} Core
  */
 
 /**

package/lib/basedriver/device-settings.js

@@ -9,13 +9,13 @@ import {errors} from '../protocol/errors';
 export const MAX_SETTINGS_SIZE = 20 * 1024 * 1024; // 20 MB
 
 /**
- * @template T
+ * @template {import('@appium/types').StringRecord} T
  * @implements {IDeviceSettings<T>}
  */
-class DeviceSettings {
+export class DeviceSettings {
   /**
    * @protected
-   * @type {Record<string,T>}
+   * @type {T}
    */
   _settings;
 
@@ -27,17 +27,17 @@ class DeviceSettings {
 
   /**
    * Creates a _shallow copy_ of the `defaultSettings` parameter!
-   * @param {Record<string,T>} [defaultSettings]
+   * @param {T} [defaultSettings]
    * @param {import('@appium/types').SettingsUpdateListener<T>} [onSettingsUpdate]
    */
-  constructor(defaultSettings = {}, onSettingsUpdate = async () => {}) {
+  constructor(defaultSettings = /** @type {T} */ ({}), onSettingsUpdate = async () => {}) {
     this._settings = {...defaultSettings};
     this._onSettingsUpdate = onSettingsUpdate;
   }
 
   /**
    * calls updateSettings from implementing driver every time a setting is changed.
-   * @param {Record<string,T>} newSettings
+   * @param {T} newSettings
    */
   async update(newSettings) {
     if (!_.isPlainObject(newSettings)) {
@@ -54,8 +54,7 @@ class DeviceSettings {
       );
     }
 
-    const props = /** @type {(keyof T & string)[]} */ (_.keys(newSettings));
-    for (const prop of props) {
+    for (const prop in newSettings) {
       if (!_.isUndefined(this._settings[prop])) {
         if (this._settings[prop] === newSettings[prop]) {
           log.debug(`The value of '${prop}' setting did not change. Skipping the update for it`);
@@ -73,9 +72,8 @@ class DeviceSettings {
 }
 
 export default DeviceSettings;
-export {DeviceSettings};
 
 /**
- * @template T
- * @typedef {import('@appium/types').DeviceSettings<T>} IDeviceSettings
+ * @template {import('@appium/types').StringRecord} [T=import('@appium/types').StringRecord]
+ * @typedef {import('@appium/types').IDeviceSettings<T>} IDeviceSettings
  */

package/lib/basedriver/{driver.js → driver.ts}

@@ -1,6 +1,3 @@
-/* eslint-disable require-await */
-/* eslint-disable no-unused-vars */
-
 import {validateCaps, processCapabilities} from './capabilities';
 import {DriverCore} from './core';
 import {util} from '@appium/support';
@@ -8,9 +5,22 @@ import B from 'bluebird';
 import _ from 'lodash';
 import {fixCaps, isW3cCaps} from '../helpers/capabilities';
 import {DELETE_SESSION_COMMAND, determineProtocol, errors} from '../protocol';
-import {createBaseDriverClass} from './commands';
 import helpers from './helpers';
-import {BASE_DESIRED_CAP_CONSTRAINTS} from '@appium/types';
+import {
+  AppiumServer,
+  BaseDriverCapConstraints,
+  BASE_DESIRED_CAP_CONSTRAINTS,
+  Capabilities,
+  Constraints,
+  DefaultCreateSessionResult,
+  Driver,
+  DriverCaps,
+  DriverData,
+  DriverOpts,
+  ServerArgs,
+  StringRecord,
+  W3CDriverCaps,
+} from '@appium/types';
 
 const EVENT_SESSION_INIT = 'newSessionRequested';
 const EVENT_SESSION_START = 'newSessionStarted';
@@ -18,55 +28,31 @@ const EVENT_SESSION_QUIT_START = 'quitSessionRequested';
 const EVENT_SESSION_QUIT_DONE = 'quitSessionFinished';
 const ON_UNEXPECTED_SHUTDOWN_EVENT = 'onUnexpectedShutdown';
 
-/**
- * @implements {SessionHandler<C>}
- * @template {Constraints} C
- * @template {StringRecord} [CArgs=StringRecord]
- * @extends {DriverCore<C>}
- */
-export class BaseDriverCore extends DriverCore {
-  /**
-   * @type {CArgs & ServerArgs}
-   */
-  cliArgs;
-
-  /**
-   * @type {Capabilities<C>}
-   */
-  caps;
-
-  /**
-   * @type {W3CCapabilities<C>}
-   */
-  originalCaps;
-
-  /**
-   * @type {C}
-   */
-  desiredCapConstraints;
-
-  /**
-   * @type {DriverOpts<C> & DriverOpts<BaseDriverCapConstraints>}
-   */
-  opts;
-
-  /**
-   *
-   * @param {DriverOpts<C>} opts
-   * @param {boolean} shouldValidateCaps
-   */
-  constructor(opts = /** @type {DriverOpts<C>} */ ({}), shouldValidateCaps = true) {
+export class BaseDriver<
+    C extends Constraints,
+    CArgs extends StringRecord = StringRecord,
+    Settings extends StringRecord = StringRecord
+  >
+  extends DriverCore<C, Settings>
+  implements Driver<C, CArgs>
+{
+  cliArgs: CArgs & ServerArgs;
+
+  caps: DriverCaps<C>;
+  originalCaps: W3CDriverCaps<C>;
+  desiredCapConstraints: C;
+  opts: DriverOpts<C>;
+  server?: AppiumServer;
+  serverHost?: string;
+  serverPort?: number;
+  serverPath?: string;
+
+  constructor(opts: DriverOpts<C>, shouldValidateCaps = true) {
     super(opts, shouldValidateCaps);
 
-    /**
-     * This must be assigned here because the declaration of {@linkcode BaseDriverCore.opts} above
-     * blows away {@linkcode DriverCore.opts}.
-     */
-    this.opts = opts;
-
-    this.caps = {};
+    this.caps = {} as DriverCaps<C>;
 
-    this.cliArgs = /** @type {CArgs & ServerArgs} */ ({});
+    this.cliArgs = {} as CArgs & ServerArgs;
   }
 
   /**
@@ -75,25 +61,20 @@ export class BaseDriverCore extends DriverCore {
    * Subclasses _shouldn't_ need to use this. If you need to use this, please create
    * an issue:
    * @see https://github.com/appium/appium/issues/new
-   * @type {Readonly<BaseDriverCapConstraints & C>}
-   * @protected
    */
-  get _desiredCapConstraints() {
+  protected get _desiredCapConstraints(): Readonly<BaseDriverCapConstraints & C> {
     return Object.freeze(_.merge({}, BASE_DESIRED_CAP_CONSTRAINTS, this.desiredCapConstraints));
   }
 
-  // This is the main command handler for the driver. It wraps command
-  // execution with timeout logic, checking that we have a valid session,
-  // and ensuring that we execute commands one at a time. This method is called
-  // by MJSONWP's express router.
   /**
-   * @param {string} cmd
-   * @param  {...any} args
-   * @returns {Promise<any>}
+   * This is the main command handler for the driver. It wraps command
+   * execution with timeout logic, checking that we have a valid session,
+   * and ensuring that we execute commands one at a time. This method is called
+   * by MJSONWP's express router.
    */
-  async executeCommand(cmd, ...args) {
+  async executeCommand<T = unknown>(cmd: string, ...args: any[]): Promise<T> {
     // get start time for this command, and log in special cases
-    let startTime = Date.now();
+    const startTime = Date.now();
 
     if (cmd === 'createSession') {
       // If creating a session determine if W3C or MJSONWP protocol was requested and remember the choice
@@ -161,12 +142,8 @@ export class BaseDriverCore extends DriverCore {
     return res;
   }
 
-  /**
-   *
-   * @param {Error|import('../protocol/errors').NoSuchDriverError} err
-   */
   async startUnexpectedShutdown(
-    err = new errors.NoSuchDriverError('The driver was unexpectedly shut down!')
+    err: Error = new errors.NoSuchDriverError('The driver was unexpectedly shut down!')
   ) {
     this.eventEmitter.emit(ON_UNEXPECTED_SHUTDOWN_EVENT, err); // allow others to listen for this
     this.shutdownUnexpectedly = true;
@@ -200,14 +177,7 @@ export class BaseDriverCore extends DriverCore {
     }, this.newCommandTimeoutMs);
   }
 
-  /**
-   *
-   * @param {import('@appium/types').AppiumServer} server
-   * @param {string} host
-   * @param {number} port
-   * @param {string} path
-   */
-  assignServer(server, host, port, path) {
+  assignServer(server: AppiumServer, host: string, port: number, path: string) {
     this.server = server;
     this.serverHost = host;
     this.serverPort = port;
@@ -223,8 +193,8 @@ export class BaseDriverCore extends DriverCore {
     this.log.debug('Running generic full reset');
 
     // preserving state
-    let currentConfig = {};
-    for (let property of [
+    const currentConfig = {};
+    for (const property of [
       'implicitWaitMs',
       'newCommandTimeoutMs',
       'sessionId',
@@ -233,9 +203,6 @@ export class BaseDriverCore extends DriverCore {
       currentConfig[property] = this[property];
     }
 
-    // We also need to preserve the unexpected shutdown, and make sure it is not cancelled during reset.
-    this.resetOnUnexpectedShutdown = () => {};
-
     try {
       if (this.sessionId !== null) {
         await this.deleteSession(this.sessionId);
@@ -244,7 +211,7 @@ export class BaseDriverCore extends DriverCore {
       await this.createSession(this.originalCaps);
     } finally {
       // always restore state.
-      for (let [key, value] of _.toPairs(currentConfig)) {
+      for (const [key, value] of _.toPairs(currentConfig)) {
         this[key] = value;
       }
     }
@@ -257,13 +224,14 @@ export class BaseDriverCore extends DriverCore {
    * Appium 2 has dropped the support of these, so now we only accept capability
    * objects in W3C format and thus allow any of the three arguments to represent
    * the latter.
-   * @param {W3CCapabilities<C>} w3cCapabilities1
-   * @param {W3CCapabilities<C>} [w3cCapabilities2]
-   * @param {W3CCapabilities<C>} [w3cCapabilities]
-   * @param {DriverData[]} [driverData]
-   * @returns {Promise<[string,Capabilities<C>]>}
    */
-  async createSession(w3cCapabilities1, w3cCapabilities2, w3cCapabilities, driverData) {
+  async createSession(
+    w3cCapabilities1: W3CDriverCaps<C>,
+    w3cCapabilities2?: W3CDriverCaps<C>,
+    w3cCapabilities?: W3CDriverCaps<C>,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    driverData?: DriverData[]
+  ): Promise<DefaultCreateSessionResult<C>> {
     if (this.sessionId !== null) {
       throw new errors.SessionNotCreatedError(
         'Cannot create a new session while one is in progress'
@@ -289,15 +257,14 @@ export class BaseDriverCore extends DriverCore {
       `Creating session with W3C capabilities: ${JSON.stringify(originalCaps, null, 2)}`
     );
 
-    /** @type {Capabilities<C>} */
-    let caps;
+    let caps: DriverCaps<C>;
     try {
       caps = processCapabilities(
         originalCaps,
         this._desiredCapConstraints,
         this.shouldValidateCaps
-      );
-      caps = fixCaps(caps, this._desiredCapConstraints, this.log);
+      ) as DriverCaps<C>;
+      caps = fixCaps(caps, this._desiredCapConstraints, this.log) as DriverCaps<C>;
     } catch (e) {
       throw new errors.SessionNotCreatedError(e.message);
     }
@@ -334,7 +301,7 @@ export class BaseDriverCore extends DriverCore {
     }
 
     if (!_.isUndefined(this.caps.newCommandTimeout)) {
-      this.newCommandTimeoutMs = /** @type {number} */ (this.caps.newCommandTimeout) * 1000;
+      this.newCommandTimeoutMs = (this.caps.newCommandTimeout as number) * 1000;
     }
 
     this._log.prefix = helpers.generateDriverLogPrefix(this, this.sessionId);
@@ -344,32 +311,23 @@ export class BaseDriverCore extends DriverCore {
     return [this.sessionId, caps];
   }
 
-  /**
-   *
-   * @param {string} [sessionId]
-   * @param {DriverData[]} [driverData]
-   * @returns {Promise<void>}
-   */
-  async deleteSession(sessionId, driverData) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async deleteSession(sessionId?: string | null) {
     await this.clearNewCommandTimeout();
     if (this.isCommandsQueueEnabled && this.commandsQueueGuard.isBusy()) {
       // simple hack to release pending commands if they exist
-      // @ts-ignore
-      for (const key of _.keys(this.commandsQueueGuard.queues)) {
-        // @ts-ignore
-        this.commandsQueueGuard.queues[key] = [];
+      // @ts-expect-error private API
+      const queues = this.commandsQueueGuard.queues;
+      for (const key of _.keys(queues)) {
+        queues[key] = [];
       }
     }
     this.sessionId = null;
     this._log.prefix = helpers.generateDriverLogPrefix(this);
   }
 
-  /**
-   *
-   * @param {Capabilities<C>} caps
-   */
-  logExtraCaps(caps) {
-    let extraCaps = _.difference(_.keys(caps), _.keys(this._desiredCapConstraints));
+  logExtraCaps(caps: Capabilities<C>) {
+    const extraCaps = _.difference(_.keys(caps), _.keys(this._desiredCapConstraints));
     if (extraCaps.length) {
       this.log.warn(
         `The following capabilities were provided, but are not ` + `recognized by Appium:`
@@ -380,12 +338,7 @@ export class BaseDriverCore extends DriverCore {
     }
   }
 
-  /**
-   *
-   * @param {Capabilities<C>} caps
-   * @returns {boolean}
-   */
-  validateDesiredCaps(caps) {
+  validateDesiredCaps(caps: any): caps is DriverCaps<C> {
     if (!this.shouldValidateCaps) {
       return true;
     }
@@ -407,68 +360,6 @@ export class BaseDriverCore extends DriverCore {
   }
 }
 
-/**
- * This ensures that all of the mixins correctly implement the interface described in {@linkcode Driver}.
- * @template {Constraints} [C={}]
- * @implements {Driver<C>}
- */
-export class BaseDriver extends createBaseDriverClass(BaseDriverCore) {}
-export default BaseDriver;
+export * from './commands';
 
-/**
- * @typedef {import('@appium/types').HTTPMethod} HTTPMethod
- * @typedef {import('@appium/types').DriverData} DriverData
- * @typedef {import('@appium/types').Constraints} Constraints
- * @typedef {import('@appium/types').Constraint} Constraint
- * @typedef {import('@appium/types').StringRecord} StringRecord
- * @typedef {import('@appium/types').BaseDriverCapConstraints} BaseDriverCapConstraints
- * @typedef {import('@appium/types').ServerArgs} ServerArgs
- */
-
-/**
- * @callback UpdateServerCallback
- * @param {import('express').Express} app - Express app
- * @param {import('@appium/types').AppiumServer} httpServer - HTTP server
- * @returns {import('type-fest').Promisable<void>}
- */
-
-/**
- * This is used to extend {@linkcode BaseDriverCore} by the mixins and also external drivers.
- * @template {Constraints} C
- * @template [Proto={}]
- * @template [Static={}]
- * @typedef {import('@appium/types').Class<BaseDriverCore<C> & Proto,import('@appium/types').DriverStatic & Static>} BaseDriverBase
- */
-
-/**
- * @template {Constraints} [C=BaseDriverCapConstraints]
- * @typedef {import('@appium/types').SessionHandler<[string, object],void, C>} SessionHandler
- */
-
-/**
- * @template {Constraints} [C=BaseDriverCapConstraints]
- * @template {StringRecord|void} [Extra=void]
- * @typedef {import('@appium/types').Capabilities<C, Extra>} Capabilities
- */
-
-/**
- * @template {Constraints} [C=BaseDriverCapConstraints]
- * @template {StringRecord|void} [Extra=void]
- * @typedef {import('@appium/types').W3CCapabilities<C, Extra>} W3CCapabilities
- */
-
-/**
- * @template {Constraints} [C=BaseDriverCapConstraints]
- * @template {StringRecord} [CArgs=StringRecord]
- * @typedef {import('@appium/types').Driver<C, CArgs>} Driver
- */
-
-/**
- * @template {Constraints} C
- * @typedef {import('@appium/types').ExternalDriver<C>} ExternalDriver
- */
-
-/**
- * @template {Constraints} C
- * @typedef {import('@appium/types').DriverOpts<C>} DriverOpts
- */
+export default BaseDriver;