@appium/base-driver 8.5.3 → 8.5.4

package/lib/protocol/routes.js

@@ -1,202 +1,241 @@
 // @ts-check
 
 import _ from 'lodash';
-import { util } from '@appium/support';
-import { PROTOCOLS, DEFAULT_BASE_PATH } from '../constants';
-
+import {util} from '@appium/support';
+import {PROTOCOLS, DEFAULT_BASE_PATH} from '../constants';
 
 const SET_ALERT_TEXT_PAYLOAD_PARAMS = {
-  validate: (jsonObj) => (!util.hasValue(jsonObj.value) && !util.hasValue(jsonObj.text)) &&
-      'either "text" or "value" must be set',
+  validate: (jsonObj) =>
+    !util.hasValue(jsonObj.value) &&
+    !util.hasValue(jsonObj.text) &&
+    'either "text" or "value" must be set',
   optional: ['value', 'text'],
   // Prefer 'value' since it's more backward-compatible.
   makeArgs: (jsonObj) => [jsonObj.value || jsonObj.text],
 };
 
-// define the routes, mapping of HTTP methods to particular driver commands,
-// and any parameters that are expected in a request
-// parameters can be `required` or `optional`
-/** @type {import('@appium/types').MethodMap} */
+/**
+ * define the routes, mapping of HTTP methods to particular driver commands, and
+ * any parameters that are expected in a request parameters can be `required` or
+ * `optional`
+ * @type {MethodMap}
+ */
 const METHOD_MAP = {
   '/status': {
-    GET: {command: 'getStatus'}
+    GET: {command: 'getStatus'},
   },
   '/session': {
-    POST: {command: 'createSession', payloadParams: {
-      validate: (jsonObj) => (!jsonObj.capabilities && !jsonObj.desiredCapabilities) && 'we require one of "desiredCapabilities" or "capabilities" object',
-      optional: ['desiredCapabilities', 'requiredCapabilities', 'capabilities']}}
+    POST: {
+      command: 'createSession',
+      payloadParams: {
+        validate: (jsonObj) =>
+          !jsonObj.capabilities &&
+          !jsonObj.desiredCapabilities &&
+          'we require one of "desiredCapabilities" or "capabilities" object',
+        optional: ['desiredCapabilities', 'requiredCapabilities', 'capabilities'],
+      },
+    },
   },
   '/sessions': {
-    GET: {command: 'getSessions'}
+    GET: {command: 'getSessions'},
   },
   '/session/:sessionId': {
     GET: {command: 'getSession'},
-    DELETE: {command: 'deleteSession'}
+    DELETE: {command: 'deleteSession'},
   },
   '/session/:sessionId/timeouts': {
     GET: {command: 'getTimeouts'}, // W3C route
-    POST: {command: 'timeouts', payloadParams: {
-      validate: (jsonObj, protocolName) => {
-        if (protocolName === PROTOCOLS.W3C) {
-          if (!util.hasValue(jsonObj.script) && !util.hasValue(jsonObj.pageLoad) && !util.hasValue(jsonObj.implicit)) {
-            return 'W3C protocol expects any of script, pageLoad or implicit to be set';
-          }
-        } else {
-          // MJSONWP
-          if (!util.hasValue(jsonObj.type) || !util.hasValue(jsonObj.ms)) {
-            return 'MJSONWP protocol requires type and ms';
+    POST: {
+      command: 'timeouts',
+      payloadParams: {
+        validate: (jsonObj, protocolName) => {
+          if (protocolName === PROTOCOLS.W3C) {
+            if (
+              !util.hasValue(jsonObj.script) &&
+              !util.hasValue(jsonObj.pageLoad) &&
+              !util.hasValue(jsonObj.implicit)
+            ) {
+              return 'W3C protocol expects any of script, pageLoad or implicit to be set';
+            }
+          } else {
+            // MJSONWP
+            if (!util.hasValue(jsonObj.type) || !util.hasValue(jsonObj.ms)) {
+              return 'MJSONWP protocol requires type and ms';
+            }
           }
-        }
+        },
+        optional: ['type', 'ms', 'script', 'pageLoad', 'implicit'],
       },
-      optional: ['type', 'ms', 'script', 'pageLoad', 'implicit'],
-    }}
+    },
   },
   '/session/:sessionId/timeouts/async_script': {
-    POST: {command: 'asyncScriptTimeout', payloadParams: {required: ['ms']}}
+    POST: {command: 'asyncScriptTimeout', payloadParams: {required: ['ms']}},
   },
   '/session/:sessionId/timeouts/implicit_wait': {
-    POST: {command: 'implicitWait', payloadParams: {required: ['ms']}}
+    POST: {command: 'implicitWait', payloadParams: {required: ['ms']}},
   },
   // JSONWP
   '/session/:sessionId/window_handle': {
-    GET: {command: 'getWindowHandle'}
+    GET: {command: 'getWindowHandle'},
   },
   // W3C
   '/session/:sessionId/window/handle': {
-    GET: {command: 'getWindowHandle'}
+    GET: {command: 'getWindowHandle'},
   },
   // JSONWP
   '/session/:sessionId/window_handles': {
-    GET: {command: 'getWindowHandles'}
+    GET: {command: 'getWindowHandles'},
   },
   // W3C
   '/session/:sessionId/window/handles': {
-    GET: {command: 'getWindowHandles'}
+    GET: {command: 'getWindowHandles'},
   },
   '/session/:sessionId/url': {
     GET: {command: 'getUrl'},
-    POST: {command: 'setUrl', payloadParams: {required: ['url']}}
+    POST: {command: 'setUrl', payloadParams: {required: ['url']}},
   },
   '/session/:sessionId/forward': {
-    POST: {command: 'forward'}
+    POST: {command: 'forward'},
   },
   '/session/:sessionId/back': {
-    POST: {command: 'back'}
+    POST: {command: 'back'},
   },
   '/session/:sessionId/refresh': {
-    POST: {command: 'refresh'}
+    POST: {command: 'refresh'},
   },
   // MJSONWP
   '/session/:sessionId/execute': {
-    POST: {command: 'execute', payloadParams: {required: ['script', 'args']}}
+    POST: {command: 'execute', payloadParams: {required: ['script', 'args']}},
   },
   // MJSONWP
   '/session/:sessionId/execute_async': {
-    POST: {command: 'executeAsync', payloadParams: {required: ['script', 'args']}}
+    POST: {
+      command: 'executeAsync',
+      payloadParams: {required: ['script', 'args']},
+    },
   },
   '/session/:sessionId/screenshot': {
-    GET: {command: 'getScreenshot'}
+    GET: {command: 'getScreenshot'},
   },
   '/session/:sessionId/ime/available_engines': {
-    GET: {command: 'availableIMEEngines'}
+    GET: {command: 'availableIMEEngines'},
   },
   '/session/:sessionId/ime/active_engine': {
-    GET: {command: 'getActiveIMEEngine'}
+    GET: {command: 'getActiveIMEEngine'},
   },
   '/session/:sessionId/ime/activated': {
-    GET: {command: 'isIMEActivated'}
+    GET: {command: 'isIMEActivated'},
   },
   '/session/:sessionId/ime/deactivate': {
-    POST: {command: 'deactivateIMEEngine'}
+    POST: {command: 'deactivateIMEEngine'},
   },
   '/session/:sessionId/ime/activate': {
-    POST: {command: 'activateIMEEngine', payloadParams: {required: ['engine']}}
+    POST: {command: 'activateIMEEngine', payloadParams: {required: ['engine']}},
   },
   '/session/:sessionId/frame': {
-    POST: {command: 'setFrame', payloadParams: {required: ['id']}}
+    POST: {command: 'setFrame', payloadParams: {required: ['id']}},
   },
   '/session/:sessionId/frame/parent': {
-    POST: {}
+    POST: {},
   },
   '/session/:sessionId/window': {
     GET: {command: 'getWindowHandle'},
-    POST: {command: 'setWindow', payloadParams: {
-      optional: ['name', 'handle'],
-      // Return both values to match W3C and JSONWP protocols
-      makeArgs: (jsonObj) => {
-        if (util.hasValue(jsonObj.handle) && !util.hasValue(jsonObj.name)) {
-          return [jsonObj.handle, jsonObj.handle];
-        }
-        if (util.hasValue(jsonObj.name) && !util.hasValue(jsonObj.handle)) {
-          return [jsonObj.name, jsonObj.name];
-        }
-        return [jsonObj.name, jsonObj.handle];
+    POST: {
+      command: 'setWindow',
+      payloadParams: {
+        optional: ['name', 'handle'],
+        // Return both values to match W3C and JSONWP protocols
+        makeArgs: (jsonObj) => {
+          if (util.hasValue(jsonObj.handle) && !util.hasValue(jsonObj.name)) {
+            return [jsonObj.handle, jsonObj.handle];
+          }
+          if (util.hasValue(jsonObj.name) && !util.hasValue(jsonObj.handle)) {
+            return [jsonObj.name, jsonObj.name];
+          }
+          return [jsonObj.name, jsonObj.handle];
+        },
+        validate: (jsonObj) =>
+          !util.hasValue(jsonObj.name) &&
+          !util.hasValue(jsonObj.handle) &&
+          'we require one of "name" or "handle" to be set',
       },
-      validate: (jsonObj) => (!util.hasValue(jsonObj.name) && !util.hasValue(jsonObj.handle))
-        && 'we require one of "name" or "handle" to be set',
-    }},
-    DELETE: {command: 'closeWindow'}
+    },
+    DELETE: {command: 'closeWindow'},
   },
   '/session/:sessionId/window/:windowhandle/size': {
     GET: {command: 'getWindowSize'},
-    POST: {}
+    POST: {},
   },
   '/session/:sessionId/window/:windowhandle/position': {
     POST: {},
-    GET: {}
+    GET: {},
   },
   '/session/:sessionId/window/:windowhandle/maximize': {
-    POST: {command: 'maximizeWindow'}
+    POST: {command: 'maximizeWindow'},
   },
   '/session/:sessionId/cookie': {
     GET: {command: 'getCookies'},
     POST: {command: 'setCookie', payloadParams: {required: ['cookie']}},
-    DELETE: {command: 'deleteCookies'}
+    DELETE: {command: 'deleteCookies'},
   },
   '/session/:sessionId/cookie/:name': {
     GET: {command: 'getCookie'},
-    DELETE: {command: 'deleteCookie'}
+    DELETE: {command: 'deleteCookie'},
   },
   '/session/:sessionId/source': {
-    GET: {command: 'getPageSource'}
+    GET: {command: 'getPageSource'},
   },
   '/session/:sessionId/title': {
-    GET: {command: 'title'}
+    GET: {command: 'title'},
   },
   '/session/:sessionId/element': {
-    POST: {command: 'findElement', payloadParams: {required: ['using', 'value']}}
+    POST: {
+      command: 'findElement',
+      payloadParams: {required: ['using', 'value']},
+    },
   },
   '/session/:sessionId/elements': {
-    POST: {command: 'findElements', payloadParams: {required: ['using', 'value']}}
+    POST: {
+      command: 'findElements',
+      payloadParams: {required: ['using', 'value']},
+    },
   },
   '/session/:sessionId/element/active': {
     GET: {command: 'active'}, // W3C: https://w3c.github.io/webdriver/webdriver-spec.html#dfn-get-active-element
-    POST: {command: 'active'}
+    POST: {command: 'active'},
   },
   '/session/:sessionId/element/:elementId': {
-    GET: {}
+    GET: {},
   },
   '/session/:sessionId/element/:elementId/element': {
-    POST: {command: 'findElementFromElement', payloadParams: {required: ['using', 'value']}}
+    POST: {
+      command: 'findElementFromElement',
+      payloadParams: {required: ['using', 'value']},
+    },
   },
   '/session/:sessionId/element/:elementId/elements': {
-    POST: {command: 'findElementsFromElement', payloadParams: {required: ['using', 'value']}}
+    POST: {
+      command: 'findElementsFromElement',
+      payloadParams: {required: ['using', 'value']},
+    },
   },
   '/session/:sessionId/element/:elementId/click': {
-    POST: {command: 'click'}
+    POST: {command: 'click'},
   },
   '/session/:sessionId/element/:elementId/submit': {
-    POST: {command: 'submit'}
+    POST: {command: 'submit'},
   },
   '/session/:sessionId/element/:elementId/text': {
-    GET: {command: 'getText'}
+    GET: {command: 'getText'},
   },
   '/session/:sessionId/element/:elementId/value': {
     POST: {
       command: 'setValue',
       payloadParams: {
-        validate: (jsonObj) => (!util.hasValue(jsonObj.value) && !util.hasValue(jsonObj.text)) &&
-            'we require one of "text" or "value" params',
+        validate: (jsonObj) =>
+          !util.hasValue(jsonObj.value) &&
+          !util.hasValue(jsonObj.text) &&
+          'we require one of "text" or "value" params',
         optional: ['value', 'text'],
         // override the default argument constructor because of the special
         // logic here. Basically we want to accept either a value (old JSONWP)
@@ -204,151 +243,168 @@ const METHOD_MAP = {
         // command (not both). Prefer 'value' since it's more
         // backward-compatible.
         makeArgs: (jsonObj) => [jsonObj.value || jsonObj.text],
-      }
-    }
+      },
+    },
   },
   '/session/:sessionId/keys': {
-    POST: {command: 'keys', payloadParams: {required: ['value']}}
+    POST: {command: 'keys', payloadParams: {required: ['value']}},
   },
   '/session/:sessionId/element/:elementId/name': {
-    GET: {command: 'getName'}
+    GET: {command: 'getName'},
   },
   '/session/:sessionId/element/:elementId/clear': {
-    POST: {command: 'clear'}
+    POST: {command: 'clear'},
   },
   '/session/:sessionId/element/:elementId/selected': {
-    GET: {command: 'elementSelected'}
+    GET: {command: 'elementSelected'},
   },
   '/session/:sessionId/element/:elementId/enabled': {
-    GET: {command: 'elementEnabled'}
+    GET: {command: 'elementEnabled'},
   },
   '/session/:sessionId/element/:elementId/attribute/:name': {
-    GET: {command: 'getAttribute'}
+    GET: {command: 'getAttribute'},
   },
   '/session/:sessionId/element/:elementId/equals/:otherId': {
-    GET: {command: 'equalsElement'}
+    GET: {command: 'equalsElement'},
   },
   '/session/:sessionId/element/:elementId/displayed': {
-    GET: {command: 'elementDisplayed'}
+    GET: {command: 'elementDisplayed'},
   },
   '/session/:sessionId/element/:elementId/location': {
-    GET: {command: 'getLocation'}
+    GET: {command: 'getLocation'},
   },
   '/session/:sessionId/element/:elementId/location_in_view': {
-    GET: {command: 'getLocationInView'}
+    GET: {command: 'getLocationInView'},
   },
   '/session/:sessionId/element/:elementId/size': {
-    GET: {command: 'getSize'}
+    GET: {command: 'getSize'},
   },
   '/session/:sessionId/element/:elementId/shadow': {
-    GET: {command: 'elementShadowRoot'}
+    GET: {command: 'elementShadowRoot'},
   },
   '/session/:sessionId/shadow/:shadowId/element': {
-    POST: {command: 'findElementFromShadowRoot', payloadParams: {required: ['using', 'value']}}
+    POST: {
+      command: 'findElementFromShadowRoot',
+      payloadParams: {required: ['using', 'value']},
+    },
   },
   '/session/:sessionId/shadow/:shadowId/elements': {
-    POST: {command: 'findElementsFromShadowRoot', payloadParams: {required: ['using', 'value']}}
+    POST: {
+      command: 'findElementsFromShadowRoot',
+      payloadParams: {required: ['using', 'value']},
+    },
   },
   '/session/:sessionId/element/:elementId/css/:propertyName': {
-    GET: {command: 'getCssProperty'}
+    GET: {command: 'getCssProperty'},
   },
   '/session/:sessionId/orientation': {
     GET: {command: 'getOrientation'},
-    POST: {command: 'setOrientation', payloadParams: {required: ['orientation']}}
+    POST: {
+      command: 'setOrientation',
+      payloadParams: {required: ['orientation']},
+    },
   },
   '/session/:sessionId/rotation': {
     GET: {command: 'getRotation'},
-    POST: {command: 'setRotation', payloadParams: {required: ['x', 'y', 'z']}}
+    POST: {command: 'setRotation', payloadParams: {required: ['x', 'y', 'z']}},
   },
   '/session/:sessionId/moveto': {
-    POST: {command: 'moveTo', payloadParams: {optional: ['element', 'xoffset', 'yoffset']}}
+    POST: {
+      command: 'moveTo',
+      payloadParams: {optional: ['element', 'xoffset', 'yoffset']},
+    },
   },
   '/session/:sessionId/click': {
-    POST: {command: 'clickCurrent', payloadParams: {optional: ['button']}}
+    POST: {command: 'clickCurrent', payloadParams: {optional: ['button']}},
   },
   '/session/:sessionId/buttondown': {
-    POST: {command: 'buttonDown', payloadParams: {optional: ['button']}}
+    POST: {command: 'buttonDown', payloadParams: {optional: ['button']}},
   },
   '/session/:sessionId/buttonup': {
-    POST: {command: 'buttonUp', payloadParams: {optional: ['button']}}
+    POST: {command: 'buttonUp', payloadParams: {optional: ['button']}},
   },
   '/session/:sessionId/doubleclick': {
-    POST: {command: 'doubleClick'}
+    POST: {command: 'doubleClick'},
   },
   '/session/:sessionId/touch/click': {
-    POST: {command: 'click', payloadParams: {required: ['element']}}
+    POST: {command: 'click', payloadParams: {required: ['element']}},
   },
   '/session/:sessionId/touch/down': {
-    POST: {command: 'touchDown', payloadParams: {required: ['x', 'y']}}
+    POST: {command: 'touchDown', payloadParams: {required: ['x', 'y']}},
   },
   '/session/:sessionId/touch/up': {
-    POST: {command: 'touchUp', payloadParams: {required: ['x', 'y']}}
+    POST: {command: 'touchUp', payloadParams: {required: ['x', 'y']}},
   },
   '/session/:sessionId/touch/move': {
-    POST: {command: 'touchMove', payloadParams: {required: ['x', 'y']}}
+    POST: {command: 'touchMove', payloadParams: {required: ['x', 'y']}},
   },
   '/session/:sessionId/touch/scroll': {
-    POST: {}
+    POST: {},
   },
   '/session/:sessionId/touch/doubleclick': {
-    POST: {}
+    POST: {},
   },
   '/session/:sessionId/actions': {
     POST: {command: 'performActions', payloadParams: {required: ['actions']}},
-    DELETE: {command: 'releaseActions'}
+    DELETE: {command: 'releaseActions'},
   },
   '/session/:sessionId/touch/longclick': {
-    POST: {command: 'touchLongClick', payloadParams: {required: ['elements']}}
+    POST: {command: 'touchLongClick', payloadParams: {required: ['elements']}},
   },
   '/session/:sessionId/touch/flick': {
-    POST: {command: 'flick', payloadParams: {optional: ['element', 'xspeed', 'yspeed', 'xoffset', 'yoffset', 'speed']}}
+    POST: {
+      command: 'flick',
+      payloadParams: {
+        optional: ['element', 'xspeed', 'yspeed', 'xoffset', 'yoffset', 'speed'],
+      },
+    },
   },
   '/session/:sessionId/location': {
     GET: {command: 'getGeoLocation'},
-    POST: {command: 'setGeoLocation', payloadParams: {required: ['location']}}
+    POST: {command: 'setGeoLocation', payloadParams: {required: ['location']}},
   },
   '/session/:sessionId/local_storage': {
     GET: {},
     POST: {},
-    DELETE: {}
+    DELETE: {},
   },
   '/session/:sessionId/local_storage/key/:key': {
     GET: {},
-    DELETE: {}
+    DELETE: {},
   },
   '/session/:sessionId/local_storage/size': {
-    GET: {}
+    GET: {},
   },
   '/session/:sessionId/session_storage': {
     GET: {},
     POST: {},
-    DELETE: {}
+    DELETE: {},
   },
   '/session/:sessionId/session_storage/key/:key': {
     GET: {},
-    DELETE: {}
+    DELETE: {},
   },
   '/session/:sessionId/session_storage/size': {
-    GET: {}
+    GET: {},
   },
   // Selenium 4 clients
   '/session/:sessionId/se/log': {
-    POST: {command: 'getLog', payloadParams: {required: ['type']}}
+    POST: {command: 'getLog', payloadParams: {required: ['type']}},
   },
   // Selenium 4 clients
   '/session/:sessionId/se/log/types': {
-    GET: {command: 'getLogTypes'}
+    GET: {command: 'getLogTypes'},
   },
   // mjsonwire, appium clients
   '/session/:sessionId/log': {
-    POST: {command: 'getLog', payloadParams: {required: ['type']}}
+    POST: {command: 'getLog', payloadParams: {required: ['type']}},
   },
   // mjsonwire, appium clients
   '/session/:sessionId/log/types': {
-    GET: {command: 'getLogTypes'}
+    GET: {command: 'getLogTypes'},
   },
   '/session/:sessionId/application_cache/status': {
-    GET: {}
+    GET: {},
   },
 
   //
@@ -356,107 +412,157 @@ const METHOD_MAP = {
   //
   '/session/:sessionId/context': {
     GET: {command: 'getCurrentContext'},
-    POST: {command: 'setContext', payloadParams: {required: ['name']}}
+    POST: {command: 'setContext', payloadParams: {required: ['name']}},
   },
   '/session/:sessionId/contexts': {
-    GET: {command: 'getContexts'}
+    GET: {command: 'getContexts'},
   },
   '/session/:sessionId/element/:elementId/pageIndex': {
-    GET: {command: 'getPageIndex'}
+    GET: {command: 'getPageIndex'},
   },
   '/session/:sessionId/network_connection': {
     GET: {command: 'getNetworkConnection'},
-    POST: {command: 'setNetworkConnection', payloadParams: {unwrap: 'parameters', required: ['type']}}
+    POST: {
+      command: 'setNetworkConnection',
+      payloadParams: {unwrap: 'parameters', required: ['type']},
+    },
   },
   '/session/:sessionId/touch/perform': {
-    POST: {command: 'performTouch', payloadParams: {wrap: 'actions', required: ['actions']}}
+    POST: {
+      command: 'performTouch',
+      payloadParams: {wrap: 'actions', required: ['actions']},
+    },
   },
   '/session/:sessionId/touch/multi/perform': {
-    POST: {command: 'performMultiAction', payloadParams: {required: ['actions'], optional: ['elementId']}}
+    POST: {
+      command: 'performMultiAction',
+      payloadParams: {required: ['actions'], optional: ['elementId']},
+    },
   },
   '/session/:sessionId/receive_async_response': {
-    POST: {command: 'receiveAsyncResponse', payloadParams: {required: ['status', 'value']}}
+    POST: {
+      command: 'receiveAsyncResponse',
+      payloadParams: {required: ['status', 'value']},
+    },
   },
   '/session/:sessionId/appium/device/shake': {
-    POST: {command: 'mobileShake'}
+    POST: {command: 'mobileShake'},
   },
   '/session/:sessionId/appium/device/system_time': {
     GET: {command: 'getDeviceTime', payloadParams: {optional: ['format']}},
-    POST: {command: 'getDeviceTime', payloadParams: {optional: ['format']}}
+    POST: {command: 'getDeviceTime', payloadParams: {optional: ['format']}},
   },
   '/session/:sessionId/appium/device/lock': {
-    POST: {command: 'lock', payloadParams: {optional: ['seconds']}}
+    POST: {command: 'lock', payloadParams: {optional: ['seconds']}},
   },
   '/session/:sessionId/appium/device/unlock': {
-    POST: {command: 'unlock'}
+    POST: {command: 'unlock'},
   },
   '/session/:sessionId/appium/device/is_locked': {
-    POST: {command: 'isLocked'}
+    POST: {command: 'isLocked'},
   },
   '/session/:sessionId/appium/start_recording_screen': {
-    POST: {command: 'startRecordingScreen', payloadParams: {optional: ['options']}}
+    POST: {
+      command: 'startRecordingScreen',
+      payloadParams: {optional: ['options']},
+    },
   },
   '/session/:sessionId/appium/stop_recording_screen': {
-    POST: {command: 'stopRecordingScreen', payloadParams: {optional: ['options']}}
+    POST: {
+      command: 'stopRecordingScreen',
+      payloadParams: {optional: ['options']},
+    },
   },
   '/session/:sessionId/appium/performanceData/types': {
-    POST: {command: 'getPerformanceDataTypes'}
+    POST: {command: 'getPerformanceDataTypes'},
   },
   '/session/:sessionId/appium/getPerformanceData': {
-    POST: {command: 'getPerformanceData', payloadParams: {required: ['packageName', 'dataType'], optional: ['dataReadTimeout']}}
+    POST: {
+      command: 'getPerformanceData',
+      payloadParams: {
+        required: ['packageName', 'dataType'],
+        optional: ['dataReadTimeout'],
+      },
+    },
   },
   '/session/:sessionId/appium/device/press_keycode': {
-    POST: {command: 'pressKeyCode', payloadParams: {required: ['keycode'], optional: ['metastate', 'flags']}}
+    POST: {
+      command: 'pressKeyCode',
+      payloadParams: {required: ['keycode'], optional: ['metastate', 'flags']},
+    },
   },
   '/session/:sessionId/appium/device/long_press_keycode': {
-    POST: {command: 'longPressKeyCode', payloadParams: {required: ['keycode'], optional: ['metastate', 'flags']}}
+    POST: {
+      command: 'longPressKeyCode',
+      payloadParams: {required: ['keycode'], optional: ['metastate', 'flags']},
+    },
   },
   '/session/:sessionId/appium/device/finger_print': {
-    POST: {command: 'fingerprint', payloadParams: {required: ['fingerprintId']}}
+    POST: {
+      command: 'fingerprint',
+      payloadParams: {required: ['fingerprintId']},
+    },
   },
   '/session/:sessionId/appium/device/send_sms': {
-    POST: {command: 'sendSMS', payloadParams: {required: ['phoneNumber', 'message']}}
+    POST: {
+      command: 'sendSMS',
+      payloadParams: {required: ['phoneNumber', 'message']},
+    },
   },
   '/session/:sessionId/appium/device/gsm_call': {
-    POST: {command: 'gsmCall', payloadParams: {required: ['phoneNumber', 'action']}}
+    POST: {
+      command: 'gsmCall',
+      payloadParams: {required: ['phoneNumber', 'action']},
+    },
   },
   '/session/:sessionId/appium/device/gsm_signal': {
     POST: {
       command: 'gsmSignal',
       payloadParams: {
-        validate: (jsonObj) => (!util.hasValue(jsonObj.signalStrength) && !util.hasValue(jsonObj.signalStrengh)) &&
-            'we require one of "signalStrength" or "signalStrengh" params',
+        validate: (jsonObj) =>
+          !util.hasValue(jsonObj.signalStrength) &&
+          !util.hasValue(jsonObj.signalStrengh) &&
+          'we require one of "signalStrength" or "signalStrengh" params',
         optional: ['signalStrength', 'signalStrengh'],
         // backward-compatible. sonObj.signalStrength can be 0
-        makeArgs: (jsonObj) => [util.hasValue(jsonObj.signalStrength) ? jsonObj.signalStrength : jsonObj.signalStrengh]
-      }
-    }
+        makeArgs: (jsonObj) => [
+          util.hasValue(jsonObj.signalStrength) ? jsonObj.signalStrength : jsonObj.signalStrengh,
+        ],
+      },
+    },
   },
   '/session/:sessionId/appium/device/gsm_voice': {
-    POST: {command: 'gsmVoice', payloadParams: {required: ['state']}}
+    POST: {command: 'gsmVoice', payloadParams: {required: ['state']}},
   },
   '/session/:sessionId/appium/device/power_capacity': {
-    POST: {command: 'powerCapacity', payloadParams: {required: ['percent']}}
+    POST: {command: 'powerCapacity', payloadParams: {required: ['percent']}},
   },
   '/session/:sessionId/appium/device/power_ac': {
-    POST: {command: 'powerAC', payloadParams: {required: ['state']}}
+    POST: {command: 'powerAC', payloadParams: {required: ['state']}},
   },
   '/session/:sessionId/appium/device/network_speed': {
-    POST: {command: 'networkSpeed', payloadParams: {required: ['netspeed']}}
+    POST: {command: 'networkSpeed', payloadParams: {required: ['netspeed']}},
   },
   '/session/:sessionId/appium/device/keyevent': {
-    POST: {command: 'keyevent', payloadParams: {required: ['keycode'], optional: ['metastate']}}
+    POST: {
+      command: 'keyevent',
+      payloadParams: {required: ['keycode'], optional: ['metastate']},
+    },
   },
   '/session/:sessionId/appium/device/rotate': {
-    POST: {command: 'mobileRotation', payloadParams: {
-      required: ['x', 'y', 'radius', 'rotation', 'touchCount', 'duration'],
-      optional: ['element'] }}
+    POST: {
+      command: 'mobileRotation',
+      payloadParams: {
+        required: ['x', 'y', 'radius', 'rotation', 'touchCount', 'duration'],
+        optional: ['element'],
+      },
+    },
   },
   '/session/:sessionId/appium/device/current_activity': {
-    GET: {command: 'getCurrentActivity'}
+    GET: {command: 'getCurrentActivity'},
   },
   '/session/:sessionId/appium/device/current_package': {
-    GET: {command: 'getCurrentPackage'}
+    GET: {command: 'getCurrentPackage'},
   },
   //region Applications Management
   '/session/:sessionId/appium/device/install_app': {
@@ -464,164 +570,199 @@ const METHOD_MAP = {
       command: 'installApp',
       payloadParams: {
         required: ['appPath'],
-        optional: ['options']
-      }
-    }
+        optional: ['options'],
+      },
+    },
   },
   '/session/:sessionId/appium/device/activate_app': {
     POST: {
       command: 'activateApp',
       payloadParams: {
         required: [['appId'], ['bundleId']],
-        optional: ['options']
-      }
-    }
+        optional: ['options'],
+      },
+    },
   },
   '/session/:sessionId/appium/device/remove_app': {
     POST: {
       command: 'removeApp',
       payloadParams: {
         required: [['appId'], ['bundleId']],
-        optional: ['options']
-      }
-    }
+        optional: ['options'],
+      },
+    },
   },
   '/session/:sessionId/appium/device/terminate_app': {
     POST: {
       command: 'terminateApp',
       payloadParams: {
         required: [['appId'], ['bundleId']],
-        optional: ['options']
-      }
-    }
+        optional: ['options'],
+      },
+    },
   },
   '/session/:sessionId/appium/device/app_installed': {
     POST: {
       command: 'isAppInstalled',
       payloadParams: {
-        required: [['appId'], ['bundleId']]
-      }
-    }
+        required: [['appId'], ['bundleId']],
+      },
+    },
   },
   '/session/:sessionId/appium/device/app_state': {
     GET: {
       command: 'queryAppState',
       payloadParams: {
-        required: [['appId'], ['bundleId']]
-      }
+        required: [['appId'], ['bundleId']],
+      },
     },
     POST: {
       command: 'queryAppState',
       payloadParams: {
-        required: [['appId'], ['bundleId']]
-      }
-    }
+        required: [['appId'], ['bundleId']],
+      },
+    },
   },
   //endregion
   '/session/:sessionId/appium/device/hide_keyboard': {
-    POST: {command: 'hideKeyboard', payloadParams: {optional: ['strategy', 'key', 'keyCode', 'keyName']}}
+    POST: {
+      command: 'hideKeyboard',
+      payloadParams: {optional: ['strategy', 'key', 'keyCode', 'keyName']},
+    },
   },
   '/session/:sessionId/appium/device/is_keyboard_shown': {
-    GET: {command: 'isKeyboardShown'}
+    GET: {command: 'isKeyboardShown'},
   },
   '/session/:sessionId/appium/device/push_file': {
-    POST: {command: 'pushFile', payloadParams: {required: ['path', 'data']}}
+    POST: {command: 'pushFile', payloadParams: {required: ['path', 'data']}},
   },
   '/session/:sessionId/appium/device/pull_file': {
-    POST: {command: 'pullFile', payloadParams: {required: ['path']}}
+    POST: {command: 'pullFile', payloadParams: {required: ['path']}},
   },
   '/session/:sessionId/appium/device/pull_folder': {
-    POST: {command: 'pullFolder', payloadParams: {required: ['path']}}
+    POST: {command: 'pullFolder', payloadParams: {required: ['path']}},
   },
   '/session/:sessionId/appium/device/toggle_airplane_mode': {
-    POST: {command: 'toggleFlightMode'}
+    POST: {command: 'toggleFlightMode'},
   },
   '/session/:sessionId/appium/device/toggle_data': {
-    POST: {command: 'toggleData'}
+    POST: {command: 'toggleData'},
   },
   '/session/:sessionId/appium/device/toggle_wifi': {
-    POST: {command: 'toggleWiFi'}
+    POST: {command: 'toggleWiFi'},
   },
   '/session/:sessionId/appium/device/toggle_location_services': {
-    POST: {command: 'toggleLocationServices'}
+    POST: {command: 'toggleLocationServices'},
   },
   '/session/:sessionId/appium/device/open_notifications': {
-    POST: {command: 'openNotifications'}
+    POST: {command: 'openNotifications'},
   },
   '/session/:sessionId/appium/device/start_activity': {
     POST: {
       command: 'startActivity',
       payloadParams: {
         required: ['appPackage', 'appActivity'],
-        optional: ['appWaitPackage', 'appWaitActivity', 'intentAction',
-          'intentCategory', 'intentFlags', 'optionalIntentArguments', 'dontStopAppOnReset']
-      }
-    }
+        optional: [
+          'appWaitPackage',
+          'appWaitActivity',
+          'intentAction',
+          'intentCategory',
+          'intentFlags',
+          'optionalIntentArguments',
+          'dontStopAppOnReset',
+        ],
+      },
+    },
   },
   '/session/:sessionId/appium/device/system_bars': {
-    GET: {command: 'getSystemBars'}
+    GET: {command: 'getSystemBars'},
   },
   '/session/:sessionId/appium/device/display_density': {
-    GET: {command: 'getDisplayDensity'}
+    GET: {command: 'getDisplayDensity'},
   },
   '/session/:sessionId/appium/simulator/touch_id': {
-    POST: {command: 'touchId', payloadParams: {required: ['match']}}
+    POST: {command: 'touchId', payloadParams: {required: ['match']}},
   },
   '/session/:sessionId/appium/simulator/toggle_touch_id_enrollment': {
-    POST: {command: 'toggleEnrollTouchId', payloadParams: {optional: ['enabled']}}
+    POST: {
+      command: 'toggleEnrollTouchId',
+      payloadParams: {optional: ['enabled']},
+    },
   },
   '/session/:sessionId/appium/app/launch': {
-    POST: {command: 'launchApp'}
+    POST: {command: 'launchApp'},
   },
   '/session/:sessionId/appium/app/close': {
-    POST: {command: 'closeApp'}
+    POST: {command: 'closeApp'},
   },
   '/session/:sessionId/appium/app/reset': {
-    POST: {command: 'reset'}
+    POST: {command: 'reset'},
   },
   '/session/:sessionId/appium/app/background': {
-    POST: {command: 'background', payloadParams: {required: ['seconds']}}
+    POST: {command: 'background', payloadParams: {required: ['seconds']}},
   },
   '/session/:sessionId/appium/app/end_test_coverage': {
-    POST: {command: 'endCoverage', payloadParams: {required: ['intent', 'path']}}
+    POST: {
+      command: 'endCoverage',
+      payloadParams: {required: ['intent', 'path']},
+    },
   },
   '/session/:sessionId/appium/app/strings': {
-    POST: {command: 'getStrings', payloadParams: {optional: ['language', 'stringFile']}}
+    POST: {
+      command: 'getStrings',
+      payloadParams: {optional: ['language', 'stringFile']},
+    },
   },
   '/session/:sessionId/appium/element/:elementId/value': {
-    POST: {command: 'setValueImmediate', payloadParams: {
-      validate: (jsonObj) => (!util.hasValue(jsonObj.value) && !util.hasValue(jsonObj.text)) &&
+    POST: {
+      command: 'setValueImmediate',
+      payloadParams: {
+        validate: (jsonObj) =>
+          !util.hasValue(jsonObj.value) &&
+          !util.hasValue(jsonObj.text) &&
           'we require one of "text" or "value" params',
-      optional: ['value', 'text'],
-      // We want to either a value (old JSONWP) or a text (new W3C) parameter,
-      // but only send one of them to the command (not both).
-      // Prefer 'value' since it's more backward-compatible.
-      makeArgs: (jsonObj) => [jsonObj.value || jsonObj.text],
-    }}
+        optional: ['value', 'text'],
+        // We want to either a value (old JSONWP) or a text (new W3C) parameter,
+        // but only send one of them to the command (not both).
+        // Prefer 'value' since it's more backward-compatible.
+        makeArgs: (jsonObj) => [jsonObj.value || jsonObj.text],
+      },
+    },
   },
   '/session/:sessionId/appium/element/:elementId/replace_value': {
-    POST: {command: 'replaceValue', payloadParams: {
-      validate: (jsonObj) => (!util.hasValue(jsonObj.value) && !util.hasValue(jsonObj.text)) &&
+    POST: {
+      command: 'replaceValue',
+      payloadParams: {
+        validate: (jsonObj) =>
+          !util.hasValue(jsonObj.value) &&
+          !util.hasValue(jsonObj.text) &&
           'we require one of "text" or "value" params',
-      optional: ['value', 'text'],
-      // We want to either a value (old JSONWP) or a text (new W3C) parameter,
-      // but only send one of them to the command (not both).
-      // Prefer 'value' since it's more backward-compatible.
-      makeArgs: (jsonObj) => [jsonObj.value ?? jsonObj.text ?? ''],
-    }}
+        optional: ['value', 'text'],
+        // We want to either a value (old JSONWP) or a text (new W3C) parameter,
+        // but only send one of them to the command (not both).
+        // Prefer 'value' since it's more backward-compatible.
+        makeArgs: (jsonObj) => [jsonObj.value ?? jsonObj.text ?? ''],
+      },
+    },
   },
   '/session/:sessionId/appium/settings': {
     POST: {command: 'updateSettings', payloadParams: {required: ['settings']}},
-    GET: {command: 'getSettings'}
+    GET: {command: 'getSettings'},
   },
   '/session/:sessionId/appium/receive_async_response': {
-    POST: {command: 'receiveAsyncResponse', payloadParams: {required: ['response']}}
+    POST: {
+      command: 'receiveAsyncResponse',
+      payloadParams: {required: ['response']},
+    },
   },
   '/session/:sessionId/appium/events': {
-    POST: {command: 'getLogEvents', payloadParams: {optional: ['type']}}
+    POST: {command: 'getLogEvents', payloadParams: {optional: ['type']}},
   },
   '/session/:sessionId/appium/log_event': {
-    POST: {command: 'logCustomEvent', payloadParams: {required: ['vendor', 'event']}}
+    POST: {
+      command: 'logCustomEvent',
+      payloadParams: {required: ['vendor', 'event']},
+    },
   },
 
   /*
@@ -636,15 +777,15 @@ const METHOD_MAP = {
     POST: {
       command: 'setAlertText',
       payloadParams: SET_ALERT_TEXT_PAYLOAD_PARAMS,
-    }
+    },
   },
   // MJSONWP
   '/session/:sessionId/accept_alert': {
-    POST: {command: 'postAcceptAlert'}
+    POST: {command: 'postAcceptAlert'},
   },
   // MJSONWP
   '/session/:sessionId/dismiss_alert': {
-    POST: {command: 'postDismissAlert'}
+    POST: {command: 'postDismissAlert'},
   },
   // https://w3c.github.io/webdriver/webdriver-spec.html#user-prompts
   '/session/:sessionId/alert/text': {
@@ -652,77 +793,78 @@ const METHOD_MAP = {
     POST: {
       command: 'setAlertText',
       payloadParams: SET_ALERT_TEXT_PAYLOAD_PARAMS,
-    }
+    },
   },
   '/session/:sessionId/alert/accept': {
-    POST: {command: 'postAcceptAlert'}
+    POST: {command: 'postAcceptAlert'},
   },
   '/session/:sessionId/alert/dismiss': {
-    POST: {command: 'postDismissAlert'}
+    POST: {command: 'postDismissAlert'},
   },
   // https://w3c.github.io/webdriver/webdriver-spec.html#get-element-rect
   '/session/:sessionId/element/:elementId/rect': {
-    GET: {command: 'getElementRect'}
+    GET: {command: 'getElementRect'},
   },
   '/session/:sessionId/execute/sync': {
-    POST: {command: 'execute', payloadParams: {required: ['script', 'args']}}
+    POST: {command: 'execute', payloadParams: {required: ['script', 'args']}},
   },
   '/session/:sessionId/execute/async': {
-    POST: {command: 'executeAsync', payloadParams: {required: ['script', 'args']}}
+    POST: {
+      command: 'executeAsync',
+      payloadParams: {required: ['script', 'args']},
+    },
   },
   // Pre-W3C endpoint for element screenshot
   '/session/:sessionId/screenshot/:elementId': {
-    GET: {command: 'getElementScreenshot'}
+    GET: {command: 'getElementScreenshot'},
   },
   '/session/:sessionId/element/:elementId/screenshot': {
-    GET: {command: 'getElementScreenshot'}
+    GET: {command: 'getElementScreenshot'},
   },
   '/session/:sessionId/window/rect': {
     GET: {command: 'getWindowRect'},
-    POST: {command: 'setWindowRect', payloadParams: {required: ['x', 'y', 'width', 'height']}},
+    POST: {
+      command: 'setWindowRect',
+      payloadParams: {required: ['x', 'y', 'width', 'height']},
+    },
   },
   '/session/:sessionId/window/maximize': {
-    POST: {command: 'maximizeWindow'}
+    POST: {command: 'maximizeWindow'},
   },
   '/session/:sessionId/window/minimize': {
-    POST: {command: 'minimizeWindow'}
+    POST: {command: 'minimizeWindow'},
   },
   '/session/:sessionId/window/fullscreen': {
-    POST: {command: 'fullScreenWindow'}
+    POST: {command: 'fullScreenWindow'},
   },
   '/session/:sessionId/window/new': {
-    POST: {command: 'createNewWindow', payloadParams: {optional: ['type']}}
+    POST: {command: 'createNewWindow', payloadParams: {optional: ['type']}},
   },
   '/session/:sessionId/element/:elementId/property/:name': {
-    GET: {command: 'getProperty'}
+    GET: {command: 'getProperty'},
   },
   '/session/:sessionId/appium/device/set_clipboard': {
     POST: {
       command: 'setClipboard',
       payloadParams: {
         required: ['content'],
-        optional: [
-          'contentType',
-          'label',
-        ]
+        optional: ['contentType', 'label'],
       },
-    }
+    },
   },
   '/session/:sessionId/appium/device/get_clipboard': {
     POST: {
       command: 'getClipboard',
       payloadParams: {
-        optional: [
-          'contentType',
-        ]
+        optional: ['contentType'],
       },
-    }
+    },
   },
 
   // chromium devtools
   // https://chromium.googlesource.com/chromium/src/+/master/chrome/test/chromedriver/server/http_handler.cc
   '/session/:sessionId/:vendor/cdp/execute': {
-    POST: {command: 'executeCdp', payloadParams: {required: ['cmd', 'params']}}
+    POST: {command: 'executeCdp', payloadParams: {required: ['cmd', 'params']}},
   },
 
   //region Webauthn
@@ -734,14 +876,14 @@ const METHOD_MAP = {
       payloadParams: {
         required: ['protocol', 'transport'],
         optional: ['hasResidentKey', 'hasUserVerification', 'isUserConsenting', 'isUserVerified'],
-      }
-    }
+      },
+    },
   },
 
   '/session/:sessionId/webauthn/authenticator/:authenticatorId': {
     DELETE: {
-      command: 'removeVirtualAuthenticator'
-    }
+      command: 'removeVirtualAuthenticator',
+    },
   },
 
   '/session/:sessionId/webauthn/authenticator/:authenticatorId/credential': {
@@ -750,8 +892,8 @@ const METHOD_MAP = {
       payloadParams: {
         required: ['credentialId', 'isResidentCredential', 'rpId', 'privateKey'],
         optional: ['userHandle', 'signCount'],
-      }
-    }
+      },
+    },
   },
 
   '/session/:sessionId/webauthn/authenticator/:authenticatorId/credentials': {
@@ -760,20 +902,19 @@ const METHOD_MAP = {
   },
 
   '/session/:sessionId/webauthn/authenticator/:authenticatorId/credentials/:credentialId': {
-    DELETE: {command: 'removeAuthCredential'}
+    DELETE: {command: 'removeAuthCredential'},
   },
 
   '/session/:sessionId/webauthn/authenticator/:authenticatorId/uv': {
     POST: {
       command: 'setUserAuthVerified',
       payloadParams: {
-        required: ['isUserVerified']
-      }
-    }
+        required: ['isUserVerified'],
+      },
+    },
   },
 
   //endregion
-
 };
 
 // driver command names
@@ -790,7 +931,7 @@ const RE_ESCAPE = /[-[\]{}()+?.,\\^$|#\s]/g;
 const RE_PARAM = /([:*])(\w+)/g;
 
 class Route {
-  constructor (route) {
+  constructor(route) {
     this.paramNames = [];
 
     let reStr = route.replace(RE_ESCAPE, '\\$&');
@@ -801,7 +942,7 @@ class Route {
     this.routeRegexp = new RegExp(`^${reStr}$`);
   }
 
-  parse (url) {
+  parse(url) {
     //if (url.indexOf('timeouts') !== -1 && this.routeRegexp.toString().indexOf('timeouts') !== -1) {
     //debugger;
     //}
@@ -817,22 +958,33 @@ class Route {
   }
 }
 
-function routeToCommandName (endpoint, method, basePath = DEFAULT_BASE_PATH) {
+/**
+ *
+ * @param {string} endpoint
+ * @param {import('@appium/types').HTTPMethod} method
+ * @param {string} [basePath]
+ * @returns {string|undefined}
+ */
+function routeToCommandName(endpoint, method, basePath = DEFAULT_BASE_PATH) {
   let dstRoute = null;
 
   // remove any query string
+  // TODO: would this be better handled as a `URL` object?
   if (endpoint.includes('?')) {
     endpoint = endpoint.slice(0, endpoint.indexOf('?'));
   }
 
-  const actualEndpoint = endpoint === '/' ? '' :
-    (_.startsWith(endpoint, '/') ? endpoint : `/${endpoint}`);
+  const actualEndpoint =
+    endpoint === '/' ? '' : _.startsWith(endpoint, '/') ? endpoint : `/${endpoint}`;
 
   for (let currentRoute of _.keys(METHOD_MAP)) {
     const route = new Route(`${basePath}${currentRoute}`);
     // we don't care about the actual session id for matching
-    if (route.parse(`${basePath}/session/ignored-session-id${actualEndpoint}`) ||
-        route.parse(`${basePath}${actualEndpoint}`) || route.parse(actualEndpoint)) {
+    if (
+      route.parse(`${basePath}/session/ignored-session-id${actualEndpoint}`) ||
+      route.parse(`${basePath}${actualEndpoint}`) ||
+      route.parse(actualEndpoint)
+    ) {
       dstRoute = currentRoute;
       break;
     }
@@ -840,7 +992,7 @@ function routeToCommandName (endpoint, method, basePath = DEFAULT_BASE_PATH) {
   if (!dstRoute) return; // eslint-disable-line curly
 
   const methods = _.get(METHOD_MAP, dstRoute);
-  method = _.toUpper(method);
+  method = /** @type {Uppercase<typeof method>} */ (_.toUpper(method));
   if (_.has(methods, method)) {
     const dstMethod = _.get(methods, method);
     if (dstMethod.command) {
@@ -852,4 +1004,9 @@ function routeToCommandName (endpoint, method, basePath = DEFAULT_BASE_PATH) {
 // driver commands that do not require a session to already exist
 const NO_SESSION_ID_COMMANDS = ['createSession', 'getStatus', 'getSessions'];
 
-export { METHOD_MAP, ALL_COMMANDS, NO_SESSION_ID_COMMANDS, routeToCommandName };
+export {METHOD_MAP, ALL_COMMANDS, NO_SESSION_ID_COMMANDS, routeToCommandName};
+
+/**
+ * @typedef {import('@appium/types').Driver} Driver
+ * @typedef {import('@appium/types').MethodMap} MethodMap
+ */