@applitools/core 2.0.1 → 2.2.0

package/dist/universal/spec-driver.js

@@ -0,0 +1,166 @@
+"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.makeSpec = void 0;
+const utils = __importStar(require("@applitools/utils"));
+function makeSpec({ socket, spec, }) {
+    const commands = {
+        // #region UTILITY
+        isDriver(driver) {
+            return utils.types.has(driver, 'applitools-ref-id');
+        },
+        isContext(context) {
+            return utils.types.has(context, 'applitools-ref-id');
+        },
+        isElement(element) {
+            return utils.types.has(element, ['applitools-ref-id', 'type']) && element.type === 'element';
+        },
+        isSelector(selector) {
+            return ((utils.types.has(selector, ['applitools-ref-id', 'type']) && selector.type === 'selector') ||
+                utils.types.isString(selector) ||
+                (utils.types.isPlainObject(selector) &&
+                    utils.types.has(selector, 'selector') &&
+                    (utils.types.isString(selector.selector) || utils.types.has(selector, 'applitools-ref-id'))));
+        },
+        extractContext(driver) {
+            return driver.context;
+        },
+        extractSelector(element) {
+            return element.selector;
+        },
+        extractHostName(driver) {
+            var _a;
+            return (_a = driver.hostname) !== null && _a !== void 0 ? _a : null;
+        },
+        isStaleElementError(error) {
+            return error === null || error === void 0 ? void 0 : error.isStaleElementError;
+        },
+        async isEqualElements(context, element1, element2) {
+            return socket.request('Driver.isEqualElements', { context, element1, element2 });
+        },
+        // #endregion
+        // #region COMMANDS
+        async mainContext(context) {
+            return socket.request('Driver.mainContext', { context });
+        },
+        async parentContext(context) {
+            return socket.request('Driver.parentContext', { context });
+        },
+        async childContext(context, element) {
+            return socket.request('Driver.childContext', { context, element });
+        },
+        async executeScript(context, script, arg) {
+            return socket.request('Driver.executeScript', { context, script: script.toString(), arg });
+        },
+        async findElement(context, selector, parent) {
+            return socket.request('Driver.findElement', { context, selector, parent });
+        },
+        async findElements(context, selector, parent) {
+            return socket.request('Driver.findElements', { context, selector, parent });
+        },
+        async waitForSelector(context, selector, parent, options) {
+            return socket.request('Driver.waitForSelector', { context, selector, parent, options });
+        },
+        async getElementText(context, element) {
+            return socket.request('Driver.getElementText', { context, element });
+        },
+        async setElementText(context, element, text) {
+            return socket.request('Driver.setElementText', { context, element, text });
+        },
+        async getWindowSize(driver) {
+            return socket.request('Driver.getWindowSize', { driver });
+        },
+        async setWindowSize(driver, size) {
+            return socket.request('Driver.setWindowSize', { driver, size });
+        },
+        async getViewportSize(driver) {
+            return socket.request('Driver.getViewportSize', { driver });
+        },
+        async setViewportSize(driver, size) {
+            return socket.request('Driver.setViewportSize', { driver, size });
+        },
+        async getCookies(driver, context) {
+            return socket.request('Driver.getCookies', { driver, context });
+        },
+        async getCapabilities(driver) {
+            return socket.request('Driver.getCapabilities', { driver });
+        },
+        async getSessionMetadata(driver) {
+            return socket.request('Driver.getSessionMetadata', { driver });
+        },
+        async getDriverInfo(driver) {
+            return socket.request('Driver.getDriverInfo', { driver });
+        },
+        async getTitle(driver) {
+            return socket.request('Driver.getTitle', { driver });
+        },
+        async getUrl(driver) {
+            return socket.request('Driver.getUrl', { driver });
+        },
+        async takeScreenshot(driver) {
+            return socket.request('Driver.takeScreenshot', { driver });
+        },
+        async click(context, element) {
+            return socket.request('Driver.click', { context, element });
+        },
+        async visit(driver, url) {
+            return socket.request('Driver.visit', { driver, url });
+        },
+        // #endregion
+        // #region NATIVE COMMANDS
+        async getSystemBars(driver) {
+            return socket.request('Driver.getSystemBars', { driver });
+        },
+        async getOrientation(driver) {
+            return socket.request('Driver.getOrientation', { driver });
+        },
+        async setOrientation(driver, orientation) {
+            return socket.request('Driver.setOrientation', { driver, orientation });
+        },
+        async getElementRegion(driver, element) {
+            return socket.request('Driver.getElementRegion', { driver, element });
+        },
+        async getElementAttribute(driver, element, attr) {
+            return socket.request('Driver.getElementAttribute', { driver, element, attr });
+        },
+        async performAction(driver, steps) {
+            return socket.request('Driver.performAction', { driver, steps });
+        },
+        async getCurrentWorld(driver) {
+            return socket.request('Driver.getCurrentWorld', { driver });
+        },
+        async getWorlds(driver) {
+            return socket.request('Driver.getWorlds', { driver });
+        },
+        async switchWorld(driver, name) {
+            return socket.request('Driver.switchWorld', { driver, name });
+        },
+        // #endregion
+    };
+    return spec.reduce((spec, name) => {
+        return Object.assign(spec, { [name]: commands[name] });
+    }, {});
+}
+exports.makeSpec = makeSpec;

package/dist/universal/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/universal/ws-server.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeServer = void 0;
+const http_1 = require("http");
+const https_1 = require("https");
+const ws_1 = require("ws");
+const { name, version } = require('../../package.json');
+const TOKEN_HEADER = 'x-eyes-universal-token';
+const TOKEN = `${name}@${version}`;
+async function makeServer(options = {}) {
+    const { port = 21077, singleton = true, debug = false, portResolutionMode = 'next', cert, key } = options;
+    const secure = Boolean(cert && key);
+    const http = secure ? new https_1.Server({ cert, key }) : new http_1.Server();
+    http.on('request', (request, response) => {
+        if (request.url === '/handshake') {
+            const token = debug ? request.headers[TOKEN_HEADER] : TOKEN;
+            if (request.headers[TOKEN_HEADER] === token) {
+                response.writeHead(200, { [TOKEN_HEADER]: token });
+            }
+            else {
+                response.writeHead(400);
+            }
+            response.end();
+        }
+    });
+    http.listen(port, 'localhost');
+    return new Promise((resolve, reject) => {
+        http.on('listening', () => {
+            const ws = new ws_1.Server({ server: http, path: '/eyes', maxPayload: 256 * 1024 * 1024 });
+            ws.on('close', () => http.close());
+            resolve({ server: ws, port: http.address().port });
+        });
+        http.on('error', async (err) => {
+            if (portResolutionMode !== 'lazy' && err.code === 'EADDRINUSE') {
+                if (singleton && (await isHandshakable({ port, secure }))) {
+                    return resolve({ port });
+                }
+                else {
+                    return resolve(await makeServer({ ...options, port: portResolutionMode === 'next' ? port + 1 : 0 }));
+                }
+            }
+            reject(err);
+        });
+    });
+}
+exports.makeServer = makeServer;
+async function isHandshakable({ port, secure }) {
+    const request = secure ? https_1.request : http_1.request;
+    return new Promise(resolve => {
+        const handshake = request(`${secure ? 'https' : 'http'}://localhost:${port}/handshake`, {
+            headers: { [TOKEN_HEADER]: TOKEN },
+        });
+        handshake.on('response', ({ statusCode, headers }) => {
+            resolve(statusCode === 200 && headers[TOKEN_HEADER] === TOKEN);
+        });
+        handshake.on('error', () => resolve(false));
+        handshake.end();
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -31,6 +31,7 @@
     "./package.json": "./package.json"
   },
   "bin": {
+    "eyes": "./dist/cli/cli.js",
     "eyes-check-network": "./dist/troubleshoot/check-network.js"
   },
   "main": "./dist/index.js",
@@ -41,9 +42,17 @@
   ],
   "scripts": {
     "lint": "node ../../node_modules/.bin/eslint '**/*.ts'",
-    "build": "node ../../node_modules/.bin/tsc --project ./tsconfig.build.json",
-    "test": "mocha --no-timeouts -r ts-node/register --parallel --jobs 15 './test/**/*.spec.ts'",
+    "build": "yarn build:dist",
+    "build:dist": "node ../../node_modules/.bin/tsc --project ./tsconfig.build.json",
+    "build:x64": "yarn build:dist && yarn build:bin:x64",
+    "build:arm64": "yarn build:dist && yarn build:bin:arm64",
+    "build:bin:x64": "pkg . --target node14-linux-x64,node14-alpine-x64,node14-macos-x64,node14-win-x64",
+    "build:bin:arm64": "pkg . --target node14-linux-arm64 --output ./bin/core-linux-arm64",
+    "build:bin:zip": "zip -j ./bin/core.zip $(find ./bin -type f -not -name '*.zip' -not -name '*.tar.gz' | xargs)",
+    "build:bin:tgz": "tar -czf ./bin/core.tar.gz $(find ./bin -type f -not -name '*.zip' -not -name '*.tar.gz' | xargs)",
+    "test": "mocha --no-timeouts -r ts-node/register --parallel --jobs 15 --exit --exclude './test/bin/**' './test/**/*.spec.ts'",
     "test:sanity": "yarn test:unit",
+    "test:bin": "mocha --no-timeouts -r ts-node/register --parallel --jobs 15 './test/bin/**/*.spec.ts'",
     "test:e2e": "mocha --no-timeouts -r ts-node/register --parallel --jobs 15 './test/e2e/**/*.spec.ts'",
     "test:it": "mocha --no-timeouts -r ts-node/register './test/it/**/*.spec.ts'",
     "test:unit": "mocha --no-timeouts -r ts-node/register './test/unit/**/*.spec.ts'",
@@ -51,45 +60,59 @@
     "docker:setup": "node ../../scripts/generate-docker-compose-config.js && docker-compose up -d",
     "docker:teardown": "docker-compose down",
     "deps": "bongo deps",
-    "preversion": "bongo preversion",
-    "version": "bongo version",
+    "preversion": "bongo preversion --verify-pending-changes --skip-deps",
+    "version": "bongo version --with-pending-changes",
     "postversion": "bongo postversion --skip-release-notification"
   },
+  "pkg": {
+    "scripts": "./dist/cli/cli.js",
+    "outputPath": "./bin",
+    "compress": "GZip",
+    "assets": [
+      "./node_modules/vm2/lib/setup-sandbox.js"
+    ]
+  },
   "dependencies": {
-    "@applitools/core-base": "1.1.34",
+    "@applitools/core-base": "1.1.36",
     "@applitools/dom-capture": "11.2.1",
     "@applitools/dom-snapshot": "4.7.3",
     "@applitools/driver": "1.11.29",
+    "@applitools/ec-client": "1.2.8",
     "@applitools/logger": "1.1.45",
-    "@applitools/nml-client": "1.3.32",
+    "@applitools/nml-client": "1.3.34",
     "@applitools/req": "1.1.30",
-    "@applitools/screenshoter": "3.7.25",
+    "@applitools/screenshoter": "3.7.26",
     "@applitools/snippets": "2.4.15",
-    "@applitools/ufg-client": "1.1.24",
+    "@applitools/socket": "1.0.6",
+    "@applitools/spec-driver-webdriver": "1.0.7",
+    "@applitools/ufg-client": "1.1.25",
     "@applitools/utils": "1.3.30",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
     "node-fetch": "2.6.7",
-    "throat": "6.0.1"
-  },
-  "optionalDependencies": {
-    "@applitools/ec-client": "1.2.6"
+    "throat": "6.0.1",
+    "webdriver": "7.30.0",
+    "ws": "8.12.0",
+    "yargs": "17.6.2"
   },
   "devDependencies": {
-    "@applitools/bongo": "^2.2.2",
+    "@applitools/bongo": "^2.2.5",
     "@applitools/spec-driver-puppeteer": "^1.1.40",
     "@applitools/spec-driver-selenium": "^1.5.27",
-    "@applitools/spec-driver-webdriverio": "^1.4.24",
-    "@applitools/test-server": "^1.1.24",
+    "@applitools/spec-driver-webdriverio": "^1.4.25",
+    "@applitools/test-server": "^1.1.25",
     "@applitools/test-utils": "^1.5.12",
     "@types/mocha": "^9.1.1",
     "@types/node": "12",
     "@types/selenium-webdriver": "^4.1.2",
+    "@types/ws": "^8.5.4",
+    "@types/yargs": "^17.0.22",
     "chromedriver": "^106.0.0",
     "mocha": "^10.0.0",
     "nock": "^13.2.8",
+    "pkg": "^5.8.0",
     "png-async": "^0.9.4",
-    "puppeteer": "^16.2.0",
+    "puppeteer": "^19.7.0",
     "selenium-webdriver": "4.4",
     "webdriverio": "^7.25.0"
   },

package/types/automation/extract-text.d.ts

@@ -1,16 +0,0 @@
-import type { MaybeArray } from '@applitools/utils';
-import type { DriverTarget, ImageTarget, ExtractTextSettings } from '../classic/types';
-import type { Core as BaseCore } from '@applitools/core-base';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-type Options<TSpec extends SpecType> = {
-    core: BaseCore;
-    spec?: SpecDriver<TSpec>;
-    logger: Logger;
-};
-export declare function makeExtractText<TSpec extends SpecType>({ core, spec, logger: defaultLogger }: Options<TSpec>): ({ target, settings, logger, }: {
-    target: DriverTarget<TSpec> | ImageTarget;
-    settings: MaybeArray<ExtractTextSettings<TSpec>>;
-    logger?: Logger | undefined;
-}) => Promise<string[]>;
-export {};

package/types/automation/get-viewport-size.d.ts

@@ -1,12 +0,0 @@
-import type { DriverTarget } from './types';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-type Options<TSpec extends SpecType> = {
-    spec: SpecDriver<TSpec>;
-    logger: Logger;
-};
-export declare function makeGetViewportSize<TSpec extends SpecType>({ spec, logger: defaultLogger }: Options<TSpec>): ({ target, logger, }: {
-    target: DriverTarget<TSpec>;
-    logger?: Logger | undefined;
-}) => Promise<import("@applitools/utils").Size>;
-export {};

package/types/automation/locate-text.d.ts

@@ -1,15 +0,0 @@
-import type { DriverTarget, ImageTarget, LocateTextSettings, LocateTextResult } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-type Options<TSpec extends SpecType> = {
-    core: BaseCore;
-    spec?: SpecDriver<TSpec>;
-    logger: Logger;
-};
-export declare function makeLocateText<TSpec extends SpecType>({ core, spec, logger: defaultLogger }: Options<TSpec>): <TPattern extends string>({ target, settings, logger, }: {
-    target: DriverTarget<TSpec> | ImageTarget;
-    settings: LocateTextSettings<TPattern, TSpec>;
-    logger?: Logger | undefined;
-}) => Promise<LocateTextResult<TPattern>>;
-export {};

package/types/automation/locate.d.ts

@@ -1,15 +0,0 @@
-import type { DriverTarget, ImageTarget, LocateSettings, LocateResult } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-type Options<TSpec extends SpecType> = {
-    core: BaseCore;
-    spec?: SpecDriver<TSpec>;
-    logger: Logger;
-};
-export declare function makeLocate<TSpec extends SpecType>({ spec, core, logger: defaultLogger }: Options<TSpec>): <TLocator extends string>({ settings, target, logger, }: {
-    target: DriverTarget<TSpec> | ImageTarget;
-    settings: LocateSettings<TLocator, TSpec>;
-    logger?: Logger | undefined;
-}) => Promise<LocateResult<TLocator>>;
-export {};

package/types/automation/set-viewport-size.d.ts

@@ -1,14 +0,0 @@
-import type { Size } from '@applitools/utils';
-import type { DriverTarget } from './types';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-type Options<TSpec extends SpecType> = {
-    spec: SpecDriver<TSpec>;
-    logger: Logger;
-};
-export declare function makeSetViewportSize<TSpec extends SpecType>({ spec, logger: defaultLogger }: Options<TSpec>): ({ target, size, logger, }: {
-    target: DriverTarget<TSpec>;
-    size: Size;
-    logger?: Logger | undefined;
-}) => Promise<void>;
-export {};

package/types/automation/types.d.ts

@@ -1,84 +0,0 @@
-import type { MaybeArray, Size, Region } from '@applitools/utils';
-import type * as BaseCore from '@applitools/core-base/types';
-import { type SpecType, type Driver, type ElementReference, type ContextReference } from '@applitools/driver';
-import { type Logger } from '@applitools/logger';
-export * from '@applitools/core-base/types';
-export type DriverTarget<TSpec extends SpecType> = TSpec['driver'] | Driver<TSpec>;
-export type Target<TSpec extends SpecType> = DriverTarget<TSpec> | BaseCore.Target;
-export interface Core<TSpec extends SpecType, TTarget = Target<TSpec>, TEyes extends Eyes<TSpec, TTarget> = Eyes<TSpec, TTarget>> extends BaseCore.Core<TTarget, TEyes> {
-    isDriver?(driver: any): driver is TSpec['driver'];
-    isElement?(element: any): element is TSpec['element'];
-    isSelector?(selector: any): selector is TSpec['selector'];
-    getViewportSize?(options: {
-        target: DriverTarget<TSpec>;
-        logger?: Logger;
-    }): Promise<Size>;
-    setViewportSize?(options: {
-        target: DriverTarget<TSpec>;
-        size: Size;
-        logger?: Logger;
-    }): Promise<void>;
-    openEyes(options: {
-        target?: DriverTarget<TSpec>;
-        settings: BaseCore.OpenSettings;
-        eyes?: BaseCore.Eyes[];
-        logger?: Logger;
-    }): Promise<TEyes>;
-    locate<TLocator extends string>(options: {
-        target: TTarget;
-        settings: LocateSettings<TLocator, TSpec>;
-        logger?: Logger;
-    }): Promise<BaseCore.LocateResult<TLocator>>;
-    locateText<TPattern extends string>(options: {
-        target: TTarget;
-        settings: LocateTextSettings<TPattern, TSpec>;
-        logger?: Logger;
-    }): Promise<BaseCore.LocateTextResult<TPattern>>;
-    extractText(options: {
-        target: TTarget;
-        settings: MaybeArray<ExtractTextSettings<TSpec>>;
-        logger?: Logger;
-    }): Promise<string[]>;
-}
-export interface Eyes<TSpec extends SpecType, TTarget = Target<TSpec>> extends BaseCore.Eyes<TTarget> {
-    getBaseEyes(options?: {
-        logger?: Logger;
-    }): Promise<BaseCore.Eyes[]>;
-    check(options?: {
-        target?: TTarget;
-        settings?: CheckSettings<TSpec>;
-        logger?: Logger;
-    }): Promise<BaseCore.CheckResult[]>;
-    checkAndClose(options?: {
-        target?: TTarget;
-        settings?: CheckSettings<TSpec> & BaseCore.CloseSettings;
-        logger?: Logger;
-    }): Promise<BaseCore.TestResult[]>;
-}
-export interface ScreenshotSettings<TSpec extends SpecType> extends BaseCore.ImageSettings<Region | ElementReference<TSpec>> {
-    frames?: (ContextReference<TSpec> | {
-        frame: ContextReference<TSpec>;
-        scrollRootElement?: ElementReference<TSpec>;
-    })[];
-    fully?: boolean;
-    scrollRootElement?: ElementReference<TSpec>;
-    stitchMode?: 'Scroll' | 'CSS';
-    hideScrollbars?: boolean;
-    hideCaret?: boolean;
-    overlap?: {
-        top?: number;
-        bottom?: number;
-    };
-    waitBeforeCapture?: number;
-    waitBetweenStitches?: number;
-    lazyLoad?: boolean | {
-        scrollLength?: number;
-        waitingTime?: number;
-        maxAmountToScroll?: number;
-    };
-    webview?: boolean | string;
-}
-export type LocateSettings<TLocator extends string, TSpec extends SpecType> = BaseCore.LocateSettings<TLocator, Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
-export type LocateTextSettings<TPattern extends string, TSpec extends SpecType> = BaseCore.LocateTextSettings<TPattern, Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
-export type ExtractTextSettings<TSpec extends SpecType> = BaseCore.ExtractTextSettings<Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
-export type CheckSettings<TSpec extends SpecType> = BaseCore.CheckSettings<Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;

package/types/automation/utils/take-screenshot.d.ts

@@ -1,19 +0,0 @@
-import type { Region } from '@applitools/utils';
-import type { ScreenshotSettings } from '../../classic/types';
-import { type Logger } from '@applitools/logger';
-import { type Driver, type Element, type ElementReference, type SpecType } from '@applitools/driver';
-export type Screenshot<TSpec extends SpecType> = {
-    image: any;
-    region: Region;
-    element: Element<TSpec>;
-    scrollingElement: Element<TSpec>;
-    restoreState(): Promise<void>;
-    calculatedRegions: [];
-};
-export declare function takeScreenshot<TSpec extends SpecType>({ driver, settings, logger, }: {
-    driver: Driver<TSpec>;
-    settings: ScreenshotSettings<TSpec> & {
-        regionsToCalculate?: ElementReference<TSpec>[];
-    };
-    logger: Logger;
-}): Promise<Screenshot<TSpec>>;

package/types/automation/utils/to-base-check-settings.d.ts

@@ -1,17 +0,0 @@
-import type { Region } from '@applitools/utils';
-import type { CheckSettings } from '../types';
-import type { CheckSettings as BaseCheckSettings } from '@applitools/core-base';
-import { type SpecType, type ElementReference, type Selector } from '@applitools/driver';
-export declare function toBaseCheckSettings<TSpec extends SpecType>({ settings }: {
-    settings: CheckSettings<TSpec>;
-}): {
-    elementReferencesToCalculate: ElementReference<TSpec>[];
-    elementReferenceToTarget: ElementReference<TSpec> | undefined;
-    getBaseCheckSettings: ({ calculatedRegions, preserveTransformation, }: {
-        calculatedRegions: {
-            selector?: Selector;
-            regions: Region[];
-        }[];
-        preserveTransformation?: boolean | undefined;
-    }) => BaseCheckSettings;
-};

package/types/automation/utils/wait-for-lazy-load.d.ts

@@ -1,14 +0,0 @@
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type Context } from '@applitools/driver';
-export type LazyLoadSettings = {
-    scrollLength?: number;
-    waitingTime?: number;
-    maxAmountToScroll?: number;
-    executionTimeout?: number;
-    pollTimeout?: number;
-};
-export declare function waitForLazyLoad<TSpec extends SpecType>({ context, settings, logger, }: {
-    context: Context<TSpec>;
-    settings: LazyLoadSettings;
-    logger: Logger;
-}): Promise<void>;

package/types/check-and-close.d.ts

@@ -1,18 +0,0 @@
-import type { Target, DriverTarget, Eyes, Config, CheckSettings, CloseSettings, TestResult } from './types';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
-    type?: TType;
-    eyes: Eyes<TSpec, TType>;
-    target?: DriverTarget<TSpec>;
-    spec?: SpecDriver<TSpec>;
-    logger: Logger;
-};
-export declare function makeCheckAndClose<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, target, settings, config, logger, }?: {
-    type?: TType | undefined;
-    target?: Target<TSpec, TType> | undefined;
-    settings?: (CheckSettings<TSpec, TDefaultType> & CloseSettings<TDefaultType> & CheckSettings<TSpec, TType> & CloseSettings<TType>) | undefined;
-    config?: (Config<TSpec, TDefaultType> & Config<TSpec, TType>) | undefined;
-    logger?: Logger | undefined;
-}) => Promise<TestResult<TType>[]>;
-export {};

package/types/check.d.ts

@@ -1,18 +0,0 @@
-import type { Target, DriverTarget, Eyes, Config, CheckSettings, CheckResult } from './types';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
-    type?: TType;
-    eyes: Eyes<TSpec, TType>;
-    target?: DriverTarget<TSpec>;
-    spec?: SpecDriver<TSpec>;
-    logger: Logger;
-};
-export declare function makeCheck<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, target, settings, config, logger, }?: {
-    type?: TType | undefined;
-    target?: Target<TSpec, TType> | undefined;
-    settings?: CheckSettings<TSpec, TType> | undefined;
-    config?: Config<TSpec, TType> | undefined;
-    logger?: Logger | undefined;
-}) => Promise<CheckResult<TType>[]>;
-export {};

package/types/classic/abort.d.ts

@@ -1,16 +0,0 @@
-import type { AbortSettings } from './types';
-import type { Eyes } from './types';
-import { type Logger } from '@applitools/logger';
-import type { DriverTarget } from './types';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-type Options<TSpec extends SpecType> = {
-    eyes: Eyes<TSpec>;
-    target?: DriverTarget<TSpec>;
-    spec?: SpecDriver<TSpec>;
-    logger: Logger;
-};
-export declare function makeAbort<TSpec extends SpecType>({ eyes, target, spec, logger: defaultLogger }: Options<TSpec>): ({ settings, logger, }?: {
-    settings?: AbortSettings | undefined;
-    logger?: Logger | undefined;
-}) => Promise<void>;
-export {};

package/types/classic/check-and-close.d.ts

@@ -1,19 +0,0 @@
-import type { Target, DriverTarget, Eyes, CheckSettings, CloseSettings, TestResult } from './types';
-import type { CheckSettings as BaseCheckSettings } from '@applitools/core-base';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-import * as utils from '@applitools/utils';
-type Options<TSpec extends SpecType> = {
-    eyes: Eyes<TSpec>;
-    target?: DriverTarget<TSpec>;
-    spec?: SpecDriver<TSpec>;
-    logger: Logger;
-};
-export declare function makeCheckAndClose<TSpec extends SpecType>({ eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TSpec>): ({ target, settings, logger, }?: {
-    target?: Target<TSpec> | undefined;
-    settings?: (BaseCheckSettings<utils.Region | import("@applitools/driver").ElementReference<TSpec>> & import("./types").ScreenshotSettings<TSpec> & {
-        retryTimeout?: number | undefined;
-    } & CloseSettings) | undefined;
-    logger?: Logger | undefined;
-}) => Promise<TestResult[]>;
-export {};

package/types/classic/check.d.ts

@@ -1,15 +0,0 @@
-import type { Target, DriverTarget, Eyes, CheckSettings, CheckResult } from './types';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-type Options<TSpec extends SpecType> = {
-    eyes: Eyes<TSpec>;
-    target?: DriverTarget<TSpec>;
-    spec?: SpecDriver<TSpec>;
-    logger: Logger;
-};
-export declare function makeCheck<TSpec extends SpecType>({ eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TSpec>): ({ target, settings, logger, }?: {
-    target?: Target<TSpec> | undefined;
-    settings?: CheckSettings<TSpec> | undefined;
-    logger?: Logger | undefined;
-}) => Promise<CheckResult[]>;
-export {};