@applitools/eyes 1.33.3 → 1.33.4

package/dist/Logger.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const logger_1 = require("@applitools/logger");
+const LogHandler_1 = require("./input/LogHandler");
+class Logger {
+    _makeLogger() {
+        return (0, logger_1.makeLogger)({
+            handler: this._options.handler && this._options.handler instanceof LogHandler_1.LogHandlerData
+                ? this._options.handler.toJSON()
+                : this._options.handler,
+            level: this._options.show || utils.general.getEnvValue('SHOW_LOGS', 'boolean') ? 'info' : 'silent',
+            format: { label: this._options.label },
+        });
+    }
+    constructor(loggerOrOptionsOrShow = false) {
+        this._options = {};
+        /** @internal */
+        this.isLogger = true;
+        if (utils.types.isBoolean(loggerOrOptionsOrShow)) {
+            return new Logger({ show: loggerOrOptionsOrShow });
+        }
+        else if (utils.types.has(loggerOrOptionsOrShow, ['log', 'console'])) {
+            this._logger = loggerOrOptionsOrShow;
+        }
+        else {
+            this._options = loggerOrOptionsOrShow;
+        }
+    }
+    /** @internal */
+    getLogger() {
+        if (!this._logger)
+            this._logger = this._makeLogger();
+        return this._logger;
+    }
+    getLogHandler() {
+        if (this._options.handler) {
+            if (!utils.types.has(this._options.handler, 'type')) {
+                return this._options.handler;
+            }
+            else if (this._options.handler.type === 'file') {
+                return new LogHandler_1.FileLogHandlerData(true, this._options.handler.filename, this._options.handler.append);
+            }
+            else if (this._options.handler.type === 'console') {
+                return new LogHandler_1.ConsoleLogHandlerData(true);
+            }
+        }
+        return new LogHandler_1.NullLogHandlerData();
+    }
+    setLogHandler(handler) {
+        this._options.handler = handler;
+        this._options.show = true;
+    }
+    verbose(...messages) {
+        if (!this._logger)
+            this._logger = this._makeLogger();
+        messages.forEach(message => this._logger.log(message));
+    }
+    log(...messages) {
+        if (!this._logger)
+            this._logger = this._makeLogger();
+        messages.forEach(message => this._logger.log(message));
+    }
+    warn(...messages) {
+        if (!this._logger)
+            this._logger = this._makeLogger();
+        messages.forEach(message => this._logger.warn(message));
+    }
+    error(...messages) {
+        if (!this._logger)
+            this._logger = this._makeLogger();
+        messages.forEach(message => this._logger.error(message));
+    }
+    fatal(...messages) {
+        if (!this._logger)
+            this._logger = this._makeLogger();
+        messages.forEach(message => this._logger.fatal(message));
+    }
+    open() {
+        var _a;
+        (_a = this._logger) === null || _a === void 0 ? void 0 : _a.open();
+    }
+    close() {
+        var _a;
+        (_a = this._logger) === null || _a === void 0 ? void 0 : _a.close();
+    }
+    /** @internal */
+    extend(label) {
+        if (this._logger)
+            return new Logger(this._logger.extend({ label }));
+        return new Logger({
+            show: this._options.show,
+            label: label !== null && label !== void 0 ? label : this._options.label,
+            handler: this._options.handler,
+        });
+    }
+}
+exports.Logger = Logger;

package/dist/Runners.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassicRunner = exports.VisualGridRunner = exports.EyesRunner = void 0;
+const NewTestError_1 = require("./errors/NewTestError");
+const DiffsFoundError_1 = require("./errors/DiffsFoundError");
+const TestFailedError_1 = require("./errors/TestFailedError");
+const RunnerOptions_1 = require("./input/RunnerOptions");
+const TestResults_1 = require("./output/TestResults");
+const TestResultsSummary_1 = require("./output/TestResultsSummary");
+const utils = __importStar(require("@applitools/utils"));
+class EyesRunner {
+    constructor(options) {
+        var _a;
+        /** @internal */
+        this._managerSettings = {};
+        /** @internal */
+        this._getResultsSettings = {};
+        this._maskLog = (_a = options === null || options === void 0 ? void 0 : options.maskLog) !== null && _a !== void 0 ? _a : false;
+        if (options) {
+            this._managerSettings = {
+                concurrency: options.testConcurrency,
+                legacyConcurrency: options.legacyConcurrency,
+                fetchConcurrency: options.fetchConcurrency,
+                removeDuplicateTests: options.removeDuplicateTests,
+            };
+            this._getResultsSettings = { removeDuplicateTests: options.removeDuplicateTests };
+        }
+    }
+    /** @internal */
+    attach(core) {
+        var _a;
+        (_a = this._core) !== null && _a !== void 0 ? _a : (this._core = core);
+    }
+    /** @internal */
+    async openEyes(options) {
+        var _a;
+        (_a = this._manager) !== null && _a !== void 0 ? _a : (this._manager = await this._core.makeManager({
+            type: this.type,
+            settings: this._managerSettings,
+            logger: options.logger,
+        }));
+        return await this._manager.openEyes(options);
+    }
+    async getAllTestResults(throwErr = true) {
+        var _a;
+        if (!this._manager)
+            return new TestResultsSummary_1.TestResultsSummaryData();
+        try {
+            const summary = await this._manager.getResults({ settings: { throwErr, ...this._getResultsSettings } });
+            return new TestResultsSummary_1.TestResultsSummaryData({ summary, core: this._core });
+        }
+        catch (err) {
+            if ((_a = err.info) === null || _a === void 0 ? void 0 : _a.result) {
+                const result = new TestResults_1.TestResultsData({ result: err.info.result, core: this._core });
+                if (err.reason === 'test failed') {
+                    throw new TestFailedError_1.TestFailedError(err.message, result);
+                }
+                else if (err.reason === 'test different') {
+                    throw new DiffsFoundError_1.DiffsFoundError(err.message, result);
+                }
+                else if (err.reason === 'test new') {
+                    throw new NewTestError_1.NewTestError(err.message, result);
+                }
+            }
+            throw err;
+        }
+    }
+}
+exports.EyesRunner = EyesRunner;
+class VisualGridRunner extends EyesRunner {
+    constructor(optionsOrLegacyConcurrency) {
+        let options;
+        if (utils.types.instanceOf(optionsOrLegacyConcurrency, RunnerOptions_1.RunnerOptionsFluent)) {
+            options = optionsOrLegacyConcurrency.toJSON();
+        }
+        else if (utils.types.isNumber(optionsOrLegacyConcurrency)) {
+            options = { legacyConcurrency: optionsOrLegacyConcurrency };
+        }
+        else {
+            options = optionsOrLegacyConcurrency;
+        }
+        super(options);
+        this.type = 'ufg';
+    }
+    get testConcurrency() {
+        var _a;
+        return (_a = this._managerSettings) === null || _a === void 0 ? void 0 : _a.concurrency;
+    }
+    /** @deprecated */
+    get legacyConcurrency() {
+        var _a;
+        return (_a = this._managerSettings) === null || _a === void 0 ? void 0 : _a.legacyConcurrency;
+    }
+    /** @deprecated */
+    getConcurrentSessions() {
+        var _a;
+        return (_a = this._managerSettings) === null || _a === void 0 ? void 0 : _a.legacyConcurrency;
+    }
+}
+exports.VisualGridRunner = VisualGridRunner;
+class ClassicRunner extends EyesRunner {
+    constructor() {
+        super(...arguments);
+        this.type = 'classic';
+    }
+}
+exports.ClassicRunner = ClassicRunner;

package/dist/SDK.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCoreWithCache = exports.initSDK = void 0;
+const core_1 = require("@applitools/core");
+const utils = __importStar(require("@applitools/utils"));
+function initSDK(options, maskLog) {
+    if (options) {
+        options.maskLog = maskLog;
+        options.offlineLocationPath = utils.general.getEnvValue('OFFLINE_LOCATION_PATH');
+    }
+    return {
+        core: (0, exports.getCoreWithCache)(options),
+        spec: options === null || options === void 0 ? void 0 : options.spec,
+    };
+}
+exports.initSDK = initSDK;
+exports.getCoreWithCache = utils.general.cachify(getCore);
+function getCore({ makeCore = core_1.makeCore, ...options } = {}) {
+    var _a;
+    (_a = options.agentId) !== null && _a !== void 0 ? _a : (options.agentId = `js/eyes/${require('../package.json').version}`);
+    return makeCore(options);
+}

package/dist/SessionEventHandlers.js

@@ -0,0 +1,193 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteSessionEventHandler = exports.SessionEventHandlers = exports.SessionEventHandler = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const RectangleSize_1 = require("./input/RectangleSize");
+const TestResults_1 = require("./output/TestResults");
+const ValidationInfo_1 = require("./output/ValidationInfo");
+const ValidationResult_1 = require("./output/ValidationResult");
+/** @deprecated */
+class SessionEventHandler {
+    /** @internal */
+    attach(eyes) {
+        this._detach = eyes.on((name, data = {}) => {
+            if (!utils.types.isFunction(this, name))
+                return;
+            const args = [];
+            if (name === 'setSizeWillStart') {
+                args.push(new RectangleSize_1.RectangleSizeData(data.viewportSize));
+            }
+            else if (['testStarted', 'validationWillStart', 'validationEnded', 'testEnded'].includes(name)) {
+                args.push(data.sessionId);
+                if (name === 'validationWillStart') {
+                    args.push(new ValidationInfo_1.ValidationInfoData(data.validationInfo));
+                }
+                else if (name === 'validationEnded') {
+                    args.push(data.validationId, new ValidationResult_1.ValidationResultData(data.validationResult));
+                }
+                else if (name === 'testEnded') {
+                    args.push(new TestResults_1.TestResultsData(data.testResults));
+                }
+            }
+            this[name](...args);
+        });
+    }
+    /** @internal */
+    detach() {
+        if (this._detach)
+            this._detach();
+    }
+}
+exports.SessionEventHandler = SessionEventHandler;
+/** @deprecated */
+class SessionEventHandlers extends SessionEventHandler {
+    constructor() {
+        super(...arguments);
+        this._handlers = new Set();
+    }
+    addEventHandler(handler) {
+        if (handler === this)
+            return;
+        this._handlers.add(handler);
+    }
+    removeEventHandler(handler) {
+        if (handler === this)
+            return;
+        this._handlers.delete(handler);
+    }
+    clearEventHandlers() {
+        this._handlers.clear();
+    }
+    initStarted() {
+        this._handlers.forEach(handler => handler.initStarted());
+    }
+    initEnded() {
+        this._handlers.forEach(handler => handler.initEnded());
+    }
+    setSizeWillStart(viewportSize) {
+        this._handlers.forEach(handler => handler.setSizeWillStart(viewportSize));
+    }
+    setSizeEnded() {
+        this._handlers.forEach(handler => handler.setSizeEnded());
+    }
+    testStarted(sessionId) {
+        this._handlers.forEach(handler => handler.testStarted(sessionId));
+    }
+    testEnded(sessionId, testResults) {
+        this._handlers.forEach(handler => handler.testEnded(sessionId, testResults));
+    }
+    validationWillStart(sessionId, validationInfo) {
+        this._handlers.forEach(handler => handler.validationWillStart(sessionId, validationInfo));
+    }
+    validationEnded(sessionId, validationId, validationResult) {
+        this._handlers.forEach(handler => handler.validationEnded(sessionId, validationId, validationResult));
+    }
+}
+exports.SessionEventHandlers = SessionEventHandlers;
+/**
+ * @undocumented
+ * @deprecated
+ */
+class RemoteSessionEventHandler extends SessionEventHandler {
+    constructor(optionsOrServerUrl, accessKey, timeout) {
+        super();
+        const options = utils.types.isObject(optionsOrServerUrl)
+            ? optionsOrServerUrl
+            : { serverUrl: optionsOrServerUrl, accessKey, timeout };
+        this._serverUrl = options.serverUrl;
+        this._accessKey = options.accessKey;
+        this._timeout = options.timeout;
+    }
+    get serverUrl() {
+        return this._serverUrl;
+    }
+    set serverUrl(serverUrl) {
+        this._serverUrl = serverUrl;
+    }
+    getServerUrl() {
+        return this._serverUrl;
+    }
+    setServerUrl(serverUrl) {
+        this.serverUrl = serverUrl;
+    }
+    get accessKey() {
+        return this._accessKey;
+    }
+    set accessKey(accessKey) {
+        this._accessKey = accessKey;
+    }
+    getAccessKey() {
+        return this.accessKey;
+    }
+    setAccessKey(accessKey) {
+        this._accessKey = accessKey;
+    }
+    get timeout() {
+        return this._timeout;
+    }
+    set timeout(timeout) {
+        this._timeout = timeout;
+    }
+    setTimeout(timeout) {
+        this._timeout = timeout;
+    }
+    getTimeout() {
+        return this._timeout;
+    }
+    initStarted() {
+        return undefined;
+    }
+    initEnded() {
+        return undefined;
+    }
+    setSizeWillStart() {
+        return undefined;
+    }
+    setSizeEnded() {
+        return undefined;
+    }
+    testStarted() {
+        return undefined;
+    }
+    testEnded() {
+        return undefined;
+    }
+    validationWillStart() {
+        return undefined;
+    }
+    validationEnded() {
+        return undefined;
+    }
+    /** @internal */
+    toJSON() {
+        return utils.general.toJSON(this, ['serverUrl', 'accessKey']);
+    }
+    /** @internal */
+    toString() {
+        return utils.general.toString(this);
+    }
+}
+exports.RemoteSessionEventHandler = RemoteSessionEventHandler;

package/dist/cli/cli.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint no-console: off */
+const core_1 = require("@applitools/core");
+const yargs_1 = __importDefault(require("yargs"));
+const Configuration_1 = require("../input/Configuration");
+const load_config_1 = require("./load-config");
+void yargs_1.default
+    .example([['eyes run-offline-snapshots', 'Run Eyes visual tests on existing snapshots']])
+    .command({
+    command: 'run-offline-snapshots',
+    builder: yargs => {
+        return yargs
+            .options({
+            offlineLocationPath: {
+                description: 'path to offline snapshots folder',
+                type: 'string',
+            },
+            failOnDiff: {
+                description: 'should exit process with non-zero exit code on visual diffs, thereby failing the CI job',
+                type: 'boolean',
+                default: false,
+            },
+            failOnError: {
+                description: 'should exit process with non-zero exit code on errors, thereby failing the CI job',
+                type: 'boolean',
+                default: true,
+            },
+            configPath: {
+                description: 'path to configuration file (applitools.config.js / applitools.config.ts)',
+                type: 'string',
+            },
+            jsonFilePath: {
+                description: 'path to json file with the test results',
+                type: 'string',
+            },
+        })
+            .fail((_msg, err, _yargs) => {
+            if (err) {
+                console.error(err.message);
+                // console.log(err)
+                process.exit(1);
+            }
+        });
+    },
+    handler: async (args) => {
+        const config = await (0, load_config_1.loadConfig)(args.configPath);
+        const options = { ...args, config: new Configuration_1.ConfigurationData(config).toJSON() };
+        await (0, core_1.runOfflineSnapshots)(options);
+    },
+})
+    .wrap(yargs_1.default.terminalWidth()).argv;

package/dist/cli/load-config.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = void 0;
+/* eslint no-console: off */
+const utils = __importStar(require("@applitools/utils"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+async function loadConfig(configPath) {
+    const configPathArr = configPath ? [configPath] : [];
+    const paths = configPathArr.concat(['applitools.config.js']);
+    let config = {};
+    try {
+        config = utils.config.getConfig({
+            paths,
+            traverse: false,
+            strict: true,
+        });
+        // @ts-ignore
+        if (config.__esModule) {
+            // @ts-ignore
+            config = config.default;
+        }
+    }
+    catch (err) {
+        if (err.code === 'ERR_REQUIRE_ESM') {
+            const resolvedPaths = paths.map(probablePath => path_1.default.resolve(process.cwd(), probablePath));
+            const foundPath = resolvedPaths.find(resolvedPath => fs_1.default.existsSync(resolvedPath));
+            if (foundPath) {
+                try {
+                    config = await import(foundPath);
+                }
+                catch (err) {
+                    console.warn(chalk_1.default.yellow(err.message));
+                }
+            }
+            else {
+                console.warn(chalk_1.default.yellow('Could not find configuration file.'));
+            }
+        }
+        else if (configPath) {
+            console.warn(chalk_1.default.yellow(`${err.message}. configPath: ${path_1.default.resolve(process.cwd(), configPath)}`));
+        }
+    }
+    return config;
+}
+exports.loadConfig = loadConfig;

package/dist/enums/AccessibilityGuidelinesVersion.js

@@ -0,0 +1,9 @@
+"use strict";
+/* GENERATED FILE */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessibilityGuidelinesVersionEnum = void 0;
+var AccessibilityGuidelinesVersionEnum;
+(function (AccessibilityGuidelinesVersionEnum) {
+    AccessibilityGuidelinesVersionEnum["WCAG_2_0"] = "WCAG_2_0";
+    AccessibilityGuidelinesVersionEnum["WCAG_2_1"] = "WCAG_2_1";
+})(AccessibilityGuidelinesVersionEnum || (exports.AccessibilityGuidelinesVersionEnum = AccessibilityGuidelinesVersionEnum = {}));

package/dist/enums/AccessibilityLevel.js

@@ -0,0 +1,9 @@
+"use strict";
+/* GENERATED FILE */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessibilityLevelEnum = void 0;
+var AccessibilityLevelEnum;
+(function (AccessibilityLevelEnum) {
+    AccessibilityLevelEnum["AA"] = "AA";
+    AccessibilityLevelEnum["AAA"] = "AAA";
+})(AccessibilityLevelEnum || (exports.AccessibilityLevelEnum = AccessibilityLevelEnum = {}));

package/dist/enums/AccessibilityRegionType.js

@@ -0,0 +1,12 @@
+"use strict";
+/* GENERATED FILE */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessibilityRegionTypeEnum = void 0;
+var AccessibilityRegionTypeEnum;
+(function (AccessibilityRegionTypeEnum) {
+    AccessibilityRegionTypeEnum["IgnoreContrast"] = "IgnoreContrast";
+    AccessibilityRegionTypeEnum["RegularText"] = "RegularText";
+    AccessibilityRegionTypeEnum["LargeText"] = "LargeText";
+    AccessibilityRegionTypeEnum["BoldText"] = "BoldText";
+    AccessibilityRegionTypeEnum["GraphicalObject"] = "GraphicalObject";
+})(AccessibilityRegionTypeEnum || (exports.AccessibilityRegionTypeEnum = AccessibilityRegionTypeEnum = {}));

package/dist/enums/AccessibilityStatus.js

@@ -0,0 +1,9 @@
+"use strict";
+/* GENERATED FILE */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessibilityStatusEnum = void 0;
+var AccessibilityStatusEnum;
+(function (AccessibilityStatusEnum) {
+    AccessibilityStatusEnum["Passed"] = "Passed";
+    AccessibilityStatusEnum["Failed"] = "Failed";
+})(AccessibilityStatusEnum || (exports.AccessibilityStatusEnum = AccessibilityStatusEnum = {}));