@appium/base-driver 9.3.3 → 9.3.4

package/lib/basedriver/capabilities.js

@@ -11,19 +11,24 @@ const PREFIXED_APPIUM_OPTS_CAP = `${APPIUM_VENDOR_PREFIX}options`;
 
 /**
  * Takes primary caps object and merges it into a secondary caps object.
- * @template {Constraints} [T={}]
- * @template {Constraints} [U={}]
- * @param {Capabilities<T>} [primary]
- * @param {Capabilities<U>} [secondary]
- * @returns {Merge<Capabilities<T>, Capabilities<U>>}
+ * @template {Constraints} T
+ * @template {Constraints} U
+ * @template {Capabilities<T>} Primary
+ * @template {Capabilities<U>} Secondary
+ * @param {Primary} [primary]
+ * @param {Secondary} [secondary]
+ * @returns {MergeExclusive<Primary, Secondary>}
  * @see https://www.w3.org/TR/webdriver/#dfn-merging-capabilities)
  */
-function mergeCaps(primary = {}, secondary = {}) {
-  let result = /** @type {Merge<Capabilities<T>, Capabilities<U>>} */ ({
+function mergeCaps(
+  primary = /** @type {Primary} */ ({}),
+  secondary = /** @type {Secondary} */ ({})
+) {
+  let result = /** @type {MergeExclusive<Primary, Secondary>} */ ({
     ...primary,
   });
 
-  for (let [name, value] of /** @type {[keyof typeof secondary, any]} */ (_.toPairs(secondary))) {
+  for (let [name, value] of Object.entries(secondary)) {
     // Overwriting is not allowed. Primary and secondary must have different properties (w3c rule 4.4)
     if (!_.isUndefined(primary[name])) {
       throw new errors.InvalidArgumentError(
@@ -38,9 +43,9 @@ function mergeCaps(primary = {}, secondary = {}) {
   return result;
 }
 
-// Validates caps against a set of constraints
 /**
- * @template {Constraints} [C={}]
+ * Validates caps against a set of constraints
+ * @template {Constraints} C
  * @param {Capabilities<C>} caps
  * @param {C} [constraints]
  * @param {ValidateCapsOpts} [opts]
@@ -121,11 +126,11 @@ function isStandardCap(cap) {
 
 /**
  * If the 'appium:' prefix was provided and it's a valid capability, strip out the prefix
- * @template {Constraints} [C={}]
- * @param {import('@appium/types').NSCapabilities<C>} caps
+ * @template {Constraints} C
+ * @param {NSCapabilities<C>} caps
  * @see https://www.w3.org/TR/webdriver/#dfn-extension-capabilities
  * @internal
- * @returns {import('@appium/types').Capabilities<C>}
+ * @returns {Capabilities<C>}
  */
 function stripAppiumPrefixes(caps) {
   // split into prefixed and non-prefixed.
@@ -135,14 +140,12 @@ function stripAppiumPrefixes(caps) {
   );
 
   // initialize this with the k/v pairs of the non-prefixed caps
-  let strippedCaps = /** @type {import('@appium/types').Capabilities<C>} */ (
-    _.pick(caps, nonPrefixedCaps)
-  );
+  let strippedCaps = /** @type {Capabilities<C>} */ (_.pick(caps, nonPrefixedCaps));
   const badPrefixedCaps = [];
 
   // Strip out the 'appium:' prefix
   for (let prefixedCap of prefixedCaps) {
-    const strippedCapName = /** @type {StringKeyOf<import('@appium/types').Capabilities<C>>} */ (
+    const strippedCapName = /** @type {StringKeyOf<Capabilities<C>>} */ (
       prefixedCap.substring(APPIUM_VENDOR_PREFIX.length)
     );
 
@@ -175,8 +178,8 @@ function stripAppiumPrefixes(caps) {
 
 /**
  * Get an array of all the unprefixed caps that are being used in 'alwaysMatch' and all of the 'firstMatch' object
- * @template {Constraints} [C={}]
- * @param {import('@appium/types').W3CCapabilities<C>} caps A capabilities object
+ * @template {Constraints} C
+ * @param {W3CCapabilities<C>} caps A capabilities object
  */
 function findNonPrefixedCaps({alwaysMatch = {}, firstMatch = []}) {
   return _.chain([alwaysMatch, ...firstMatch])
@@ -191,13 +194,25 @@ function findNonPrefixedCaps({alwaysMatch = {}, firstMatch = []}) {
     .value();
 }
 
+/**
+ * Returned by {@linkcode parseCaps}
+ * @template {Constraints} C
+ * @typedef ParsedCaps
+ * @property {NSCapabilities<C>[]} allFirstMatchCaps
+ * @property {Capabilities<C>[]} validatedFirstMatchCaps
+ * @property {NSCapabilities<C>} requiredCaps
+ * @property {Capabilities<C>|null} matchedCaps
+ * @property {string[]} validationErrors
+ */
+
 /**
  * Parse capabilities
- * @template {Constraints} [C={}]
- * @param {import('@appium/types').W3CCapabilities<C>} caps
+ * @template {Constraints} C
+ * @param {W3CCapabilities<C>} caps
  * @param {C} [constraints]
  * @param {boolean} [shouldValidateCaps]
  * @see https://www.w3.org/TR/webdriver/#processing-capabilities
+ * @returns {ParsedCaps<C>}
  */
 function parseCaps(caps, constraints = /** @type {C} */ ({}), shouldValidateCaps = true) {
   // If capabilities request is not an object, return error (#1.1)
@@ -210,8 +225,8 @@ function parseCaps(caps, constraints = /** @type {C} */ ({}), shouldValidateCaps
   // Let 'requiredCaps' be property named 'alwaysMatch' from capabilities request (#2)
   // and 'allFirstMatchCaps' be property named 'firstMatch' from capabilities request (#3)
   let {
-    alwaysMatch: requiredCaps = {}, // If 'requiredCaps' is undefined, set it to an empty JSON object (#2.1)
-    firstMatch: allFirstMatchCaps = [{}], // If 'firstMatch' is undefined set it to a singleton list with one empty object (#3.1)
+    alwaysMatch: requiredCaps = /** @type {NSCapabilities<C>} */ ({}), // If 'requiredCaps' is undefined, set it to an empty JSON object (#2.1)
+    firstMatch: allFirstMatchCaps = /** @type {NSCapabilities<C>[]} */ ([{}]), // If 'firstMatch' is undefined set it to a singleton list with one empty object (#3.1)
   } = caps;
 
   // Reject 'firstMatch' argument if it's not an array (#3.2)
@@ -241,6 +256,7 @@ function parseCaps(caps, constraints = /** @type {C} */ ({}), shouldValidateCaps
 
   // Strip out the 'appium:' prefix from all
   let strippedRequiredCaps = stripAppiumPrefixes(requiredCaps);
+  /** @type {Capabilities<C>[]} */
   let strippedAllFirstMatchCaps = allFirstMatchCaps.map(stripAppiumPrefixes);
 
   // Validate the requiredCaps. But don't validate 'presence' because if that constraint fails on 'alwaysMatch' it could still pass on one of the 'firstMatch' keys
@@ -259,24 +275,23 @@ function parseCaps(caps, constraints = /** @type {C} */ ({}), shouldValidateCaps
   /** @type {string[]} */
   let validationErrors = [];
   let validatedFirstMatchCaps = _.compact(
-    strippedAllFirstMatchCaps.map(
-      /**
-       * @param {import('@appium/types').Capabilities<C>} firstMatchCaps
-       */
-      (firstMatchCaps) => {
-        try {
-          // Validate firstMatch caps
-          return shouldValidateCaps
-            ? validateCaps(firstMatchCaps, filteredConstraints)
-            : firstMatchCaps;
-        } catch (e) {
-          validationErrors.push(e.message);
-        }
+    strippedAllFirstMatchCaps.map((firstMatchCaps) => {
+      try {
+        // Validate firstMatch caps
+        return shouldValidateCaps
+          ? validateCaps(firstMatchCaps, filteredConstraints)
+          : firstMatchCaps;
+      } catch (e) {
+        validationErrors.push(e.message);
       }
-    )
+    })
   );
 
-  // Try to merge requiredCaps with first match capabilities, break once it finds its first match (see spec #6)
+  /**
+   * Try to merge requiredCaps with first match capabilities, break once it finds its first match
+   * (see spec #6)
+   * @type {ParsedCaps<C>['matchedCaps']}
+   */
   let matchedCaps = null;
   for (let firstMatchCaps of validatedFirstMatchCaps) {
     try {
@@ -300,13 +315,14 @@ function parseCaps(caps, constraints = /** @type {C} */ ({}), shouldValidateCaps
   };
 }
 
-// Calls parseCaps and just returns the matchedCaps variable
 /**
+ * Calls parseCaps and just returns the matchedCaps variable
  * @template {Constraints} C
- * @param {import('@appium/types').W3CCapabilities<C>} w3cCaps
+ * @template {W3CCapabilities<C>} W3CCaps
+ * @param {W3CCaps} w3cCaps
  * @param {C} [constraints]
  * @param {boolean} [shouldValidateCaps]
- * @returns {import('@appium/types').Capabilities<C>}
+ * @returns {Capabilities<C>}
  */
 function processCapabilities(
   w3cCaps,
@@ -400,8 +416,8 @@ function promoteAppiumOptionsForObject(obj) {
  * capability and promoted it to the top level.
  *
  * @template {Constraints} C
- * @param {import('@appium/types').W3CCapabilities<C>} originalCaps
- * @return {import('@appium/types').W3CCapabilities<C>} the capabilities with 'options' promoted if necessary
+ * @param {W3CCapabilities<C>} originalCaps
+ * @return {W3CCapabilities<C>} the capabilities with 'options' promoted if necessary
  */
 function promoteAppiumOptions(originalCaps) {
   const result = {};
@@ -451,28 +467,26 @@ export {
  */
 
 /**
- * @template {Constraints} [C=BaseDriverCapConstraints]
- * @template {StringRecord|void} [Extra=void]
- * @typedef {import('@appium/types').NSCapabilities<C, Extra>} NSCapabilities
+ * @template {Constraints} C
+ * @typedef {import('@appium/types').NSCapabilities<C>} NSCapabilities
  */
 
 /**
- * @template {Constraints} [C=BaseDriverCapConstraints]
- * @template {StringRecord|void} [Extra=void]
- * @typedef {import('@appium/types').Capabilities<C, Extra>} Capabilities
+ * @template {Constraints} C
+ * @typedef {import('@appium/types').Capabilities<C>} Capabilities
  */
 
 /**
- * @template {Constraints} [C=BaseDriverCapConstraints]
- * @template {StringRecord|void} [Extra=void]
- * @typedef {import('@appium/types').W3CCapabilities<C, Extra>} W3CCapabilities
+ * @template {Constraints} C
+ * @typedef {import('@appium/types').W3CCapabilities<C>} W3CCapabilities
  */
 
-/**
- * @template T,U
- * @typedef {import('type-fest').Merge<T,U>} Merge
- */
 /**
  * @template T
  * @typedef {import('type-fest').StringKeyOf<T>} StringKeyOf
  */
+
+/**
+ * @template T,U
+ * @typedef {import('type-fest').MergeExclusive<T, U>} MergeExclusive<T,U>
+ */

package/lib/basedriver/commands/event.ts

@@ -1,9 +1,10 @@
-import _ from 'lodash';
 import {Constraints, IEventCommands} from '@appium/types';
-import {mixin} from './mixin';
+import _ from 'lodash';
 import {BaseDriver} from '../driver';
+import {mixin} from './mixin';
 
 declare module '../driver' {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   interface BaseDriver<C extends Constraints> extends IEventCommands {}
 }
 

package/lib/basedriver/commands/execute.ts

@@ -12,6 +12,7 @@ import {mixin} from './mixin';
 import {BaseDriver} from '../driver';
 
 declare module '../driver' {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   interface BaseDriver<C extends Constraints> extends IExecuteCommands {}
 }
 
@@ -19,7 +20,7 @@ const ExecuteCommands: IExecuteCommands = {
   async executeMethod<C extends Constraints>(
     this: BaseDriver<C>,
     script: string,
-    protoArgs: [StringRecord] | any[]
+    protoArgs: readonly [StringRecord<unknown>] | readonly unknown[]
   ) {
     const Driver = this.constructor as DriverClass<Driver<C>>;
     const commandMetadata = {...Driver.executeMethodMap?.[script]};

package/lib/basedriver/commands/find.ts

@@ -4,6 +4,7 @@ import {BaseDriver} from '../driver';
 import {mixin} from './mixin';
 
 declare module '../driver' {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   interface BaseDriver<C extends Constraints> extends IFindCommands {}
 }
 

package/lib/basedriver/commands/index.ts

@@ -1,7 +1,7 @@
-export * from './event';
-export * from './find';
-export * from './log';
-export * from './session';
-export * from './settings';
-export * from './timeout';
-export * from './execute';
+import './event';
+import './find';
+import './log';
+import './session';
+import './settings';
+import './timeout';
+import './execute';

package/lib/basedriver/commands/log.ts

@@ -4,6 +4,7 @@ import {BaseDriver} from '../driver';
 import {mixin} from './mixin';
 
 declare module '../driver' {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   interface BaseDriver<C extends Constraints> extends ILogCommands {}
 }
 
@@ -15,10 +16,7 @@ const LogCommands: ILogCommands = {
     return Object.keys(this.supportedLogTypes);
   },
 
-  async getLog<C extends Constraints>(
-    this: Driver<C>,
-    logType: keyof ILogCommands['supportedLogTypes']
-  ) {
+  async getLog<C extends Constraints>(this: Driver<C>, logType: string) {
     this.log.debug(`Retrieving '${String(logType)}' logs`);
 
     if (!(logType in this.supportedLogTypes)) {

package/lib/basedriver/commands/mixin.ts

@@ -2,13 +2,14 @@ import {Constraints} from '@appium/types';
 import {BaseDriver} from '../driver';
 
 /**
- * This function assigns a mixin `T` to the `FakeDriver` class' prototype.
- * While each mixin has its own interface which is (in isolation) unrelated to `FakeDriver`, the constraint
- * on this generic type `T` is that it must be a partial of `FakeDriver`'s interface. This enforces
- * that it does not conflict with the existing interface of `FakeDriver`.  In that way, you can
+ * This function assigns a mixin `T` to the `BaseDriver` class' prototype.
+ * While each mixin has its own interface which is (in isolation) unrelated to `BaseDriver`, the constraint
+ * on this generic type `T` is that it must be a partial of `BaseDriver`'s interface. This enforces
+ * that it does not conflict with the existing interface of `BaseDriver`.  In that way, you can
  * think of it as a type guard.
  * @param mixin Mixin implementation
  */
 export function mixin<C extends Constraints, T extends Partial<BaseDriver<C>>>(mixin: T): void {
+  // eslint-disable-next-line no-restricted-syntax
   Object.assign(BaseDriver.prototype, mixin);
 }

package/lib/basedriver/commands/session.ts

@@ -1,14 +1,17 @@
-import {Constraints, ISessionCommands, MultiSessionData} from '@appium/types';
+import {Constraints, ISessionCommands, MultiSessionData, SingularSessionData} from '@appium/types';
 import {BaseDriver} from '../driver';
 import {mixin} from './mixin';
 
 declare module '../driver' {
-  interface BaseDriver<C extends Constraints> extends ISessionCommands {}
+  interface BaseDriver<
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    C extends Constraints
+  > extends ISessionCommands {}
 }
 
 const SessionCommands: ISessionCommands = {
   async getSessions<C extends Constraints>(this: BaseDriver<C>) {
-    const ret: MultiSessionData[] = [];
+    const ret: MultiSessionData<C>[] = [];
 
     if (this.sessionId) {
       ret.push({
@@ -24,10 +27,9 @@ const SessionCommands: ISessionCommands = {
    * Returns capabilities for the session and event history (if applicable)
    */
   async getSession<C extends Constraints>(this: BaseDriver<C>) {
-    if (this.caps.eventTimings) {
-      return {...this.caps, events: this.eventHistory};
-    }
-    return this.caps;
+    return <SingularSessionData<C>>(
+      (this.caps.eventTimings ? {...this.caps, events: this.eventHistory} : this.caps)
+    );
   },
 };
 

package/lib/basedriver/commands/settings.ts

@@ -3,6 +3,7 @@ import {Constraints, ISettingsCommands, StringRecord} 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 ISettingsCommands {}
 }
 

package/lib/basedriver/commands/timeout.ts

@@ -1,7 +1,3 @@
-// @ts-check
-
-/* eslint-disable no-unused-vars */
-/* eslint-disable require-await */
 import {waitForCondition} from 'asyncbox';
 import _ from 'lodash';
 import {util} from '@appium/support';
@@ -11,13 +7,14 @@ 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(type, ms, script, pageLoad, implicit) {
+  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})}}`);
 
@@ -66,42 +63,42 @@ const TimeoutCommands: ITimeoutCommands = {
   },
 
   // implicit
-  async implicitWaitW3C(ms) {
+  async implicitWaitW3C<C extends Constraints>(this: BaseDriver<C>, ms) {
     await this.implicitWait(ms);
   },
 
-  async implicitWaitMJSONWP(ms) {
+  async implicitWaitMJSONWP<C extends Constraints>(this: BaseDriver<C>, ms) {
     await this.implicitWait(ms);
   },
 
-  async implicitWait(ms) {
-    await this.setImplicitWait(this.parseTimeoutArgument(ms));
+  async implicitWait<C extends Constraints>(this: BaseDriver<C>, ms) {
+    this.setImplicitWait(this.parseTimeoutArgument(ms));
   },
 
   // pageLoad
-  async pageLoadTimeoutW3C(ms) {
+  async pageLoadTimeoutW3C<C extends Constraints>(this: BaseDriver<C>, ms) {
     throw new errors.NotImplementedError('Not implemented yet for pageLoad.');
   },
 
-  async pageLoadTimeoutMJSONWP(ms) {
+  async pageLoadTimeoutMJSONWP<C extends Constraints>(this: BaseDriver<C>, ms) {
     throw new errors.NotImplementedError('Not implemented yet for pageLoad.');
   },
 
   // script
-  async scriptTimeoutW3C(ms) {
+  async scriptTimeoutW3C<C extends Constraints>(this: BaseDriver<C>, ms) {
     throw new errors.NotImplementedError('Not implemented yet for script.');
   },
 
-  async scriptTimeoutMJSONWP(ms) {
+  async scriptTimeoutMJSONWP<C extends Constraints>(this: BaseDriver<C>, ms) {
     throw new errors.NotImplementedError('Not implemented yet for script.');
   },
 
   // command
-  async newCommandTimeout(ms) {
+  async newCommandTimeout<C extends Constraints>(this: BaseDriver<C>, ms) {
     this.setNewCommandTimeout(this.parseTimeoutArgument(ms));
   },
 
-  setImplicitWait(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`);
@@ -115,7 +112,7 @@ const TimeoutCommands: ITimeoutCommands = {
     }
   },
 
-  setNewCommandTimeout(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) {
@@ -128,7 +125,10 @@ const TimeoutCommands: ITimeoutCommands = {
     }
   },
 
-  async implicitWaitForCondition(condFn) {
+  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

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 {
   /**
@@ -40,7 +38,7 @@ class DriverCore {
   opts;
 
   /**
-   * @type {ServerArgs}
+   * @type {import('@appium/types').DriverOpts<C>}
    */
   initialOpts;
 
@@ -98,7 +96,6 @@ class DriverCore {
   _log;
 
   /**
-   * @protected
    * @type {boolean}
    */
   shutdownUnexpectedly;
@@ -119,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;
 
@@ -184,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} */ ({});
   }
 
   /**
@@ -260,7 +255,7 @@ class DriverCore {
    * @returns {Core<C> | null}
    */
   driverForSession(sessionId) {
-    return this;
+    return /** @type {Core<C> | null} */ (this);
   }
 
   isMjsonwpProtocol() {
@@ -448,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
  */