appium 3.2.2 → 3.3.1

package/build/lib/schema/schema.js

@@ -4,36 +4,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAllowedSchemaFileExtension = exports.getDefaultsForExtension = exports.getDefaultsForSchema = exports.flattenSchema = exports.getSchema = exports.validate = exports.resetSchema = exports.finalizeSchema = exports.isFinalized = exports.hasArgSpec = exports.getArgSpec = exports.getAllArgSpecs = exports.registerSchema = exports.SchemaUnsupportedSchemaError = exports.SchemaUnknownSchemaError = exports.SchemaNameConflictError = exports.SchemaFinalizationError = exports.ALLOWED_SCHEMA_EXTENSIONS = exports.RoachHotelMap = void 0;
-const ajv_1 = require("ajv");
+const ajv_1 = __importDefault(require("ajv"));
 const ajv_formats_1 = __importDefault(require("ajv-formats"));
 const lodash_1 = __importDefault(require("lodash"));
 const node_path_1 = __importDefault(require("node:path"));
-const constants_1 = require("../constants");
 const schema_1 = require("@appium/schema");
+const constants_1 = require("../constants");
 const arg_spec_1 = require("./arg-spec");
 const keywords_1 = require("./keywords");
 /**
  * Key/value pairs go in... but they don't come out.
- *
- * @template K,V
- * @extends {Map<K,V>}
  */
 class RoachHotelMap extends Map {
-    /**
-     * @param {K} key
-     * @param {V} value
-     */
     set(key, value) {
         if (this.has(key)) {
-            throw new Error(`${key} is already set`);
+            throw new Error(`${String(key)} is already set`);
         }
         return super.set(key, value);
     }
-    /**
-     * @param {K} key
-     */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    delete(key) {
+    delete(_key) {
         return false;
     }
     clear() {
@@ -41,66 +31,22 @@ class RoachHotelMap extends Map {
     }
 }
 exports.RoachHotelMap = RoachHotelMap;
-/**
- * Extensions that an extension schema file can have.
- */
-exports.ALLOWED_SCHEMA_EXTENSIONS = Object.freeze(new Set(/** @type {AllowedSchemaExtension[]} */ (['.json', '.js', '.cjs'])));
+exports.ALLOWED_SCHEMA_EXTENSIONS = Object.freeze(new Set(['.json', '.js', '.cjs']));
 const SCHEMA_KEY = '$schema';
-/**
- * A wrapper around Ajv and schema-related functions.
- *
- * Should have been named Highlander, because _there can only be one_
- */
 class AppiumSchema {
-    /**
-     * A mapping of unique argument IDs to their corresponding {@link ArgSpec}s.
-     *
-     * An "argument" is a CLI argument or a config property.
-     *
-     * Used to provide easy lookups of argument metadata when converting between different representations of those arguments.
-     * @type {RoachHotelMap<string,ArgSpec>}
-     */
+    static #instance;
     #argSpecs = new RoachHotelMap();
-    /**
-     * A map of extension types to extension names to schema objects.
-     *
-     * This data structure is used to ensure there are no naming conflicts. The schemas
-     * are stored here in memory until the instance is _finalized_.
-     * @type {Record<ExtensionType,Map<string,SchemaObject>>}
-     */
-    #registeredSchemas = { [constants_1.DRIVER_TYPE]: new Map(), [constants_1.PLUGIN_TYPE]: new Map() };
-    /**
-     * Ajv instance
-     *
-     * @type {Ajv}
-     */
+    #registeredSchemas = {
+        [constants_1.DRIVER_TYPE]: new Map(),
+        [constants_1.PLUGIN_TYPE]: new Map(),
+    };
     #ajv;
-    /**
-     * Singleton instance.
-     * @type {AppiumSchema}
-     */
-    static #instance;
-    /**
-     * Lookup of schema IDs to finalized schemas.
-     *
-     * This does not include references, but rather the root schemas themselves.
-     * @type {Record<string,StrictSchemaObject>?}
-     */
     #finalizedSchemas = null;
-    /**
-     * Initializes Ajv, adds standard formats and our custom keywords.
-     * @see https://npm.im/ajv-formats
-     * @private
-     */
     constructor() {
         this.#ajv = AppiumSchema._instantiateAjv();
     }
     /**
-     * Factory function for {@link AppiumSchema} instances.
-     *
-     * Returns a singleton instance if one exists, otherwise creates a new one.
-     * Binds public methods to the instance.
-     * @returns {AppiumSchema}
+     * Returns a singleton instance.
      */
     static create() {
         if (!AppiumSchema.#instance) {
@@ -125,157 +71,105 @@ class AppiumSchema {
         return AppiumSchema.#instance;
     }
     /**
-     * Returns `true` if a schema has been registered using given extension type and name.
-     *
-     * This does not depend on whether or not the instance has been _finalized_.
-     * @param {ExtensionType} extType - Extension type
-     * @param {string} extName - Name
-     * @returns {boolean} If registered
+     * Returns `true` if filename extension is an allowed schema extension.
+     */
+    static isAllowedSchemaFileExtension(filename) {
+        return exports.ALLOWED_SCHEMA_EXTENSIONS.has(node_path_1.default.extname(filename));
+    }
+    /**
+     * Returns `true` if schema is a plain object and not async.
+     */
+    static isSupportedSchemaType(schema) {
+        return lodash_1.default.isPlainObject(schema) && schema.$async !== true;
+    }
+    /**
+     * Configures and creates an Ajv instance.
+     */
+    static _instantiateAjv() {
+        const ajv = (0, ajv_formats_1.default)(new ajv_1.default({
+            // without this not much validation actually happens
+            allErrors: true,
+        }));
+        lodash_1.default.forEach(keywords_1.keywords, (keyword) => {
+            ajv.addKeyword(keyword);
+        });
+        return ajv;
+    }
+    /**
+     * Returns `true` if a schema has been registered for extension type/name.
      */
     hasRegisteredSchema(extType, extName) {
         return this.#registeredSchemas[extType].has(extName);
     }
     /**
-     * Return `true` if {@link AppiumSchema.finalize finalize} has been called
-     * successfully and {@link AppiumSchema.reset reset} has not been called since.
-     * @returns {boolean} If finalized
+     * Returns `true` if this instance has been finalized.
      */
     isFinalized() {
         return Boolean(this.#finalizedSchemas);
     }
+    /**
+     * Returns map of known argument specs.
+     */
     getAllArgSpecs() {
         return this.#argSpecs;
     }
     /**
-     * Call this when no more schemas will be registered.
-     *
-     * This does three things:
-     * 1. It combines all schemas from extensions into the Appium config schema,
-     *    then adds the result to the `Ajv` instance.
-     * 2. It adds schemas for _each_ argument/property for validation purposes.
-     *    The CLI uses these schemas to validate specific arguments.
-     * 3. The schemas are validated against JSON schema draft-07 (which is the
-     *    only one supported at this time)
-     *
-     * Any method in this instance that needs to interact with the `Ajv` instance
-     * will throw if this method has not been called.
-     *
-     * If the instance has already been finalized, this is a no-op.
-     * @public
-     * @throws {Error} If the schema is not valid
-     * @returns {Readonly<Record<string,StrictSchemaObject>>} Record of schema IDs to full schema objects
+     * Finalizes all registered schemas into Ajv and generates arg-spec lookups.
      */
-    finalize() {
+    async finalize() {
         if (this.isFinalized()) {
-            return /** @type {Record<string,StrictSchemaObject>} */ (this.#finalizedSchemas);
+            return this.#finalizedSchemas;
         }
         const ajv = this.#ajv;
-        // Ajv will _mutate_ the schema, so we need to clone it.
         const baseSchema = lodash_1.default.cloneDeep(schema_1.AppiumConfigJsonSchema);
-        /**
-         *
-         * @param {SchemaObject} schema
-         * @param {ExtensionType} [extType]
-         * @param {string} [extName]
-         */
         const addArgSpecs = (schema, extType, extName) => {
-            for (let [propName, propSchema] of Object.entries(schema)) {
+            for (const [propName, propSchema] of Object.entries(schema)) {
                 const argSpec = arg_spec_1.ArgSpec.create(propName, {
                     dest: propSchema.appiumCliDest,
                     defaultValue: propSchema.default,
                     extType,
                     extName,
                 });
-                const { arg } = argSpec;
-                this.#argSpecs.set(arg, argSpec);
+                this.#argSpecs.set(argSpec.arg, argSpec);
             }
         };
         addArgSpecs(lodash_1.default.omit(baseSchema.properties.server.properties, [constants_1.DRIVER_TYPE, constants_1.PLUGIN_TYPE]));
-        /**
-         * @type {Record<string,StrictSchemaObject>}
-         */
         const finalizedSchemas = {};
-        const finalSchema = lodash_1.default.reduce(this.#registeredSchemas, 
-        /**
-         * @param {typeof baseSchema} baseSchema
-         * @param {Map<string,SchemaObject>} extensionSchemas
-         * @param {ExtensionType} extType
-         */
-        (baseSchema, extensionSchemas, extType) => {
-            extensionSchemas.forEach((schema, extName) => {
+        for (const [extType, extensionSchemas] of Object.entries(this.#registeredSchemas)) {
+            for (const [extName, schema] of extensionSchemas.entries()) {
                 const $ref = arg_spec_1.ArgSpec.toSchemaBaseRef(extType, extName);
                 schema.$id = $ref;
-                schema.additionalProperties = false; // this makes `schema` become a `StrictSchemaObject`
-                baseSchema.properties.server.properties[extType].properties[extName] = {
-                    $ref,
-                    $comment: extName,
-                };
-                ajv.validateSchema(schema, true);
+                schema.additionalProperties = false;
+                baseSchema.properties.server.properties[extType].properties[extName] = { $ref, $comment: extName };
+                await ajv.validateSchema(schema, true);
                 addArgSpecs(schema.properties, extType, extName);
                 ajv.addSchema(schema, $ref);
-                finalizedSchemas[$ref] = /** @type {StrictSchemaObject} */ (schema);
-            });
-            return baseSchema;
-        }, baseSchema);
+                finalizedSchemas[$ref] = schema;
+            }
+        }
+        const finalSchema = baseSchema;
         ajv.addSchema(finalSchema, arg_spec_1.APPIUM_CONFIG_SCHEMA_ID);
         finalizedSchemas[arg_spec_1.APPIUM_CONFIG_SCHEMA_ID] = finalSchema;
-        ajv.validateSchema(finalSchema, true);
+        await ajv.validateSchema(finalSchema, true);
         this.#finalizedSchemas = finalizedSchemas;
         return Object.freeze(finalizedSchemas);
     }
     /**
-     * Configures and creates an Ajv instance.
-     * @private
-     * @returns {Ajv}
-     */
-    static _instantiateAjv() {
-        const ajv = (0, ajv_formats_1.default)(new ajv_1.Ajv({
-            // without this not much validation actually happens
-            allErrors: true,
-        }));
-        // add custom keywords to ajv. see schema-keywords.js
-        lodash_1.default.forEach(keywords_1.keywords, (keyword) => {
-            ajv.addKeyword(keyword);
-        });
-        return ajv;
-    }
-    /**
-     * Resets this instance to its original state.
-     *
-     * - Removes all added schemas from the `Ajv` instance
-     * - Resets the map of {@link ArgSpec ArgSpecs}
-     * - Resets the map of registered schemas
-     * - Sets the {@link AppiumSchema._finalized _finalized} flag to `false`
-     *
-     * If you need to call {@link AppiumSchema.finalize} again, you'll want to call this first.
-     * @returns {void}
+     * Resets this instance to initial state.
      */
     reset() {
         for (const schemaId of Object.keys(this.#finalizedSchemas ?? {})) {
             this.#ajv.removeSchema(schemaId);
         }
         this.#argSpecs = new RoachHotelMap();
-        this.#registeredSchemas = {
-            [constants_1.DRIVER_TYPE]: new Map(),
-            [constants_1.PLUGIN_TYPE]: new Map(),
-        };
+        this.#registeredSchemas = { [constants_1.DRIVER_TYPE]: new Map(), [constants_1.PLUGIN_TYPE]: new Map() };
         this.#finalizedSchemas = null;
-        // Ajv seems to have an over-eager cache, so we have to dump the object entirely.
         this.#ajv = AppiumSchema._instantiateAjv();
     }
     /**
-     * Registers a schema from an extension.
-     *
-     * This is "fail-fast" in that the schema will immediately be validated against JSON schema draft-07 _or_ whatever the value of the schema's `$schema` prop is.
-     *
-     * Does _not_ add the schema to the `ajv` instance (this is done by {@link AppiumSchema.finalize}).
-     * @param {ExtensionType} extType - Extension type
-     * @param {string} extName - Unique extension name for `type`
-     * @param {SchemaObject} schema - Schema object
-     * @throws {SchemaNameConflictError} If the schema is an invalid
-     * @returns {void}
+     * Registers an extension schema.
      */
-    registerSchema(extType, extName, schema) {
+    async registerSchema(extType, extName, schema) {
         if (!(extType && extName) || lodash_1.default.isUndefined(schema)) {
             throw new TypeError('Expected extension type, extension name, and a defined schema');
         }
@@ -289,53 +183,28 @@ class AppiumSchema {
             }
             throw new SchemaNameConflictError(extType, extName);
         }
-        this.#ajv.validateSchema(schema, true);
+        await this.#ajv.validateSchema(schema, true);
         this.#registeredSchemas[extType].set(normalizedExtName, schema);
     }
     /**
-     * Returns a {@link ArgSpec} for the given argument name.
-     * @param {string} name - CLI argument name
-     * @param {ExtensionType} [extType] - Extension type
-     * @param {string} [extName] - Extension name
-     * @returns {ArgSpec|undefined} ArgSpec or `undefined` if not found
+     * Returns an `ArgSpec` for argument name/ext context, if present.
      */
     getArgSpec(name, extType, extName) {
         return this.#argSpecs.get(arg_spec_1.ArgSpec.toArg(name, extType, extName));
     }
     /**
-     * Returns `true` if the instance knows about an argument by the given `name`.
-     * @param {string} name - CLI argument name
-     * @param {ExtensionType} [extType] - Extension type
-     * @param {string} [extName] - Extension name
-     * @returns {boolean} `true` if such an {@link ArgSpec} exists
+     * Returns `true` if an `ArgSpec` exists for argument name/ext context.
      */
     hasArgSpec(name, extType, extName) {
         return this.#argSpecs.has(arg_spec_1.ArgSpec.toArg(name, extType, extName));
     }
     /**
-     * Returns a `Record` of argument "dest" strings to default values.
-     *
-     * The "dest" string is the property name in object returned by
-     * `argparse.ArgumentParser['parse_args']`.
-     * @template {boolean|undefined} Flattened
-     * @param {Flattened} [flatten=true] - If `true`, flattens the returned object
-     * using "keypath"-style keys of the format `<extType>.<extName>.<argName>`.
-     * Otherwise, returns a nested object using `extType` and `extName` as
-     * properties. Base arguments (server arguments) are always at the top level.
-     * @returns {DefaultValues<Flattened>}
+     * Returns default values for all args, flattened or nested.
      */
-    getDefaults(flatten = /** @type {Flattened} */ (true)) {
+    getDefaults(flatten = true) {
         if (!this.isFinalized()) {
             throw new SchemaFinalizationError();
         }
-        /**
-         * @private
-         * @callback DefaultReducer
-         * @param {DefaultValues<Flattened>} defaults
-         * @param {ArgSpec} argSpec
-         * @returns {DefaultValues<Flattened>}
-         */
-        /** @type {DefaultReducer} */
         const reducer = flatten
             ? (defaults, { defaultValue, dest }) => {
                 if (!lodash_1.default.isUndefined(defaultValue)) {
@@ -349,16 +218,11 @@ class AppiumSchema {
                 }
                 return defaults;
             };
-        /** @type {DefaultValues<Flattened>} */
         const retval = {};
         return [...this.#argSpecs.values()].reduce(reducer, retval);
     }
     /**
-     * Returns a flattened Record of defaults for a specific extension. Keys will
-     * be of format `<argName>`.
-     * @param {ExtensionType} extType - Extension type
-     * @param {string} extName - Extension name
-     * @returns {Record<string,ArgSpecDefaultValue>}
+     * Returns flattened defaults for a specific extension.
      */
     getDefaultsForExtension(extType, extName) {
         if (!this.isFinalized()) {
@@ -373,27 +237,14 @@ class AppiumSchema {
         }, {});
     }
     /**
-     * Flatten schema into an array of `SchemaObject`s and associated
-     * {@link ArgSpec ArgSpecs}.
-     *
-     * Converts nested extension schemas to keys based on the extension type and
-     * name. Used when translating to `argparse` options or getting the list of
-     * default values (see {@link AppiumSchema.getDefaults}) for CLI or otherwise.
-     *
-     * The return value is an intermediate representation used by `cli-args`
-     * module's `toParserArgs`, which converts the finalized schema to parameters
-     * used by `argparse`.
-     * @throws If {@link AppiumSchema.finalize} has not been called yet.
-     * @returns {FlattenedSchema}
+     * Flattens finalized schemas into schema + argSpec tuples.
      */
     flatten() {
         const schema = this.getSchema();
-        /** @type { {properties: SchemaObject, prefix: string[]}[] } */
-        const stack = [{ properties: schema.properties, prefix: [] }];
-        /** @type {FlattenedSchema} */
+        const stack = [
+            { properties: schema.properties, prefix: [] },
+        ];
         const flattened = [];
-        // this bit is a recursive algorithm rewritten as a for loop.
-        // when we find something we want to traverse, we add it to `stack`
         for (const { properties, prefix } of stack) {
             const pairs = lodash_1.default.toPairs(properties);
             for (const [key, value] of pairs) {
@@ -402,10 +253,7 @@ class AppiumSchema {
                 }
                 const { properties, $ref } = value;
                 if (properties) {
-                    stack.push({
-                        properties,
-                        prefix: key === arg_spec_1.SERVER_PROP_NAME ? [] : [...prefix, key],
-                    });
+                    stack.push({ properties, prefix: key === arg_spec_1.SERVER_PROP_NAME ? [] : [...prefix, key] });
                 }
                 else if ($ref) {
                     let refSchema;
@@ -413,24 +261,18 @@ class AppiumSchema {
                         refSchema = this.getSchema($ref);
                     }
                     catch {
-                        // this can happen if an extension schema supplies a $ref to a non-existent schema
                         throw new SchemaUnknownSchemaError($ref);
                     }
                     const { normalizedExtName } = arg_spec_1.ArgSpec.extensionInfoFromRootSchemaId($ref);
                     if (!normalizedExtName) {
-                        /* istanbul ignore next */
                         throw new ReferenceError(`Could not determine extension name from schema ID ${$ref}. This is a bug.`);
                     }
-                    stack.push({
-                        properties: refSchema.properties,
-                        prefix: [...prefix, key, normalizedExtName],
-                    });
+                    stack.push({ properties: refSchema.properties, prefix: [...prefix, key, normalizedExtName] });
                 }
                 else if (key !== constants_1.DRIVER_TYPE && key !== constants_1.PLUGIN_TYPE) {
                     const [extType, extName] = prefix;
-                    const argSpec = this.getArgSpec(key, /** @type {ExtensionType} */ (extType), extName);
+                    const argSpec = this.getArgSpec(key, extType, extName);
                     if (!argSpec) {
-                        /* istanbul ignore next */
                         throw new ReferenceError(`Unknown argument with key ${key}, extType ${extType} and extName ${extName}. This is a bug.`);
                     }
                     flattened.push({ schema: lodash_1.default.cloneDeep(value), argSpec });
@@ -440,20 +282,20 @@ class AppiumSchema {
         return flattened;
     }
     /**
-     * Retrieves the schema itself
-     * @public
-     * @param {string} [ref] - Schema ID
-     * @throws If the schema has not yet been finalized
-     * @returns {SchemaObject}
+     * Returns schema by ID (default: base Appium schema).
      */
     getSchema(ref = arg_spec_1.APPIUM_CONFIG_SCHEMA_ID) {
-        return /** @type {SchemaObject} */ (this._getValidator(ref).schema);
+        return this._getValidator(ref).schema;
     }
     /**
-     * Retrieves schema validator function from Ajv
-     * @param {string} [id] - Schema ID
-     * @private
-     * @returns {import('ajv').ValidateFunction}
+     * Validates a value against schema by ID/reference.
+     */
+    validate(value, ref = arg_spec_1.APPIUM_CONFIG_SCHEMA_ID) {
+        const validator = this._getValidator(ref);
+        return !validator(value) && lodash_1.default.isArray(validator.errors) ? [...validator.errors] : [];
+    }
+    /**
+     * Retrieves schema validator function from Ajv.
      */
     _getValidator(id = arg_spec_1.APPIUM_CONFIG_SCHEMA_ID) {
         const validator = this.#ajv.getSchema(id);
@@ -461,50 +303,12 @@ class AppiumSchema {
             if (id === arg_spec_1.APPIUM_CONFIG_SCHEMA_ID) {
                 throw new SchemaFinalizationError();
             }
-            else {
-                throw new SchemaUnknownSchemaError(id);
-            }
+            throw new SchemaUnknownSchemaError(id);
         }
         return validator;
     }
-    /**
-     * Given an object, validates it against the Appium config schema.
-     * If errors occur, the returned array will be non-empty.
-     * @param {any} value - The value (hopefully an object) to validate against the schema
-     * @param {string} [ref] - Schema ID or ref.
-     * @public
-     * @returns {import('ajv').ErrorObject[]} Array of errors, if any.
-     */
-    validate(value, ref = arg_spec_1.APPIUM_CONFIG_SCHEMA_ID) {
-        const validator = this._getValidator(ref);
-        return !validator(value) && lodash_1.default.isArray(validator.errors) ? [...validator.errors] : [];
-    }
-    /**
-     * Returns `true` if `filename`'s file extension is allowed (in {@link ALLOWED_SCHEMA_EXTENSIONS}).
-     * @param {import('type-fest').LiteralUnion<AllowedSchemaExtension, string>} filename
-     * @returns {boolean}
-     */
-    static isAllowedSchemaFileExtension(filename) {
-        return exports.ALLOWED_SCHEMA_EXTENSIONS.has(
-        /** @type {AllowedSchemaExtension} */ (node_path_1.default.extname(filename)));
-    }
-    /**
-     * Returns `true` if `schema` is a plain object with a non-true `$async` property.
-     * @param {any} schema - Schema to check
-     * @returns {schema is SchemaObject}
-     */
-    static isSupportedSchemaType(schema) {
-        return lodash_1.default.isPlainObject(schema) && schema.$async !== true;
-    }
 }
-/**
- * Thrown when the {@link AppiumSchema} instance has not yet been finalized, but
- * the method called requires it.
- */
 class SchemaFinalizationError extends Error {
-    /**
-     * @type {Readonly<string>}
-     */
     code = 'APPIUMERR_SCHEMA_FINALIZATION';
     constructor() {
         super('Schema not yet finalized; `finalize()` must be called first.');
@@ -512,23 +316,11 @@ class SchemaFinalizationError extends Error {
 }
 exports.SchemaFinalizationError = SchemaFinalizationError;
 /**
- * Thrown when a "unique" schema ID conflicts with an existing schema ID.
- *
- * This is likely going to be caused by attempting to register the same schema twice.
+ * Thrown when a unique extension schema name conflicts with an existing one.
  */
 class SchemaNameConflictError extends Error {
-    /**
-     * @type {Readonly<string>}
-     */
     code = 'APPIUMERR_SCHEMA_NAME_CONFLICT';
-    /**
-     * @type {Readonly<{extType: ExtensionType, extName: string}>}
-     */
     data;
-    /**
-     * @param {ExtensionType} extType
-     * @param {string} extName
-     */
     constructor(extType, extName) {
         super(`Name for ${extType} schema "${extName}" conflicts with an existing schema`);
         this.data = { extType, extName };
@@ -536,20 +328,11 @@ class SchemaNameConflictError extends Error {
 }
 exports.SchemaNameConflictError = SchemaNameConflictError;
 /**
- * Thrown when a schema ID was expected, but it doesn't exist on the {@link Ajv} instance.
+ * Thrown when requested schema ID is unknown to Ajv.
  */
 class SchemaUnknownSchemaError extends ReferenceError {
-    /**
-     * @type {Readonly<string>}
-     */
     code = 'APPIUMERR_SCHEMA_UNKNOWN_SCHEMA';
-    /**
-     * @type {Readonly<{schemaId: string}>}
-     */
     data;
-    /**
-     * @param {string} schemaId
-     */
     constructor(schemaId) {
         super(`Unknown schema: "${schemaId}"`);
         this.data = { schemaId };
@@ -557,29 +340,14 @@ class SchemaUnknownSchemaError extends ReferenceError {
 }
 exports.SchemaUnknownSchemaError = SchemaUnknownSchemaError;
 /**
- * Thrown when a schema is provided, but it's of an unsupported type.
- *
- * "Valid" schemas which are unsupported include boolean schemas and async schemas
- * (having a `true` `$async` property).
+ * Thrown when provided schema type is unsupported (boolean/async/non-object).
  */
 class SchemaUnsupportedSchemaError extends TypeError {
-    /**
-     * @type {Readonly<string>}
-     */
     code = 'APPIUMERR_SCHEMA_UNSUPPORTED_SCHEMA';
-    /**
-     * @type {Readonly<{schema: any, extType: ExtensionType, extName: string}>}
-     */
     data;
-    /**
-     * @param {any} schema
-     * @param {ExtensionType} extType
-     * @param {string} extName
-     */
     constructor(schema, extType, extName) {
-        // https://github.com/Microsoft/TypeScript/issues/8277
         super((() => {
-            let msg = `Unsupported schema from ${extType} "${extName}":`;
+            const msg = `Unsupported schema from ${extType} "${extName}":`;
             if (lodash_1.default.isBoolean(schema)) {
                 return `${msg} schema cannot be a boolean`;
             }
@@ -587,7 +355,6 @@ class SchemaUnsupportedSchemaError extends TypeError {
                 if (schema.$async) {
                     return `${msg} schema cannot be an async schema`;
                 }
-                /* istanbul ignore next */
                 throw new TypeError(`schema IS supported; this error should not be thrown (this is a bug). value of schema: ${JSON.stringify(schema)}`);
             }
             return `${msg} schema must be a plain object without a true "$async" property`;
@@ -599,41 +366,4 @@ exports.SchemaUnsupportedSchemaError = SchemaUnsupportedSchemaError;
 const appiumSchema = AppiumSchema.create();
 exports.registerSchema = appiumSchema.registerSchema, exports.getAllArgSpecs = appiumSchema.getAllArgSpecs, exports.getArgSpec = appiumSchema.getArgSpec, exports.hasArgSpec = appiumSchema.hasArgSpec, exports.isFinalized = appiumSchema.isFinalized, exports.finalizeSchema = appiumSchema.finalize, exports.resetSchema = appiumSchema.reset, exports.validate = appiumSchema.validate, exports.getSchema = appiumSchema.getSchema, exports.flattenSchema = appiumSchema.flatten, exports.getDefaultsForSchema = appiumSchema.getDefaults, exports.getDefaultsForExtension = appiumSchema.getDefaultsForExtension;
 exports.isAllowedSchemaFileExtension = AppiumSchema.isAllowedSchemaFileExtension;
-/**
- * Appium only supports schemas that are plain objects; not arrays.
- * @typedef {import('ajv').SchemaObject & {[key: number]: never}} SchemaObject
- */
-/**
- * @typedef {import('@appium/types').ExtensionType} ExtensionType
- */
-/**
- * An object having property `additionalProperties: false`
- * @typedef StrictProp
- * @property {false} additionalProperties
- */
-/**
- * A {@link SchemaObject} with `additionalProperties: false`
- * @typedef {SchemaObject & StrictProp} StrictSchemaObject
- */
-/**
- * A list of schemas associated with properties and their corresponding {@link ArgSpec} objects.
- *
- * Intermediate data structure used when converting the entire schema down to CLI arguments.
- * @typedef { {schema: SchemaObject, argSpec: ArgSpec}[] } FlattenedSchema
- */
-/**
- * @typedef {ArgSpec['defaultValue']} ArgSpecDefaultValue
- */
-/**
- * e.g. `{driver: {foo: 'bar'}}` where `foo` is the arg name and `bar` is the default value.
- * @typedef {Record<string,Record<string,ArgSpecDefaultValue>>} NestedArgSpecDefaultValue
- */
-/**
- * Helper type for the return value of {@link AppiumSchema.getDefaults}
- * @template {boolean|undefined} Flattened
- * @typedef {Record<string,Flattened extends true ? ArgSpecDefaultValue : ArgSpecDefaultValue | NestedArgSpecDefaultValue>} DefaultValues
- */
-/**
- * @typedef {'.json'|'.js'|'.cjs'} AllowedSchemaExtension
- */
 //# sourceMappingURL=schema.js.map