appium 2.0.0-beta.25 → 2.0.0-beta.28

package/build/lib/cli/extension.js

@@ -13,18 +13,20 @@ var _driverCommand = _interopRequireDefault(require("./driver-command"));
 
 var _pluginCommand = _interopRequireDefault(require("./plugin-command"));
 
-var _driverConfig = _interopRequireDefault(require("../driver-config"));
-
-var _pluginConfig = _interopRequireDefault(require("../plugin-config"));
-
-var _extensionConfig = require("../extension-config");
+var _constants = require("../constants");
 
 var _utils = require("./utils");
 
-var _args = require("./args");
+const commandClasses = Object.freeze({
+  [_constants.DRIVER_TYPE]: _driverCommand.default,
+  [_constants.PLUGIN_TYPE]: _pluginCommand.default
+});
 
-async function runExtensionCommand(args, type, configObject) {
+async function runExtensionCommand(args, configObject) {
   let jsonResult = null;
+  const {
+    extensionType: type
+  } = configObject;
   const extCmd = args[`${type}Command`];
 
   if (!extCmd) {
@@ -42,23 +44,15 @@ async function runExtensionCommand(args, type, configObject) {
 
   const logFn = msg => (0, _utils.log)(json, msg);
 
-  let config;
-
-  if (configObject) {
-    config = configObject;
-    config.log = logFn;
-  } else {
-    config = (type === _extensionConfig.DRIVER_TYPE ? _driverConfig.default : _pluginConfig.default).getInstance(_args.APPIUM_HOME, logFn);
-  }
-
-  const CommandClass = type === _extensionConfig.DRIVER_TYPE ? _driverCommand.default : _pluginCommand.default;
+  let config = configObject;
+  config.log = logFn;
+  const CommandClass = commandClasses[type];
   const cmd = new CommandClass({
     config,
     json
   });
 
   try {
-    await config.read();
     jsonResult = await cmd.execute(args);
   } catch (err) {
     if (suppressOutput) {
@@ -73,7 +67,5 @@ async function runExtensionCommand(args, type, configObject) {
   }
 
   return jsonResult;
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/cli/parser.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Creates a {@link ArgParser} instance; finalizes the config schema.
+ *
+ * @constructs ArgParser
+ * @param {boolean} [debug] - If `true`, throw instead of exit upon parsing error
+ * @returns {ArgParser}
+ */
+export function getParser(debug?: boolean | undefined): ArgParser;
+/**
+ * A wrapper around `argparse`
+ *
+ * - Handles instantiation, configuration, and monkeypatching of an
+ *    `ArgumentParser` instance for Appium server and its extensions
+ * - Handles error conditions, messages, and exit behavior
+ */
+export class ArgParser {
+    /**
+     * Given an object full of arguments as returned by `argparser.parse_args`,
+     * expand the ones for extensions into a nested object structure and rename
+     * keys to match the intended destination.
+     *
+     * E.g., `{'driver-foo-bar': baz}` becomes `{driver: {foo: {bar: 'baz'}}}`
+     * @param {object} args
+     * @returns {object}
+     */
+    static _transformParsedArgs(args: object): object;
+    /**
+     * Patches the `exit()` method of the parser to throw an error, so we can handle it manually.
+     * @param {ArgumentParser} parser
+     */
+    static _patchExit(parser: ArgumentParser): void;
+    /**
+     *
+     * @param {import('argparse').SubParser} subParser
+     * @returns {import('./args').ArgumentDefinitions}
+     */
+    static _addServerToParser(subParser: import('argparse').SubParser): import('./args').ArgumentDefinitions;
+    /**
+     * Adds extension sub-sub-commands to `driver`/`plugin` subcommands
+     * @param {import('argparse').SubParser} subParsers
+     */
+    static _addExtensionCommandsToParser(subParsers: import('argparse').SubParser): void;
+    /**
+     * @param {boolean} [debug] - If true, throw instead of exit on error.
+     */
+    constructor(debug?: boolean | undefined);
+    /**
+     * Program name (typically `appium`)
+     * @type {string}
+     */
+    prog: string;
+    /**
+     * If `true`, throw an error on parse failure instead of printing help
+     * @type {boolean}
+     */
+    debug: boolean;
+    /**
+     * Wrapped `ArgumentParser` instance
+     * @type {ArgumentParser}
+     */
+    parser: ArgumentParser;
+    rawArgs: import("./args").ArgumentDefinitions;
+    /**
+     * @type {ArgParser['parseArgs']}
+     */
+    parse_args: ArgParser['parseArgs'];
+    /**
+     * Parse arguments from the command line.
+     *
+     * If no subcommand is passed in, this method will inject the `server` subcommand.
+     *
+     * `ArgParser.prototype.parse_args` is an alias of this method.
+     * @param {string[]} [args] - Array of arguments, ostensibly from `process.argv`. Gathers args from `process.argv` if not provided.
+     * @returns {import('../../types/cli').ParsedArgs} - The parsed arguments
+     */
+    parseArgs(args?: string[] | undefined): import('../../types/cli').ParsedArgs;
+}
+import { ArgumentParser } from "argparse";
+//# sourceMappingURL=parser.d.ts.map

package/build/lib/cli/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../lib/cli/parser.js"],"names":[],"mappings":"AA6PA;;;;;;GAMG;AACH,wDAFa,SAAS,CAMrB;AAzOD;;;;;;GAMG;AACH;IA2FE;;;;;;;;OAQG;IACH,kCAHW,MAAM,GACJ,MAAM,CAiBlB;IAED;;;OAGG;IACH,0BAFW,cAAc,QASxB;IAED;;;;OAIG;IACH,qCAHW,OAAO,UAAU,EAAE,SAAS,GAC1B,OAAO,QAAQ,EAAE,mBAAmB,CAkBhD;IAED;;;OAGG;IACH,iDAFW,OAAO,UAAU,EAAE,SAAS,QAyDtC;IAnND;;OAEG;IACH,yCAmDC;IAxCC;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,OAFU,OAAO,CAEC;IAElB;;;OAGG;IACH,QAFU,cAAc,CAEJ;IAcpB,8CAAyB;IAMzB;;OAEG;IACH,YAFU,SAAS,CAAC,WAAW,CAAC,CAEA;IAGlC;;;;;;;;OAQG;IACH,wCAFa,OAAO,iBAAiB,EAAE,UAAU,CAyBhD;CA4HF"}

package/build/lib/cli/parser.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.SERVER_SUBCOMMAND = exports.ArgParser = void 0;
+exports.ArgParser = void 0;
 exports.getParser = getParser;
 
 require("source-map-support/register");
@@ -14,25 +14,21 @@ var _support = require("@appium/support");
 
 var _argparse = require("argparse");
 
-var _bluebird = _interopRequireDefault(require("bluebird"));
-
 var _lodash = _interopRequireDefault(require("lodash"));
 
 var _path = _interopRequireDefault(require("path"));
 
-var _extensionConfig = require("../extension-config");
+var _constants = require("../constants");
 
 var _schema = require("../schema");
 
-var _utils = require("../utils");
+var _config = require("../config");
 
 var _args = require("./args");
 
-const SERVER_SUBCOMMAND = 'server';
-exports.SERVER_SUBCOMMAND = SERVER_SUBCOMMAND;
-const NON_SERVER_ARGS = Object.freeze(new Set([_extensionConfig.DRIVER_TYPE, _extensionConfig.PLUGIN_TYPE, SERVER_SUBCOMMAND, '-h', '--help', '-v', '--version']));
+const NON_SERVER_ARGS = Object.freeze(new Set([_constants.DRIVER_TYPE, _constants.PLUGIN_TYPE, _constants.SERVER_SUBCOMMAND, '-h', '--help', '-v', '--version']));
 
-const version = _support.fs.readPackageJsonFrom(_utils.rootDir).version;
+const version = _support.fs.readPackageJsonFrom(_config.rootDir).version;
 
 class ArgParser {
   constructor(debug = false) {
@@ -67,7 +63,7 @@ class ArgParser {
 
   parseArgs(args = process.argv.slice(2)) {
     if (!NON_SERVER_ARGS.has(args[0])) {
-      args.unshift(SERVER_SUBCOMMAND);
+      args.unshift(_constants.SERVER_SUBCOMMAND);
     }
 
     try {
@@ -131,7 +127,7 @@ class ArgParser {
   }
 
   static _addExtensionCommandsToParser(subParsers) {
-    for (const type of [_extensionConfig.DRIVER_TYPE, _extensionConfig.PLUGIN_TYPE]) {
+    for (const type of [_constants.DRIVER_TYPE, _constants.PLUGIN_TYPE]) {
       const extParser = subParsers.add_parser(type, {
         add_help: true,
         help: `Access the ${type} management CLI commands`
@@ -188,14 +184,8 @@ class ArgParser {
 
 exports.ArgParser = ArgParser;
 
-async function getParser(debug = false) {
-  await _bluebird.default.all([_args.driverConfig.read(), _args.pluginConfig.read()]);
+function getParser(debug) {
   (0, _schema.finalizeSchema)();
   return new ArgParser(debug);
 }
-
-var _default = getParser;
-exports.default = _default;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/cli/parser.js"],"names":["SERVER_SUBCOMMAND","NON_SERVER_ARGS","Object","freeze","Set","DRIVER_TYPE","PLUGIN_TYPE","version","fs","readPackageJsonFrom","rootDir","ArgParser","constructor","debug","prog","process","argv","path","basename","parser","ArgumentParser","add_help","description","_patchExit","add_argument","action","subParsers","add_subparsers","dest","serverArgs","_addServerToParser","rawArgs","_addExtensionCommandsToParser","parse_args","parseArgs","args","slice","has","unshift","parsed","_transformParsedArgs","err","console","error","message","exit","_","reduce","unpacked","value","key","isUndefined","set","code","msg","Error","subParser","serverParser","add_parser","help","flagsOrNames","opts","type","extParser","extSubParsers","extensionArgs","parserSpecs","command","list","install","uninstall","update","run","getParser","B","all","driverConfig","read","pluginConfig"],"mappings":";;;;;;;;;;;;AAEA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAOO,MAAMA,iBAAiB,GAAG,QAA1B;;AAMP,MAAMC,eAAe,GAAGC,MAAM,CAACC,MAAP,CACtB,IAAIC,GAAJ,CAAQ,CACNC,4BADM,EAENC,4BAFM,EAGNN,iBAHM,EAIN,IAJM,EAKN,QALM,EAMN,IANM,EAON,WAPM,CAAR,CADsB,CAAxB;;AAYA,MAAMO,OAAO,GAAGC,YAAGC,mBAAH,CAAuBC,cAAvB,EAAgCH,OAAhD;;AASA,MAAMI,SAAN,CAAgB;AAIdC,EAAAA,WAAW,CAAEC,KAAK,GAAG,KAAV,EAAiB;AAC1B,UAAMC,IAAI,GAAGC,OAAO,CAACC,IAAR,CAAa,CAAb,IAAkBC,cAAKC,QAAL,CAAcH,OAAO,CAACC,IAAR,CAAa,CAAb,CAAd,CAAlB,GAAmD,QAAhE;AACA,UAAMG,MAAM,GAAG,IAAIC,wBAAJ,CAAmB;AAChCC,MAAAA,QAAQ,EAAE,IADsB;AAEhCC,MAAAA,WAAW,EACT,6HAH8B;AAIhCR,MAAAA;AAJgC,KAAnB,CAAf;;AAOAH,IAAAA,SAAS,CAACY,UAAV,CAAqBJ,MAArB;;AAMA,SAAKL,IAAL,GAAYA,IAAZ;AAMA,SAAKD,KAAL,GAAaA,KAAb;AAMA,SAAKM,MAAL,GAAcA,MAAd;AAEAA,IAAAA,MAAM,CAACK,YAAP,CAAoB,IAApB,EAA0B,WAA1B,EAAuC;AACrCC,MAAAA,MAAM,EAAE,SAD6B;AAErClB,MAAAA;AAFqC,KAAvC;AAKA,UAAMmB,UAAU,GAAGP,MAAM,CAACQ,cAAP,CAAsB;AAACC,MAAAA,IAAI,EAAE;AAAP,KAAtB,CAAnB;;AAKA,UAAMC,UAAU,GAAGlB,SAAS,CAACmB,kBAAV,CAA6BJ,UAA7B,CAAnB;;AAEA,SAAKK,OAAL,GAAeF,UAAf;;AAGAlB,IAAAA,SAAS,CAACqB,6BAAV,CAAwCN,UAAxC;;AAMA,SAAKO,UAAL,GAAkB,KAAKC,SAAvB;AACD;;AAWDA,EAAAA,SAAS,CAAEC,IAAI,GAAGpB,OAAO,CAACC,IAAR,CAAaoB,KAAb,CAAmB,CAAnB,CAAT,EAAgC;AACvC,QAAI,CAACnC,eAAe,CAACoC,GAAhB,CAAoBF,IAAI,CAAC,CAAD,CAAxB,CAAL,EAAmC;AACjCA,MAAAA,IAAI,CAACG,OAAL,CAAatC,iBAAb;AACD;;AAED,QAAI;AACF,YAAMuC,MAAM,GAAG,KAAKpB,MAAL,CAAYc,UAAZ,CAAuBE,IAAvB,CAAf;AACA,aAAOxB,SAAS,CAAC6B,oBAAV,CAA+BD,MAA/B,CAAP;AACD,KAHD,CAGE,OAAOE,GAAP,EAAY;AACZ,UAAI,KAAK5B,KAAT,EAAgB;AACd,cAAM4B,GAAN;AACD;;AAID;AAEEC,QAAAA,OAAO,CAACC,KAAR;AAEAD,QAAAA,OAAO,CAACC,KAAR,CAAcF,GAAG,CAACG,OAAlB;AACA7B,QAAAA,OAAO,CAAC8B,IAAR,CAAa,CAAb;AACD;AACF;AACF;;AAW0B,SAApBL,oBAAoB,CAAEL,IAAF,EAAQ;AACjC,WAAOW,gBAAEC,MAAF,CACLZ,IADK,EAEL,CAACa,QAAD,EAAWC,KAAX,EAAkBC,GAAlB,KAA0B;AACxB,UAAI,CAACJ,gBAAEK,WAAF,CAAcF,KAAd,CAAD,IAAyB,wBAAWC,GAAX,CAA7B,EAA8C;AAC5C,cAAM;AAACtB,UAAAA;AAAD,YAA6D,wBAAWsB,GAAX,CAAnE;;AACAJ,wBAAEM,GAAF,CAAMJ,QAAN,EAAgBpB,IAAhB,EAAsBqB,KAAtB;AACD,OAHD,MAGO;AAELD,QAAAA,QAAQ,CAACE,GAAD,CAAR,GAAgBD,KAAhB;AACD;;AACD,aAAOD,QAAP;AACD,KAXI,EAYL,EAZK,CAAP;AAcD;;AAMgB,SAAVzB,UAAU,CAAEJ,MAAF,EAAU;AACzBA,IAAAA,MAAM,CAAC0B,IAAP,GAAc,CAACQ,IAAD,EAAOC,GAAP,KAAe;AAC3B,UAAID,IAAJ,EAAU;AACR,cAAM,IAAIE,KAAJ,CAAUD,GAAV,CAAN;AACD;;AACDvC,MAAAA,OAAO,CAAC8B,IAAR;AACD,KALD;AAMD;;AAOwB,SAAlBf,kBAAkB,CAAE0B,SAAF,EAAa;AACpC,UAAMC,YAAY,GAAGD,SAAS,CAACE,UAAV,CAAqB,QAArB,EAA+B;AAClDrC,MAAAA,QAAQ,EAAE,IADwC;AAElDsC,MAAAA,IAAI,EAAE;AAF4C,KAA/B,CAArB;;AAKAhD,IAAAA,SAAS,CAACY,UAAV,CAAqBkC,YAArB;;AAEA,UAAM5B,UAAU,GAAG,0BAAnB;;AACA,SAAK,MAAM,CAAC+B,YAAD,EAAeC,IAAf,CAAX,IAAmChC,UAAnC,EAA+C;AAG7C4B,MAAAA,YAAY,CAACjC,YAAb,CAA0B,GAAGoC,YAA7B,EAA2C,EAAC,GAAGC;AAAJ,OAA3C;AACD;;AAED,WAAOhC,UAAP;AACD;;AAMmC,SAA7BG,6BAA6B,CAAEN,UAAF,EAAc;AAChD,SAAK,MAAMoC,IAAX,IAAmB,CAACzD,4BAAD,EAAcC,4BAAd,CAAnB,EAA+C;AAC7C,YAAMyD,SAAS,GAAGrC,UAAU,CAACgC,UAAX,CAAsBI,IAAtB,EAA4B;AAC5CzC,QAAAA,QAAQ,EAAE,IADkC;AAE5CsC,QAAAA,IAAI,EAAG,cAAaG,IAAK;AAFmB,OAA5B,CAAlB;;AAKAnD,MAAAA,SAAS,CAACY,UAAV,CAAqBwC,SAArB;;AAEA,YAAMC,aAAa,GAAGD,SAAS,CAACpC,cAAV,CAAyB;AAC7CC,QAAAA,IAAI,EAAG,GAAEkC,IAAK;AAD+B,OAAzB,CAAtB;AAGA,YAAMG,aAAa,GAAG,6BAAtB;AACA,YAAMC,WAAW,GAAG,CAClB;AACEC,QAAAA,OAAO,EAAE,MADX;AAEEhC,QAAAA,IAAI,EAAE8B,aAAa,CAACH,IAAD,CAAb,CAAoBM,IAF5B;AAGET,QAAAA,IAAI,EAAG,gCAA+BG,IAAK;AAH7C,OADkB,EAMlB;AACEK,QAAAA,OAAO,EAAE,SADX;AAEEhC,QAAAA,IAAI,EAAE8B,aAAa,CAACH,IAAD,CAAb,CAAoBO,OAF5B;AAGEV,QAAAA,IAAI,EAAG,aAAYG,IAAK;AAH1B,OANkB,EAWlB;AACEK,QAAAA,OAAO,EAAE,WADX;AAEEhC,QAAAA,IAAI,EAAE8B,aAAa,CAACH,IAAD,CAAb,CAAoBQ,SAF5B;AAGEX,QAAAA,IAAI,EAAG,eAAcG,IAAK;AAH5B,OAXkB,EAgBlB;AACEK,QAAAA,OAAO,EAAE,QADX;AAEEhC,QAAAA,IAAI,EAAE8B,aAAa,CAACH,IAAD,CAAb,CAAoBS,MAF5B;AAGEZ,QAAAA,IAAI,EAAG,oBAAmBG,IAAK;AAHjC,OAhBkB,EAqBlB;AACEK,QAAAA,OAAO,EAAE,KADX;AAEEhC,QAAAA,IAAI,EAAE8B,aAAa,CAACH,IAAD,CAAb,CAAoBU,GAF5B;AAGEb,QAAAA,IAAI,EACD,oCAAmCG,IAAK,4BAAzC,GACC,gEAA+DA,IAAK;AALzE,OArBkB,CAApB;;AA8BA,WAAK,MAAM;AAACK,QAAAA,OAAD;AAAUhC,QAAAA,IAAV;AAAgBwB,QAAAA;AAAhB,OAAX,IAAoCO,WAApC,EAAiD;AAC/C,cAAM/C,MAAM,GAAG6C,aAAa,CAACN,UAAd,CAAyBS,OAAzB,EAAkC;AAACR,UAAAA;AAAD,SAAlC,CAAf;;AAEAhD,QAAAA,SAAS,CAACY,UAAV,CAAqBJ,MAArB;;AAEA,aAAK,MAAM,CAACyC,YAAD,EAAeC,IAAf,CAAX,IAAmC1B,IAAnC,EAAyC;AAGvChB,UAAAA,MAAM,CAACK,YAAP,CAAoB,GAAGoC,YAAvB,EAAqC,EAAC,GAAGC;AAAJ,WAArC;AACD;AACF;AACF;AACF;;AApNa;;;;AA+NhB,eAAeY,SAAf,CAA0B5D,KAAK,GAAG,KAAlC,EAAyC;AACvC,QAAM6D,kBAAEC,GAAF,CAAM,CAACC,mBAAaC,IAAb,EAAD,EAAsBC,mBAAaD,IAAb,EAAtB,CAAN,CAAN;AACA;AAEA,SAAO,IAAIlE,SAAJ,CAAcE,KAAd,CAAP;AACD;;eAEc4D,S","sourcesContent":["// @ts-check\n\nimport { fs } from '@appium/support';\nimport { ArgumentParser } from 'argparse';\nimport B from 'bluebird';\nimport _ from 'lodash';\nimport path from 'path';\nimport { DRIVER_TYPE, PLUGIN_TYPE } from '../extension-config';\nimport { finalizeSchema, getArgSpec, hasArgSpec } from '../schema';\nimport { rootDir } from '../utils';\nimport {\n  driverConfig,\n  getExtensionArgs,\n  getServerArgs,\n  pluginConfig\n} from './args';\n\nexport const SERVER_SUBCOMMAND = 'server';\n\n/**\n * If the parsed args do not contain any of these values, then we\n * will automatially inject the `server` subcommand.\n */\nconst NON_SERVER_ARGS = Object.freeze(\n  new Set([\n    DRIVER_TYPE,\n    PLUGIN_TYPE,\n    SERVER_SUBCOMMAND,\n    '-h',\n    '--help',\n    '-v',\n    '--version'\n  ])\n);\n\nconst version = fs.readPackageJsonFrom(rootDir).version;\n\n/**\n * A wrapper around `argparse`\n *\n * - Handles instantiation, configuration, and monkeypatching of an\n *    `ArgumentParser` instance for Appium server and its extensions\n * - Handles error conditions, messages, and exit behavior\n */\nclass ArgParser {\n  /**\n   * @param {boolean} [debug] - If true, throw instead of exit on error.\n   */\n  constructor (debug = false) {\n    const prog = process.argv[1] ? path.basename(process.argv[1]) : 'appium';\n    const parser = new ArgumentParser({\n      add_help: true,\n      description:\n        'A webdriver-compatible server that facilitates automation of web, mobile, and other types of apps across various platforms.',\n      prog,\n    });\n\n    ArgParser._patchExit(parser);\n\n    /**\n     * Program name (typically `appium`)\n     * @type {string}\n     */\n    this.prog = prog;\n\n    /**\n     * If `true`, throw an error on parse failure instead of printing help\n     * @type {boolean}\n     */\n    this.debug = debug;\n\n    /**\n     * Wrapped `ArgumentParser` instance\n     * @type {ArgumentParser}\n     */\n    this.parser = parser;\n\n    parser.add_argument('-v', '--version', {\n      action: 'version',\n      version,\n    });\n\n    const subParsers = parser.add_subparsers({dest: 'subcommand'});\n\n    // add the 'server' subcommand, and store the raw arguments on the parser\n    // object as a way for other parts of the code to work with the arguments\n    // conceptually rather than just through argparse\n    const serverArgs = ArgParser._addServerToParser(subParsers);\n\n    this.rawArgs = serverArgs;\n\n    // add the 'driver' and 'plugin' subcommands\n    ArgParser._addExtensionCommandsToParser(subParsers);\n\n    // backwards compatibility / drop-in wrapper\n    /**\n     * @type {ArgParser['parseArgs']}\n     */\n    this.parse_args = this.parseArgs;\n  }\n\n  /**\n   * Parse arguments from the command line.\n   *\n   * If no subcommand is passed in, this method will inject the `server` subcommand.\n   *\n   * `ArgParser.prototype.parse_args` is an alias of this method.\n   * @param {string[]} [args] - Array of arguments, ostensibly from `process.argv`. Gathers args from `process.argv` if not provided.\n   * @returns {import('../../types/types').ParsedArgs} - The parsed arguments\n   */\n  parseArgs (args = process.argv.slice(2)) {\n    if (!NON_SERVER_ARGS.has(args[0])) {\n      args.unshift(SERVER_SUBCOMMAND);\n    }\n\n    try {\n      const parsed = this.parser.parse_args(args);\n      return ArgParser._transformParsedArgs(parsed);\n    } catch (err) {\n      if (this.debug) {\n        throw err;\n      }\n      // this isn't tested via unit tests (we use `debug: true`) so may escape coverage.\n\n      /* istanbul ignore next */\n      {\n        // eslint-disable-next-line no-console\n        console.error(); // need an extra space since argparse prints usage.\n        // eslint-disable-next-line no-console\n        console.error(err.message);\n        process.exit(1);\n      }\n    }\n  }\n\n  /**\n   * Given an object full of arguments as returned by `argparser.parse_args`,\n   * expand the ones for extensions into a nested object structure and rename\n   * keys to match the intended destination.\n   *\n   * E.g., `{'driver-foo-bar': baz}` becomes `{driver: {foo: {bar: 'baz'}}}`\n   * @param {object} args\n   * @returns {object}\n   */\n  static _transformParsedArgs (args) {\n    return _.reduce(\n      args,\n      (unpacked, value, key) => {\n        if (!_.isUndefined(value) && hasArgSpec(key)) {\n          const {dest} = /** @type {import('../schema/arg-spec').ArgSpec} */(getArgSpec(key));\n          _.set(unpacked, dest, value);\n        } else {\n          // this could be anything that _isn't_ a server arg\n          unpacked[key] = value;\n        }\n        return unpacked;\n      },\n      {},\n    );\n  }\n\n  /**\n   * Patches the `exit()` method of the parser to throw an error, so we can handle it manually.\n   * @param {ArgumentParser} parser\n   */\n  static _patchExit (parser) {\n    parser.exit = (code, msg) => {\n      if (code) {\n        throw new Error(msg);\n      }\n      process.exit();\n    };\n  }\n\n  /**\n   *\n   * @param {import('argparse').SubParser} subParser\n   * @returns {import('./args').ArgumentDefinitions}\n   */\n  static _addServerToParser (subParser) {\n    const serverParser = subParser.add_parser('server', {\n      add_help: true,\n      help: 'Run an Appium server',\n    });\n\n    ArgParser._patchExit(serverParser);\n\n    const serverArgs = getServerArgs();\n    for (const [flagsOrNames, opts] of serverArgs) {\n      // TS doesn't like the spread operator here.\n      // @ts-ignore\n      serverParser.add_argument(...flagsOrNames, {...opts});\n    }\n\n    return serverArgs;\n  }\n\n  /**\n   * Adds extension sub-sub-commands to `driver`/`plugin` subcommands\n   * @param {import('argparse').SubParser} subParsers\n   */\n  static _addExtensionCommandsToParser (subParsers) {\n    for (const type of [DRIVER_TYPE, PLUGIN_TYPE]) {\n      const extParser = subParsers.add_parser(type, {\n        add_help: true,\n        help: `Access the ${type} management CLI commands`,\n      });\n\n      ArgParser._patchExit(extParser);\n\n      const extSubParsers = extParser.add_subparsers({\n        dest: `${type}Command`,\n      });\n      const extensionArgs = getExtensionArgs();\n      const parserSpecs = [\n        {\n          command: 'list',\n          args: extensionArgs[type].list,\n          help: `List available and installed ${type}s`,\n        },\n        {\n          command: 'install',\n          args: extensionArgs[type].install,\n          help: `Install a ${type}`,\n        },\n        {\n          command: 'uninstall',\n          args: extensionArgs[type].uninstall,\n          help: `Uninstall a ${type}`,\n        },\n        {\n          command: 'update',\n          args: extensionArgs[type].update,\n          help: `Update installed ${type}s to the latest version`,\n        },\n        {\n          command: 'run',\n          args: extensionArgs[type].run,\n          help:\n            `Run a script (defined inside the ${type}'s package.json under the ` +\n            `“scripts” field inside the “appium” field) from an installed ${type}`,\n        },\n      ];\n\n      for (const {command, args, help} of parserSpecs) {\n        const parser = extSubParsers.add_parser(command, {help});\n\n        ArgParser._patchExit(parser);\n\n        for (const [flagsOrNames, opts] of args) {\n          // add_argument mutates params so make sure to send in copies instead\n          // @ts-ignore\n          parser.add_argument(...flagsOrNames, {...opts});\n        }\n      }\n    }\n  }\n}\n\n/**\n * Creates a {@link ArgParser} instance.  Necessarily reads extension configuration\n * beforehand, and finalizes the config schema.\n *\n * @constructs ArgParser\n * @param {boolean} [debug] - If `true`, throw instead of exit upon parsing error\n * @returns {Promise<ArgParser>}\n */\nasync function getParser (debug = false) {\n  await B.all([driverConfig.read(), pluginConfig.read()]);\n  finalizeSchema();\n\n  return new ArgParser(debug);\n}\n\nexport default getParser;\nexport { getParser, ArgParser };\n"],"file":"lib/cli/parser.js","sourceRoot":"../../.."}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/cli/parser.js"],"names":["NON_SERVER_ARGS","Object","freeze","Set","DRIVER_TYPE","PLUGIN_TYPE","SERVER_SUBCOMMAND","version","fs","readPackageJsonFrom","rootDir","ArgParser","constructor","debug","prog","process","argv","path","basename","parser","ArgumentParser","add_help","description","_patchExit","add_argument","action","subParsers","add_subparsers","dest","serverArgs","_addServerToParser","rawArgs","_addExtensionCommandsToParser","parse_args","parseArgs","args","slice","has","unshift","parsed","_transformParsedArgs","err","console","error","message","exit","_","reduce","unpacked","value","key","isUndefined","set","code","msg","Error","subParser","serverParser","add_parser","help","flagsOrNames","opts","type","extParser","extSubParsers","extensionArgs","parserSpecs","command","list","install","uninstall","update","run","getParser"],"mappings":"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","sourcesContent":["\nimport { fs } from '@appium/support';\nimport { ArgumentParser } from 'argparse';\nimport _ from 'lodash';\nimport path from 'path';\nimport { DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND } from '../constants';\nimport { finalizeSchema, getArgSpec, hasArgSpec } from '../schema';\nimport { rootDir } from '../config';\nimport {\n  getExtensionArgs,\n  getServerArgs\n} from './args';\n\n/**\n * If the parsed args do not contain any of these values, then we\n * will automatially inject the `server` subcommand.\n */\nconst NON_SERVER_ARGS = Object.freeze(\n  new Set([\n    DRIVER_TYPE,\n    PLUGIN_TYPE,\n    SERVER_SUBCOMMAND,\n    '-h',\n    '--help',\n    '-v',\n    '--version'\n  ])\n);\n\nconst version = fs.readPackageJsonFrom(rootDir).version;\n\n/**\n * A wrapper around `argparse`\n *\n * - Handles instantiation, configuration, and monkeypatching of an\n *    `ArgumentParser` instance for Appium server and its extensions\n * - Handles error conditions, messages, and exit behavior\n */\nclass ArgParser {\n  /**\n   * @param {boolean} [debug] - If true, throw instead of exit on error.\n   */\n  constructor (debug = false) {\n    const prog = process.argv[1] ? path.basename(process.argv[1]) : 'appium';\n    const parser = new ArgumentParser({\n      add_help: true,\n      description:\n        'A webdriver-compatible server that facilitates automation of web, mobile, and other types of apps across various platforms.',\n      prog,\n    });\n\n    ArgParser._patchExit(parser);\n\n    /**\n     * Program name (typically `appium`)\n     * @type {string}\n     */\n    this.prog = prog;\n\n    /**\n     * If `true`, throw an error on parse failure instead of printing help\n     * @type {boolean}\n     */\n    this.debug = debug;\n\n    /**\n     * Wrapped `ArgumentParser` instance\n     * @type {ArgumentParser}\n     */\n    this.parser = parser;\n\n    parser.add_argument('-v', '--version', {\n      action: 'version',\n      version,\n    });\n\n    const subParsers = parser.add_subparsers({dest: 'subcommand'});\n\n    // add the 'server' subcommand, and store the raw arguments on the parser\n    // object as a way for other parts of the code to work with the arguments\n    // conceptually rather than just through argparse\n    const serverArgs = ArgParser._addServerToParser(subParsers);\n\n    this.rawArgs = serverArgs;\n\n    // add the 'driver' and 'plugin' subcommands\n    ArgParser._addExtensionCommandsToParser(subParsers);\n\n    // backwards compatibility / drop-in wrapper\n    /**\n     * @type {ArgParser['parseArgs']}\n     */\n    this.parse_args = this.parseArgs;\n  }\n\n  /**\n   * Parse arguments from the command line.\n   *\n   * If no subcommand is passed in, this method will inject the `server` subcommand.\n   *\n   * `ArgParser.prototype.parse_args` is an alias of this method.\n   * @param {string[]} [args] - Array of arguments, ostensibly from `process.argv`. Gathers args from `process.argv` if not provided.\n   * @returns {import('../../types/cli').ParsedArgs} - The parsed arguments\n   */\n  parseArgs (args = process.argv.slice(2)) {\n    if (!NON_SERVER_ARGS.has(args[0])) {\n      args.unshift(SERVER_SUBCOMMAND);\n    }\n\n    try {\n      const parsed = this.parser.parse_args(args);\n      return ArgParser._transformParsedArgs(parsed);\n    } catch (err) {\n      if (this.debug) {\n        throw err;\n      }\n      // this isn't tested via unit tests (we use `debug: true`) so may escape coverage.\n\n      /* istanbul ignore next */\n      {\n        // eslint-disable-next-line no-console\n        console.error(); // need an extra space since argparse prints usage.\n        // eslint-disable-next-line no-console\n        console.error(err.message);\n        process.exit(1);\n      }\n    }\n  }\n\n  /**\n   * Given an object full of arguments as returned by `argparser.parse_args`,\n   * expand the ones for extensions into a nested object structure and rename\n   * keys to match the intended destination.\n   *\n   * E.g., `{'driver-foo-bar': baz}` becomes `{driver: {foo: {bar: 'baz'}}}`\n   * @param {object} args\n   * @returns {object}\n   */\n  static _transformParsedArgs (args) {\n    return _.reduce(\n      args,\n      (unpacked, value, key) => {\n        if (!_.isUndefined(value) && hasArgSpec(key)) {\n          const {dest} = /** @type {import('../schema/arg-spec').ArgSpec} */(getArgSpec(key));\n          _.set(unpacked, dest, value);\n        } else {\n          // this could be anything that _isn't_ a server arg\n          unpacked[key] = value;\n        }\n        return unpacked;\n      },\n      {},\n    );\n  }\n\n  /**\n   * Patches the `exit()` method of the parser to throw an error, so we can handle it manually.\n   * @param {ArgumentParser} parser\n   */\n  static _patchExit (parser) {\n    parser.exit = (code, msg) => {\n      if (code) {\n        throw new Error(msg);\n      }\n      process.exit();\n    };\n  }\n\n  /**\n   *\n   * @param {import('argparse').SubParser} subParser\n   * @returns {import('./args').ArgumentDefinitions}\n   */\n  static _addServerToParser (subParser) {\n    const serverParser = subParser.add_parser('server', {\n      add_help: true,\n      help: 'Run an Appium server',\n    });\n\n    ArgParser._patchExit(serverParser);\n\n    const serverArgs = getServerArgs();\n    for (const [flagsOrNames, opts] of serverArgs) {\n      // TS doesn't like the spread operator here.\n      // @ts-ignore\n      serverParser.add_argument(...flagsOrNames, {...opts});\n    }\n\n    return serverArgs;\n  }\n\n  /**\n   * Adds extension sub-sub-commands to `driver`/`plugin` subcommands\n   * @param {import('argparse').SubParser} subParsers\n   */\n  static _addExtensionCommandsToParser (subParsers) {\n    for (const type of [DRIVER_TYPE, PLUGIN_TYPE]) {\n      const extParser = subParsers.add_parser(type, {\n        add_help: true,\n        help: `Access the ${type} management CLI commands`,\n      });\n\n      ArgParser._patchExit(extParser);\n\n      const extSubParsers = extParser.add_subparsers({\n        dest: `${type}Command`,\n      });\n      const extensionArgs = getExtensionArgs();\n      const parserSpecs = [\n        {\n          command: 'list',\n          args: extensionArgs[type].list,\n          help: `List available and installed ${type}s`,\n        },\n        {\n          command: 'install',\n          args: extensionArgs[type].install,\n          help: `Install a ${type}`,\n        },\n        {\n          command: 'uninstall',\n          args: extensionArgs[type].uninstall,\n          help: `Uninstall a ${type}`,\n        },\n        {\n          command: 'update',\n          args: extensionArgs[type].update,\n          help: `Update installed ${type}s to the latest version`,\n        },\n        {\n          command: 'run',\n          args: extensionArgs[type].run,\n          help:\n            `Run a script (defined inside the ${type}'s package.json under the ` +\n            `“scripts” field inside the “appium” field) from an installed ${type}`,\n        },\n      ];\n\n      for (const {command, args, help} of parserSpecs) {\n        const parser = extSubParsers.add_parser(command, {help});\n\n        ArgParser._patchExit(parser);\n\n        for (const [flagsOrNames, opts] of args) {\n          // add_argument mutates params so make sure to send in copies instead\n          // @ts-ignore\n          parser.add_argument(...flagsOrNames, {...opts});\n        }\n      }\n    }\n  }\n}\n\n/**\n * Creates a {@link ArgParser} instance; finalizes the config schema.\n *\n * @constructs ArgParser\n * @param {boolean} [debug] - If `true`, throw instead of exit upon parsing error\n * @returns {ArgParser}\n */\nfunction getParser (debug) {\n  finalizeSchema();\n\n  return new ArgParser(debug);\n}\n\nexport { getParser, ArgParser };\n"]}

package/build/lib/cli/plugin-command.d.ts

@@ -0,0 +1,39 @@
+export default class PluginCommand extends ExtensionCommand<any> {
+    /**
+     *
+     * @param {PluginCommandOptions} opts
+     */
+    constructor({ config, json }: PluginCommandOptions);
+    knownExtensions: Readonly<{
+        readonly images: "@appium/images-plugin";
+        readonly 'execute-driver': "@appium/execute-driver-plugin";
+        readonly 'relaxed-caps': "@appium/relaxed-caps-plugin";
+    }>;
+    install({ plugin, installType, packageName }: {
+        plugin: any;
+        installType: any;
+        packageName: any;
+    }): Promise<import("./extension-command").ExtRecord<any>>;
+    uninstall({ plugin }: {
+        plugin: any;
+    }): Promise<import("./extension-command").ExtRecord<any>>;
+    update({ plugin, unsafe }: {
+        plugin: any;
+        unsafe: any;
+    }): Promise<import("./extension-command").ExtensionUpdateResult>;
+    run({ plugin, scriptName }: {
+        plugin: any;
+        scriptName: any;
+    }): Promise<import("./extension-command").RunOutput>;
+    getPostInstallText({ extName, extData }: {
+        extName: any;
+        extData: any;
+    }): string;
+    validateExtensionFields(appiumPkgData: any): void;
+}
+export type PluginCommandOptions = {
+    config: import('../extension/extension-config').ExtensionConfig<import('../extension/manifest').PluginType>;
+    json: boolean;
+};
+import ExtensionCommand from "./extension-command";
+//# sourceMappingURL=plugin-command.d.ts.map

package/build/lib/cli/plugin-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-command.d.ts","sourceRoot":"","sources":["../../../lib/cli/plugin-command.js"],"names":[],"mappings":"AAMA;IAEE;;;OAGG;IACH,8BAFW,oBAAoB,EAK9B;IADC;;;;OAAoC;IAGtC;;;;8DAEC;IAED;;8DAEC;IAED;;;qEAEC;IAED;;;yDAEC;IAED;;;eAEC;IAED,kDAUC;CAEF;;YAIa,OAAO,+BAA+B,EAAE,eAAe,CAAC,OAAO,uBAAuB,EAAE,UAAU,CAAC;UACnG,OAAO"}

package/build/lib/cli/plugin-command.js

@@ -13,9 +13,7 @@ var _lodash = _interopRequireDefault(require("lodash"));
 
 var _extensionCommand = _interopRequireDefault(require("./extension-command"));
 
-var _extensionConfig = require("../extension-config");
-
-var _plugins = require("../plugins");
+var _constants = require("../constants");
 
 const REQ_PLUGIN_FIELDS = ['pluginName', 'mainClass'];
 
@@ -26,10 +24,9 @@ class PluginCommand extends _extensionCommand.default {
   }) {
     super({
       config,
-      json,
-      type: _extensionConfig.PLUGIN_TYPE
+      json
     });
-    this.knownExtensions = _plugins.KNOWN_PLUGINS;
+    this.knownExtensions = _constants.KNOWN_PLUGINS;
   }
 
   async install({
@@ -37,7 +34,7 @@ class PluginCommand extends _extensionCommand.default {
     installType,
     packageName
   }) {
-    return await super.install({
+    return await super._install({
       ext: plugin,
       installType,
       packageName
@@ -47,7 +44,7 @@ class PluginCommand extends _extensionCommand.default {
   async uninstall({
     plugin
   }) {
-    return await super.uninstall({
+    return await super._uninstall({
       ext: plugin
     });
   }
@@ -56,7 +53,7 @@ class PluginCommand extends _extensionCommand.default {
     plugin,
     unsafe
   }) {
-    return await super.update({
+    return await super._update({
       ext: plugin,
       unsafe
     });
@@ -66,7 +63,7 @@ class PluginCommand extends _extensionCommand.default {
     plugin,
     scriptName
   }) {
-    return await super.run({
+    return await super._run({
       ext: plugin,
       scriptName
     });
@@ -89,7 +86,5 @@ class PluginCommand extends _extensionCommand.default {
 
 }
 
-exports.default = PluginCommand;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+exports.default = PluginCommand;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/cli/utils.d.ts

@@ -0,0 +1,29 @@
+/***
+ * Log an error to the console and exit the process.
+ * @param {boolean} json - whether we should log json or text
+ * @param {any} msg - error message, object, Error instance, etc.
+ */
+export function errAndQuit(json: boolean, msg: any): void;
+/**
+ * Conditionally log something to the console
+ * @param {boolean} json - whether we are in json mode (and should therefore not log)
+ * @param {string} msg - string to log
+ */
+export function log(json: boolean, msg: string): void;
+/**
+ * Start a spinner, execute an async function, and then stop the spinner
+ * @param {boolean} json - whether we are in json mode (and should therefore not log)
+ * @param {string} msg - string to log
+ * @param {function} fn - function to wrap with spinning
+ */
+export function spinWith(json: boolean, msg: string, fn: Function): Promise<any>;
+export const JSON_SPACES: 4;
+export class RingBuffer {
+    constructor(size?: number);
+    size: number;
+    buffer: any[];
+    getBuff(): any[];
+    dequeue(): void;
+    enqueue(item: any): void;
+}
+//# sourceMappingURL=utils.d.ts.map

package/build/lib/cli/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/cli/utils.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,iCAHW,OAAO,OACP,GAAG,QAYb;AAED;;;;GAIG;AACH,0BAHW,OAAO,OACP,MAAM,QAIhB;AAED;;;;;GAKG;AACH,+BAJW,OAAO,OACP,MAAM,8BAiBhB;AAhDD,4BAAsB;AAkDtB;IACE,2BAGC;IAFC,aAAgB;IAChB,cAAgB;IAElB,iBAEC;IACD,gBAEC;IACD,yBAKC;CACF"}

package/build/lib/cli/utils.js

@@ -79,7 +79,5 @@ class RingBuffer {
 
 }
 
-exports.RingBuffer = RingBuffer;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+exports.RingBuffer = RingBuffer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/config-file.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Given an array of errors and the result of loading a config file, generate a
+ * helpful string for the user.
+ *
+ * - If `opts` contains a `json` property, this should be the original JSON
+ *   _string_ of the config file.  This is only applicable if the config file
+ *   was in JSON format. If present, it will associate line numbers with errors.
+ * - If `errors` happens to be empty, this will throw.
+ * @param {import('ajv').ErrorObject[]} errors - Non-empty array of errors. Required.
+ * @param {ReadConfigFileResult['config']|any} [config] -
+ * Configuration & metadata
+ * @param {FormatConfigErrorsOptions} [opts]
+ * @throws {TypeError} If `errors` is empty
+ * @returns {string}
+ */
+export function formatErrors(errors?: import('ajv').ErrorObject[], config?: ReadConfigFileResult['config'] | any, opts?: FormatConfigErrorsOptions | undefined): string;
+/**
+ * Given an optional path, read a config file. Validates the config file.
+ *
+ * Call {@link validate} if you already have a config object.
+ * @param {string} [filepath] - Path to config file, if we have one
+ * @param {ReadConfigFileOptions} [opts] - Options
+ * @public
+ * @returns {Promise<ReadConfigFileResult>} Contains config and filepath, if found, and any errors
+ */
+export function readConfigFile(filepath?: string | undefined, opts?: ReadConfigFileOptions | undefined): Promise<ReadConfigFileResult>;
+/**
+ * Convert schema property names to either a) the value of the `appiumCliDest` property, if any; or b) camel-case
+ * @param {AppiumConfig} config - Configuration object
+ * @returns {NormalizedAppiumConfig} New object with camel-cased keys (or `dest` keys).
+ */
+export function normalizeConfig(config: AppiumConfig): NormalizedAppiumConfig;
+/**
+ * Result of calling {@link readConfigFile }.
+ */
+export type ReadConfigFileResult = {
+    /**
+     * - Validation errors
+     */
+    errors?: import("ajv").ErrorObject<string, Record<string, any>, any>[] | undefined;
+    /**
+     * - The path to the config file, if found
+     */
+    filepath?: string | undefined;
+    /**
+     * - If `true`, the config file exists but is empty
+     */
+    isEmpty?: boolean | undefined;
+    /**
+     * - The parsed configuration
+     */
+    config?: import("@appium/types").NormalizedAppiumConfig | undefined;
+    /**
+     * - Human-readable error messages and suggestions. If the `pretty` option is `true`, this will be a nice string to print.
+     */
+    reason?: string | import("@sidvind/better-ajv-errors").IOutputError[] | undefined;
+};
+/**
+ * Options for {@link readConfigFile }.
+ */
+export type ReadConfigFileOptions = {
+    /**
+     * If `false`, do not use color and fancy formatting in the `reason` property of the {@link ReadConfigFileResult }. The value of `reason` is then suitable for machine-reading.
+     */
+    pretty?: boolean | undefined;
+};
+/**
+ * This is an `AsyncSearcher` which is inexplicably _not_ exported by the `lilconfig` type definition.
+ */
+export type LilconfigAsyncSearcher = ReturnType<typeof import("lilconfig")["lilconfig"]>;
+/**
+ * The contents of an Appium config file. Generated from schema
+ */
+export type AppiumConfig = import('@appium/types').AppiumConfig;
+/**
+ * The contents of an Appium config file with camelcased property names (and using `appiumCliDest` value if present). Generated from {@link AppiumConfig }
+ */
+export type NormalizedAppiumConfig = import('@appium/types').NormalizedAppiumConfig;
+/**
+ * The string should be a raw JSON string.
+ */
+export type RawJson = string;
+/**
+ * Options for {@link formatErrors }.
+ */
+export type FormatConfigErrorsOptions = {
+    /**
+     * - Raw JSON config (as string)
+     */
+    json?: string | undefined;
+    /**
+     * - Whether to format errors as a CLI-friendly string
+     */
+    pretty?: boolean | undefined;
+    /**
+     * - Specific ID of a prop; otherwise entire schema
+     */
+    schemaId?: string | undefined;
+};
+//# sourceMappingURL=config-file.d.ts.map

package/build/lib/config-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-file.d.ts","sourceRoot":"","sources":["../../lib/config-file.js"],"names":[],"mappings":"AAiEA;;;;;;;;;;;;;;GAcG;AACH,sCAPW,OAAO,KAAK,EAAE,WAAW,EAAE,WAC3B,oBAAoB,CAAC,QAAQ,CAAC,GAAC,GAAG,iDAIhC,MAAM,CAUlB;AAED;;;;;;;;GAQG;AACH,yGAFa,QAAQ,oBAAoB,CAAC,CA8CzC;AAED;;;;GAIG;AACH,wCAHW,YAAY,GACV,sBAAsB,CA8BlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAoBY,WAAW,2BAAoB,WAAW,CAAC,CAAC;;;;2BAK5C,OAAO,eAAe,EAAE,YAAY;;;;qCAKpC,OAAO,eAAe,EAAE,sBAAsB;;;;sBAK9C,MAAM"}