appium 3.2.2 → 3.3.1

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

@@ -1,445 +1,241 @@
-/**
- * This is needed to ensure proper module resolution for installed extensions,
- * especially ESM ones.
- *
- * @param {ExtensionConfig<ExtensionType>} driverConfig
- * @param {ExtensionConfig<ExtensionType>} pluginConfig
- * @param {import('@appium/types').AppiumLogger} logger
- */
-export function injectAppiumSymlinks(driverConfig: ExtensionConfig<ExtensionType>, pluginConfig: ExtensionConfig<ExtensionType>, logger: import("@appium/types").AppiumLogger): Promise<void>;
-export default ExtensionCliCommand;
-export { ExtensionCliCommand as ExtensionCommand };
+import type { AppiumLogger, ExtensionType } from '@appium/types';
+import type { ExtInstallReceipt as AppiumExtInstallReceipt, ExtManifest as AppiumExtManifest, ExtMetadata as AppiumExtMetadata, ExtPackageJson as AppiumExtPackageJson, ExtRecord as AppiumExtRecord, InstallType } from 'appium/types';
+import type { ExtensionConfig as BaseExtensionConfig } from '../extension/extension-config';
 /**
  * Options for the {@linkcode ExtensionCliCommand} constructor
  */
-export type ExtensionCommandOptions<ExtType extends ExtensionType> = {
-    /**
-     * - the `DriverConfig` or `PluginConfig` instance used for this command
-     */
+export type ExtensionCommandOptions<ExtType extends ExtensionType = ExtensionType> = {
     config: ExtensionConfig<ExtType>;
-    /**
-     * - whether the output of this command should be JSON or text
-     */
     json: boolean;
 };
+export type ExtensionConfig<ExtType extends ExtensionType = ExtensionType> = BaseExtensionConfig<ExtType>;
+export type ExtRecord<ExtType extends ExtensionType = ExtensionType> = AppiumExtRecord<ExtType>;
+export type ExtMetadata<ExtType extends ExtensionType = ExtensionType> = AppiumExtMetadata<ExtType>;
+export type ExtManifest<ExtType extends ExtensionType = ExtensionType> = AppiumExtManifest<ExtType>;
+export type ExtPackageJson<ExtType extends ExtensionType = ExtensionType> = AppiumExtPackageJson<ExtType>;
+export type ExtInstallReceipt<ExtType extends ExtensionType = ExtensionType> = AppiumExtInstallReceipt<ExtType>;
 /**
  * Extra stuff about extensions; used indirectly by {@linkcode ExtensionCliCommand.list}.
  */
 export type ExtensionListMetadata = {
-    /**
-     * - If `true`, the extension is installed
-     */
     installed: boolean;
-    /**
-     * - If the extension is installed and the latest
-     */
-    upToDate: boolean;
-    /**
-     * - If the extension is installed, the version it can be updated to
-     */
-    updateVersion: string | null;
-    /**
-     * - Same as above, but a major version bump
-     */
-    unsafeUpdateVersion: string | null;
-    /**
-     * - Update check error message (if present)
-     */
-    updateError?: string | undefined;
-    /**
-     * - If Appium is run from an extension's working copy
-     */
-    devMode?: boolean | undefined;
-    /**
-     * - Repository URL for the extension (if available)
-     */
-    repositoryUrl?: string | undefined;
+    upToDate?: boolean;
+    updateVersion?: string | null;
+    unsafeUpdateVersion?: string | null;
+    updateError?: string;
+    devMode?: boolean;
+    repositoryUrl?: string;
 };
-export type ExtensionType = import("@appium/types").ExtensionType;
-export type DriverType = import("@appium/types").DriverType;
-export type PluginType = import("@appium/types").PluginType;
-export type ExtRecord<ExtType extends ExtensionType> = import("appium/types").ExtRecord<ExtType>;
-export type ExtensionConfig<ExtType extends ExtensionType> = import("../extension/extension-config").ExtensionConfig<ExtType>;
-export type ExtMetadata<ExtType extends ExtensionType> = import("appium/types").ExtMetadata<ExtType>;
-export type ExtManifest<ExtType extends ExtensionType> = import("appium/types").ExtManifest<ExtType>;
-export type ExtPackageJson<ExtType extends ExtensionType> = import("appium/types").ExtPackageJson<ExtType>;
-export type ExtInstallReceipt<ExtType extends ExtensionType> = import("appium/types").ExtInstallReceipt<ExtType>;
 /**
  * Possible return value for {@linkcode ExtensionCliCommand.list}
  */
-export type ExtensionListData<ExtType extends ExtensionType> = Partial<ExtManifest<ExtType>> & Partial<ExtensionListMetadata>;
-export type InstalledExtensionListData<ExtType extends ExtensionType> = ExtManifest<ExtType> & ExtensionListMetadata;
+export type ExtensionListData<ExtType extends ExtensionType = ExtensionType> = Partial<ExtManifest<ExtType>> & Partial<ExtensionListMetadata>;
+export type InstalledExtensionListData<ExtType extends ExtensionType = ExtensionType> = ExtManifest<ExtType> & ExtensionListMetadata;
 /**
  * Return value of {@linkcode ExtensionCliCommand.list}.
  */
-export type ExtensionList<ExtType extends ExtensionType> = Record<string, ExtensionListData<ExtType>>;
-/**
- * Options for {@linkcode ExtensionCliCommand._run}.
- */
-export type RunOptions = {
-    /**
-     * - name of the extension to run a script from
-     */
-    installSpec: string;
-    /**
-     * - name of the script to run. If not provided
-     * then all available script names will be printed
-     */
-    scriptName?: string | undefined;
-    /**
-     * - arguments to pass to the script
-     */
-    extraArgs?: string[] | undefined;
-    /**
-     * - if true, will buffer the output of the script and return it
-     */
-    bufferOutput?: boolean | undefined;
-};
-/**
- * Options for {@linkcode ExtensionCliCommand.doctor}.
- */
-export type DoctorOptions = {
-    /**
-     * - name of the extension to run doctor checks for
-     */
-    installSpec: string;
-};
+export type ExtensionList<ExtType extends ExtensionType = ExtensionType> = Record<string, ExtensionListData<ExtType>>;
 /**
  * Return value of {@linkcode ExtensionCliCommand._run}
  */
 export type RunOutput = {
-    /**
-     * - script output if `bufferOutput` was `true` in {@linkcode RunOptions}
-     */
-    output?: string[] | undefined;
+    output?: string[];
 };
 /**
- * Options for {@linkcode ExtensionCliCommand._update}.
+ * Return type of {@linkcode ExtensionCliCommand.getPostInstallText}.
  */
-export type ExtensionUpdateOpts = {
-    /**
-     * - the name of the extension to update
-     */
-    installSpec: string;
-    /**
-     * - if true, will perform unsafe updates past major revision boundaries
-     */
-    unsafe: boolean;
-};
+export type PostInstallText = string;
 /**
  * Return value of {@linkcode ExtensionCliCommand._update}.
  */
 export type ExtensionUpdateResult = {
-    /**
-     * - map of ext names to error objects
-     */
     errors: Record<string, Error>;
-    /**
-     * - map of ext names to {@linkcode UpdateReport}s
-     */
     updates: Record<string, UpdateReport>;
 };
 /**
- * Part of result of {@linkcode ExtensionCliCommand._update}.
+ * Used by {@linkcode ExtensionCliCommand.getPostInstallText}
  */
-export type UpdateReport = {
-    /**
-     * - version the extension was updated from
-     */
-    from: string;
-    /**
-     * - version the extension was updated to
-     */
-    to: string;
+export type ExtensionArgs<ExtType extends ExtensionType = ExtensionType> = {
+    extName: string;
+    extData: ExtInstallReceipt<ExtType>;
 };
 /**
- * Options for {@linkcode ExtensionCliCommand._uninstall}.
+ * Options for {@linkcode ExtensionCliCommand._run}.
  */
-export type UninstallOpts = {
-    /**
-     * - the name or spec of an extension to uninstall
-     */
+type RunOptions = {
     installSpec: string;
+    scriptName?: string;
+    extraArgs?: string[];
+    bufferOutput?: boolean;
 };
 /**
- * Used by {@linkcode ExtensionCliCommand.getPostInstallText}
+ * Options for {@linkcode ExtensionCliCommand.doctor}.
  */
-export type ExtensionArgs = {
-    /**
-     * - the name of an extension
-     */
-    extName: string;
-    /**
-     * - the data for an installed extension
-     */
-    extData: object;
+type DoctorOptions = {
+    installSpec: string;
 };
 /**
- * Options for {@linkcode ExtensionCliCommand.installViaNpm}
+ * Options for {@linkcode ExtensionCliCommand._update}.
  */
-export type InstallViaNpmArgs = {
-    /**
-     * - the name or spec of an extension to install
-     */
+type ExtensionUpdateOpts = {
+    installSpec: string;
+    unsafe: boolean;
+};
+/**
+ * Part of result of {@linkcode ExtensionCliCommand._update}.
+ */
+type UpdateReport = {
+    from: string;
+    to: string | null;
+};
+/**
+ * Options for {@linkcode ExtensionCliCommand._uninstall}.
+ */
+type UninstallOpts = {
     installSpec: string;
-    /**
-     * - the NPM package name of the extension
-     */
-    pkgName: string;
-    /**
-     * - type of install
-     */
-    installType: import("appium/types").InstallType;
-    /**
-     * - the specific version of the NPM package
-     */
-    pkgVer?: string | undefined;
 };
 /**
  * Object returned by {@linkcode ExtensionCliCommand.checkForExtensionUpdate}
  */
-export type PossibleUpdates = {
-    /**
-     * - current version
-     */
+type PossibleUpdates = {
     current: string;
-    /**
-     * - version we can safely update to if it exists, or null
-     */
     safeUpdate: string | null;
-    /**
-     * - version we can unsafely update to if it exists, or null
-     */
     unsafeUpdate: string | null;
 };
 /**
  * Options for {@linkcode ExtensionCliCommand._install}
  */
-export type InstallOpts = {
-    /**
-     * - the name or spec of an extension to install
-     */
+type InstallOpts = {
     installSpec: string;
-    /**
-     * - how to install this extension. One of the INSTALL_TYPES
-     */
     installType: InstallType;
-    /**
-     * - for git/github installs, the extension node package name
-     */
-    packageName?: string | undefined;
+    packageName?: string;
 };
-export type KnownExtensions<ExtType extends ExtensionType> = ExtType extends DriverType ? typeof import("../constants").KNOWN_DRIVERS : ExtType extends PluginType ? typeof import("../constants").KNOWN_PLUGINS : never;
-export type ListOptions = {
-    /**
-     * - whether should show only installed extensions
-     */
+type ListOptions = {
     showInstalled: boolean;
-    /**
-     * - whether should show available updates
-     */
     showUpdates: boolean;
-    /**
-     * - whether to show additional data from the extension
-     */
-    verbose?: boolean | undefined;
-};
-/**
- * Opts for {@linkcode ExtensionCliCommand.getInstallationReceipt}
- */
-export type GetInstallationReceiptOpts<ExtType extends ExtensionType> = {
-    installPath: string;
-    installSpec: string;
-    pkg: ExtPackageJson<ExtType>;
-    installType: InstallType;
+    verbose?: boolean;
 };
-export type InstallType = import("appium/types").InstallType;
-/**
- * @template {ExtensionType} ExtType
- */
-declare class ExtensionCliCommand<ExtType extends ExtensionType> {
-    /**
-     * Build an ExtensionCommand
-     * @param {ExtensionCommandOptions<ExtType>} opts
-     */
-    constructor({ config, json }: ExtensionCommandOptions<ExtType>);
+declare abstract class ExtensionCliCommand<ExtType extends ExtensionType = ExtensionType> {
     /**
      * This is the `DriverConfig` or `PluginConfig`, depending on `ExtType`.
-     * @type {ExtensionConfig<ExtType>}
      */
-    config: ExtensionConfig<ExtType>;
+    protected readonly config: ExtensionConfig<ExtType>;
     /**
      * {@linkcode Record} of official plugins or drivers.
-     * @type {KnownExtensions<ExtType>}
      */
-    knownExtensions: KnownExtensions<ExtType>;
+    protected knownExtensions: Record<string, string>;
     /**
      * If `true`, command output has been requested as JSON.
-     * @type {boolean}
-     */
-    isJsonOutput: boolean;
-    log: console.CliConsole;
-    /**
-     * `driver` or `plugin`, depending on the `ExtensionConfig`.
      */
-    get type(): ExtType;
+    protected readonly isJsonOutput: boolean;
+    protected readonly log: any;
     /**
-     * Logs a message and returns an {@linkcode Error} to throw.
+     * Creates an extension command instance.
      *
-     * For TS to understand that a function throws an exception, it must actually throw an exception--
-     * in other words, _calling_ a function which is guaranteed to throw an exception is not enough--
-     * nor is something like `@returns {never}` which does not imply a thrown exception.
-     *
-     * @param {string} message
-     * @protected
-     * @throws {Error}
+     * @param opts - constructor options containing extension config and JSON mode
      */
-    protected _createFatalError(message: string): Error;
+    constructor({ config, json }: ExtensionCommandOptions<ExtType>);
     /**
-     * Take a CLI parse and run an extension command based on its type
-     *
-     * @param {object} args - a key/value object with CLI flags and values
-     * @return {Promise<object>} the result of the specific command which is executed
+     * `driver` or `plugin`, depending on the `ExtensionConfig`.
      */
-    execute(args: object): Promise<object>;
+    get type(): ExtensionType;
     /**
-     * List extensions
+     * Executes an extension subcommand from parsed CLI args.
      *
-     * @template {ExtensionType} ExtType
-     * @param {ListOptions} opts
-     * @return {Promise<ExtensionList<ExtType>>} map of extension names to extension data
+     * @param args - parsed CLI argument object
+     * @returns result of the executed extension subcommand
      */
-    list<ExtType_1 extends ExtensionType>({ showInstalled, showUpdates, verbose }: ListOptions): Promise<ExtensionList<ExtType_1>>;
+    execute(args: Record<string, any>): Promise<unknown>;
     /**
-     * Build the initial list data structure from installed and known extensions
+     * Lists available/installed extensions and optional update metadata.
      *
-     * @template {ExtensionType} ExtType
-     * @param {boolean} showInstalled
-     * @returns {ExtensionList<ExtType>}
-     * @private
+     * @param opts - list command options
+     * @returns map of extension names to list data
      */
-    private _buildListData;
+    list({ showInstalled, showUpdates, verbose }: ListOptions): Promise<ExtensionList>;
     /**
-     * Check for available updates for installed extensions
+     * Logs a message and returns an {@linkcode Error} to throw.
      *
-     * @template {ExtensionType} ExtType
-     * @param {ExtensionList<ExtType>} listData
-     * @param {boolean} showUpdates
-     * @param {string} lsMsg
-     * @returns {Promise<void>}
-     * @private
-     */
-    private _checkForUpdates;
-    /**
-     * Add repository URLs to list data for all extensions
+     * For TS to understand that a function throws an exception, it must actually throw an exception--
+     * in other words, _calling_ a function which is guaranteed to throw an exception is not enough--
+     * nor is something like a `never` return annotation, which does not imply a thrown exception.
      *
-     * @template {ExtensionType} ExtType
-     * @param {ExtensionList<ExtType>} listData
-     * @returns {Promise<void>}
-     * @private
+     * @throws {Error}
      */
-    private _addRepositoryUrlsToListData;
+    protected _createFatalError(message: string): Error;
     /**
-     * Display normal formatted output
+     * Build the initial list data structure from installed and known extensions
      *
-     * @template {ExtensionType} ExtType
-     * @param {ExtensionList<ExtType>} listData
-     * @param {boolean} showUpdates
-     * @returns {Promise<ExtensionList<ExtType>>}
-     * @private
      */
-    private _displayNormalListOutput;
+    protected _install({ installSpec, installType, packageName }: InstallOpts): Promise<Record<string, any>>;
     /**
-     * Format a single extension line for display
+     * Uninstall an extension.
      *
-     * @template {ExtensionType} ExtType
-     * @param {string} name
-     * @param {ExtensionListData<ExtType>} data
-     * @param {boolean} showUpdates
-     * @returns {Promise<string>}
-     * @private
-     */
-    private _formatExtensionLine;
-    /**
-     * Format installation status text
+     * First tries to do this via `npm uninstall`, but if that fails, just `rm -rf`'s the extension dir.
      *
-     * @template {ExtensionType} ExtType
-     * @param {InstalledExtensionListData<ExtType>} data
-     * @returns {string}
-     * @private
-     */
-    private _formatInstallText;
-    /**
-     * Format update information text
+     * Will only remove the extension from the manifest if it has been successfully removed.
      *
-     * @template {ExtensionType} ExtType
-     * @param {InstalledExtensionListData<ExtType>} data
-     * @returns {string}
-     * @private
+     * @return map of all installed extension names to extension data (without the extension just uninstalled)
      */
-    private _formatUpdateText;
+    protected _uninstall({ installSpec }: UninstallOpts): Promise<Record<string, any>>;
     /**
-     * Get repository URL from package data
+     * Attempt to update one or more drivers using NPM
      *
-     * @template {ExtensionType} ExtType
-     * @param {ExtensionListData<ExtType>} data
-     * @returns {Promise<string|null>}
-     * @private
      */
-    private _getRepositoryUrl;
+    protected _update({ installSpec, unsafe }: ExtensionUpdateOpts): Promise<ExtensionUpdateResult>;
     /**
-     * Get repository URL from installed extension's package.json
+     * Given an extension name, figure out what its highest possible version upgrade is, and also the
+     * highest possible safe upgrade.
      *
-     * @template {ExtensionType} ExtType
-     * @param {InstalledExtensionListData<ExtType>} data
-     * @returns {Promise<string|null>}
-     * @private
+     * @param ext - name of extension
      */
-    private _getRepositoryUrlFromInstalled;
+    protected checkForExtensionUpdate(ext: string): Promise<PossibleUpdates>;
     /**
-     * Get repository URL from npm for a package name
+     * Runs doctor checks for the given extension.
      *
-     * @param {string} pkgName
-     * @returns {Promise<string|null>}
-     * @private
+     * @returns The amount of Doctor checks that were
+     * successfully loaded and executed for the given extension
+     * @throws {Error} If any of the mandatory Doctor checks fails.
      */
-    private _getRepositoryUrlFromNpm;
+    protected _doctor({ installSpec }: DoctorOptions): Promise<number>;
     /**
-     * Checks whether the given extension is compatible with the currently installed server
+     * Runs a script cached inside the `scripts` field under `appium`
+     * inside of the extension's `package.json` file. Will throw
+     * an error if the driver/plugin does not contain a `scripts` field
+     * underneath the `appium` field in its `package.json`, if the
+     * `scripts` field is not a plain object, or if the `scriptName` is
+     * not found within `scripts` object.
      *
-     * @param {InstallViaNpmArgs} installViaNpmOpts
-     * @returns {Promise<void>}
      */
-    _checkInstallCompatibility({ installSpec, pkgName, pkgVer, installType }: InstallViaNpmArgs): Promise<void>;
+    protected _run({ installSpec, scriptName, extraArgs, bufferOutput, }: RunOptions): Promise<RunOutput>;
+    private _buildListData;
     /**
-     * Install an extension
+     * Install an extension via NPM
      *
-     * @param {InstallOpts} opts
-     * @return {Promise<ExtRecord<ExtType>>} map of all installed extension names to extension data
      */
-    _install({ installSpec, installType, packageName }: InstallOpts): Promise<ExtRecord<ExtType>>;
+    private installViaNpm;
     /**
-     * Install an extension via NPM
+     * Actually update an extension installed by NPM, using the NPM cli. And update the installation
+     * manifest.
      *
-     * @param {InstallViaNpmArgs} args
-     * @returns {Promise<ExtInstallReceipt<ExtType>>}
+     * @param installSpec - name of extension to update
+     * @param version - version string identifier to update extension to
      */
-    installViaNpm({ installSpec, pkgName, pkgVer, installType }: InstallViaNpmArgs): Promise<ExtInstallReceipt<ExtType>>;
+    private updateExtension;
     /**
-     * Get the text which should be displayed to the user after an extension has been installed. This
-     * is designed to be overridden by drivers/plugins with their own particular text.
+     * Just wraps {@linkcode child_process.spawn} with some default options
      *
-     * @param {ExtensionArgs} args
-     * @returns {string}
+     * @param cwd - CWD
+     * @param script - Path to script
+     * @param args - Extra args for script
+     * @param opts - Options
      */
-    getPostInstallText(args: ExtensionArgs): string;
+    private _runUnbuffered;
     /**
      * Once a package is installed on-disk, this gathers some necessary metadata for validation.
      *
-     * @param {GetInstallationReceiptOpts<ExtType>} opts
-     * @returns {ExtInstallReceipt<ExtType>}
      */
-    getInstallationReceipt({ pkg, installPath, installType, installSpec }: GetInstallationReceiptOpts<ExtType>): ExtInstallReceipt<ExtType>;
+    private getInstallationReceipt;
     /**
      * Validates the _required_ root fields of an extension's `package.json` file.
      *
@@ -447,87 +243,87 @@ declare class ExtensionCliCommand<ExtType extends ExtensionType> {
      * - `name`
      * - `version`
      * - `appium`
-     * @param {import('type-fest').PackageJson} pkg - `package.json` of extension
-     * @param {string} installSpec - Extension name/spec
+     * @param pkg - `package.json` of extension
+     * @param installSpec - Extension name/spec
      * @throws {ReferenceError} If `package.json` has a missing or invalid field
-     * @returns {pkg is ExtPackageJson<ExtType>}
      */
-    validatePackageJson(pkg: import("type-fest").PackageJson, installSpec: string): pkg is ExtPackageJson<ExtType>;
+    private validatePackageJson;
     /**
-     * For any `package.json` fields which a particular type of extension requires, validate the
-     * presence and form of those fields on the `package.json` data, throwing an error if anything is
-     * amiss.
+     * Check for available updates for installed extensions
      *
-     * @param {ExtMetadata<ExtType>} extMetadata - the data in the "appium" field of `package.json` for an extension
-     * @param {string} installSpec - Extension name/spec
      */
-    validateExtensionFields(extMetadata: ExtMetadata<ExtType>, installSpec: string): void;
+    private _checkForUpdates;
     /**
-     * Uninstall an extension.
+     * Add repository URLs to list data for all extensions
      *
-     * First tries to do this via `npm uninstall`, but if that fails, just `rm -rf`'s the extension dir.
+     */
+    private _addRepositoryUrlsToListData;
+    /**
+     * Display normal formatted output
      *
-     * Will only remove the extension from the manifest if it has been successfully removed.
+     */
+    private _displayNormalListOutput;
+    /**
+     * Format a single extension line for display
      *
-     * @param {UninstallOpts} opts
-     * @return {Promise<ExtRecord<ExtType>>} map of all installed extension names to extension data (without the extension just uninstalled)
      */
-    _uninstall({ installSpec }: UninstallOpts): Promise<ExtRecord<ExtType>>;
+    private _formatExtensionLine;
     /**
-     * Attempt to update one or more drivers using NPM
+     * Format installation status text
      *
-     * @param {ExtensionUpdateOpts} updateSpec
-     * @return {Promise<ExtensionUpdateResult>}
      */
-    _update({ installSpec, unsafe }: ExtensionUpdateOpts): Promise<ExtensionUpdateResult>;
+    private _formatInstallText;
     /**
-     * Given an extension name, figure out what its highest possible version upgrade is, and also the
-     * highest possible safe upgrade.
+     * Format update information text
      *
-     * @param {string} ext - name of extension
-     * @return {Promise<PossibleUpdates>}
      */
-    checkForExtensionUpdate(ext: string): Promise<PossibleUpdates>;
+    private _formatUpdateText;
     /**
-     * Actually update an extension installed by NPM, using the NPM cli. And update the installation
-     * manifest.
+     * Get repository URL from package data
      *
-     * @param {string} installSpec - name of extension to update
-     * @param {string} version - version string identifier to update extension to
-     * @returns {Promise<void>}
      */
-    updateExtension(installSpec: string, version: string): Promise<void>;
+    private _getRepositoryUrl;
     /**
-     * Just wraps {@linkcode child_process.spawn} with some default options
+     * Get repository URL from installed extension's package.json
      *
-     * @param {string} cwd - CWD
-     * @param {string} script - Path to script
-     * @param {string[]} args - Extra args for script
-     * @param {import('child_process').SpawnOptions} opts - Options
-     * @returns {import('node:child_process').ChildProcess}
      */
-    _runUnbuffered(cwd: string, script: string, args?: string[], opts?: import("child_process").SpawnOptions): import("node:child_process").ChildProcess;
+    private _getRepositoryUrlFromInstalled;
     /**
-     * Runs doctor checks for the given extension.
+     * Get repository URL from npm for a package name
      *
-     * @param {DoctorOptions} opts
-     * @returns {Promise<number>} The amount of Doctor checks that were
-     * successfully loaded and executed for the given extension
-     * @throws {Error} If any of the mandatory Doctor checks fails.
      */
-    _doctor({ installSpec }: DoctorOptions): Promise<number>;
+    private _getRepositoryUrlFromNpm;
     /**
-     * Runs a script cached inside the `scripts` field under `appium`
-     * inside of the extension's `package.json` file. Will throw
-     * an error if the driver/plugin does not contain a `scripts` field
-     * underneath the `appium` field in its `package.json`, if the
-     * `scripts` field is not a plain object, or if the `scriptName` is
-     * not found within `scripts` object.
+     * Checks whether the given extension is compatible with the currently installed server
+     *
+     */
+    private _checkInstallCompatibility;
+    /**
+     * For any `package.json` fields which a particular type of extension requires, validate the
+     * presence and form of those fields on the `package.json` data, throwing an error if anything is
+     * amiss.
+     *
+     * @param extMetadata - the data in the "appium" field of `package.json` for an extension
+     * @param installSpec - Extension name/spec
+     */
+    protected abstract validateExtensionFields(extMetadata: ExtMetadata<ExtType>, installSpec: string): void;
+    /**
+     * Get the text which should be displayed to the user after an extension has been installed. This
+     * is designed to be overridden by drivers/plugins with their own particular text.
      *
-     * @param {RunOptions} opts
-     * @return {Promise<RunOutput>}
      */
-    _run({ installSpec, scriptName, extraArgs, bufferOutput }: RunOptions): Promise<RunOutput>;
+    protected abstract getPostInstallText(args: ExtensionArgs<ExtType>): PostInstallText;
 }
-import { console } from '@appium/support';
+/**
+ * This is needed to ensure proper module resolution for installed extensions,
+ * especially ESM ones.
+ *
+ * @param driverConfig - active driver extension config
+ * @param pluginConfig - active plugin extension config
+ * @param logger - logger instance used for non-fatal symlink errors
+ * @returns resolves when symlink injection has completed for all extensions
+ */
+export declare function injectAppiumSymlinks(driverConfig: ExtensionConfig<any>, pluginConfig: ExtensionConfig<any>, logger: AppiumLogger): Promise<void>;
+export default ExtensionCliCommand;
+export { ExtensionCliCommand as ExtensionCommand };
 //# sourceMappingURL=extension-command.d.ts.map