@applitools/core 1.0.0

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "@applitools/core",
+  "version": "1.0.0",
+  "homepage": "https://applitools.com",
+  "bugs": {
+    "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/applitools/eyes.sdk.javascript1.git",
+    "directory": "js/packages/core-base"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": {
+    "name": "Applitools Team",
+    "email": "team@applitools.com"
+  },
+  "aliases": [
+    "core"
+  ],
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./dist/*": "./dist/*.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "eyes-check-network": "./dist/troubleshoot/check-network.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./types/index.d.ts",
+  "files": [
+    "dist",
+    "types"
+  ],
+  "scripts": {
+    "lint": "eslint '**/*.ts'",
+    "build": "tsc --project ./tsconfig.build.json",
+    "test": "mocha --no-timeouts -r ts-node/register --parallel --jobs 15 './test/**/*.spec.ts'",
+    "test:sanity": "yarn test:unit",
+    "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'",
+    "setup": "yarn docker:setup",
+    "docker:setup": "node ../scripts/scripts/generate-docker-compose-config.js && docker-compose up -d",
+    "docker:teardown": "docker-compose down",
+    "deps": "bongo deps",
+    "preversion": "bongo preversion",
+    "version": "bongo version",
+    "postversion": "bongo postversion --skip-release-notification"
+  },
+  "husky": {
+    "hooks": {
+      "pre-push": "yarn bongo lint"
+    }
+  },
+  "dependencies": {
+    "@applitools/core-base": "1.0.1",
+    "@applitools/dom-capture": "11.1.2",
+    "@applitools/dom-snapshot": "4.6.2",
+    "@applitools/driver": "1.9.28",
+    "@applitools/logger": "1.1.20",
+    "@applitools/nml-client": "1.2.1",
+    "@applitools/req": "1.1.4",
+    "@applitools/screenshoter": "3.5.2",
+    "@applitools/snippets": "2.4.5",
+    "@applitools/types": "1.5.13",
+    "@applitools/ufg-client": "1.0.1",
+    "@applitools/utils": "1.3.12",
+    "abort-controller": "3.0.0",
+    "throat": "6.0.1"
+  },
+  "devDependencies": {
+    "@applitools/bongo": "^2.2.0",
+    "@applitools/sdk-fake-eyes-server": "^2.1.3",
+    "@applitools/spec-driver-puppeteer": "^1.1.10",
+    "@applitools/spec-driver-selenium": "^1.3.22",
+    "@applitools/test-server": "^1.1.5",
+    "@applitools/test-utils": "^1.5.1",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "12",
+    "@types/selenium-webdriver": "^4.1.2",
+    "@typescript-eslint/eslint-plugin": "^5.38.0",
+    "@typescript-eslint/parser": "^5.38.0",
+    "eslint": "^8.23.1",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-mocha-no-only": "^1.1.1",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "husky": "^4.3.7",
+    "mocha": "^10.0.0",
+    "nock": "^13.2.8",
+    "png-async": "^0.9.4",
+    "prettier": "^2.6.2",
+    "puppeteer": "^16.2.0",
+    "selenium-webdriver": "^4.4.0",
+    "ts-node": "^10.7.0",
+    "typescript": "^4.8.3"
+  },
+  "engines": {
+    "node": ">=12.13.0"
+  }
+}

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

@@ -0,0 +1,11 @@
+import type { SpecDriver } from '@applitools/types';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    logger?: Logger;
+};
+export declare function makeGetViewportSize<TDriver, TContext, TElement, TSelector>({ spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, logger }: {
+    target: TDriver;
+    logger?: Logger;
+}) => Promise<import("@applitools/types").Size>;
+export {};

package/types/automation/locate.d.ts

@@ -0,0 +1,16 @@
+import type { SpecDriver, Region } from '@applitools/types';
+import type { Core as BaseCore } from '@applitools/types/base';
+import type { Target, LocateSettings } from '@applitools/types/classic';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    core: BaseCore;
+    target?: Target<TDriver>;
+    logger?: Logger;
+};
+export declare function makeLocate<TDriver, TContext, TElement, TSelector>({ spec, core, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TLocator extends string>({ target, settings, logger, }?: {
+    target?: Target<TDriver>;
+    settings?: LocateSettings<TLocator, TElement, TSelector>;
+    logger?: Logger;
+}) => Promise<Record<TLocator, Region[]>>;
+export {};

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

@@ -0,0 +1,12 @@
+import type { SpecDriver, Size } from '@applitools/types';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    logger?: Logger;
+};
+export declare function makeSetViewportSize<TDriver, TContext, TElement, TSelector>({ spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, size, logger }: {
+    target: TDriver;
+    size: Size;
+    logger?: Logger;
+}) => Promise<void>;
+export {};

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

@@ -0,0 +1,15 @@
+import type { Region } from '@applitools/types';
+import { ScreenshotSettings } from '@applitools/types/classic';
+import { type Logger } from '@applitools/logger';
+import { type Driver, type Element } from '@applitools/driver';
+export declare type Screenshot = {
+    image: any;
+    region: Region;
+    scrollingElement: Element<unknown, unknown, unknown, unknown>;
+    restoreState(): Promise<void>;
+};
+export declare function takeScreenshot<TDriver, TContext, TElement, TSelector>({ driver, settings, logger, }: {
+    driver: Driver<TDriver, TContext, TElement, TSelector>;
+    settings: ScreenshotSettings<TElement, TSelector>;
+    logger: Logger;
+}): Promise<Screenshot>;

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

@@ -0,0 +1,15 @@
+import type { Target, Config, CheckSettings, CloseSettings, TestResult } from '@applitools/types';
+import type { Eyes as ClassicEyes } from '@applitools/types/classic';
+import type { Eyes as UFGEyes } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TElement, TSelector> = {
+    eyes: ClassicEyes<TDriver, TElement, TSelector> | UFGEyes<TDriver, TElement, TSelector>;
+    logger: Logger;
+};
+export declare function makeCheckAndClose<TDriver, TElement, TSelector, TType extends 'classic' | 'ufg' = 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TDriver, TElement, TSelector>): ({ target, settings, config, logger, }?: {
+    target?: Target<TDriver, TType>;
+    settings?: CheckSettings<TElement, TSelector, TType> & CloseSettings<TType>;
+    config?: Config<TElement, TSelector, TType>;
+    logger?: Logger;
+}) => Promise<TestResult<TType>[]>;
+export {};

package/types/check.d.ts

@@ -0,0 +1,15 @@
+import type { Target, Config, CheckSettings, CheckResult } from '@applitools/types';
+import type { Eyes as ClassicEyes } from '@applitools/types/classic';
+import type { Eyes as UFGEyes } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TElement, TSelector> = {
+    eyes: ClassicEyes<TDriver, TElement, TSelector> | UFGEyes<TDriver, TElement, TSelector>;
+    logger: Logger;
+};
+export declare function makeCheck<TDriver, TElement, TSelector, TType extends 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TDriver, TElement, TSelector>): ({ target, settings, config, logger, }?: {
+    target?: Target<TDriver, TType>;
+    settings?: CheckSettings<TElement, TSelector, TType>;
+    config?: Config<TElement, TSelector, TType>;
+    logger?: Logger;
+}) => Promise<CheckResult<TType>[]>;
+export {};

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

@@ -0,0 +1,16 @@
+import type { SpecDriver } from '@applitools/types';
+import type { Eyes as BaseEyes } from '@applitools/types/base';
+import type { Target, CheckSettings, CloseSettings, TestResult } from '@applitools/types/classic';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    eyes: BaseEyes;
+    target?: Target<TDriver>;
+    logger?: Logger;
+};
+export declare function makeCheckAndClose<TDriver, TContext, TElement, TSelector>({ spec, eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }?: {
+    target?: Target<TDriver>;
+    settings?: CheckSettings<TElement, TSelector> & CloseSettings;
+    logger?: Logger;
+}) => Promise<TestResult[]>;
+export {};

package/types/classic/check.d.ts

@@ -0,0 +1,16 @@
+import type { SpecDriver } from '@applitools/types';
+import type { Eyes as BaseEyes } from '@applitools/types/base';
+import type { Target, CheckSettings, CheckResult } from '@applitools/types/classic';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    eyes: BaseEyes;
+    target?: Target<TDriver>;
+    logger?: Logger;
+};
+export declare function makeCheck<TDriver, TContext, TElement, TSelector>({ spec, eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }?: {
+    target?: Target<TDriver>;
+    settings?: CheckSettings<TElement, TSelector>;
+    logger?: Logger;
+}) => Promise<CheckResult[]>;
+export {};

package/types/classic/core.d.ts

@@ -0,0 +1,13 @@
+import type { SpecDriver } from '@applitools/types';
+import type { Core as BaseCore } from '@applitools/types/base';
+import type { Core } from '@applitools/types/classic';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    core?: BaseCore;
+    agentId?: string;
+    cwd?: string;
+    logger?: Logger;
+};
+export declare function makeCore<TDriver, TContext, TElement, TSelector>({ spec, core, agentId, cwd, logger, }: Options<TDriver, TContext, TElement, TSelector>): Core<TDriver, TElement, TSelector>;
+export {};

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

@@ -0,0 +1,16 @@
+import type { MaybeArray, SpecDriver } from '@applitools/types';
+import type { Eyes as BaseEyes } from '@applitools/types/base';
+import type { Target, ExtractTextSettings } from '@applitools/types/classic';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    eyes: BaseEyes;
+    target?: Target<TDriver>;
+    logger?: Logger;
+};
+export declare function makeExtractText<TDriver, TContext, TElement, TSelector>({ spec, eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }?: {
+    target?: Target<TDriver>;
+    settings?: MaybeArray<ExtractTextSettings<TElement, TSelector>>;
+    logger?: Logger;
+}) => Promise<string[]>;
+export {};

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

@@ -0,0 +1,16 @@
+import type { SpecDriver, TextRegion } from '@applitools/types';
+import type { Eyes as BaseEyes } from '@applitools/types/base';
+import type { Target, LocateTextSettings } from '@applitools/types/classic';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    eyes: BaseEyes;
+    target?: Target<TDriver>;
+    logger?: Logger;
+};
+export declare function makeLocateText<TDriver, TContext, TElement, TSelector>({ spec, eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TPattern extends string>({ target, settings, logger, }?: {
+    target?: Target<TDriver>;
+    settings?: LocateTextSettings<TPattern, TElement, TSelector>;
+    logger?: Logger;
+}) => Promise<Record<TPattern, TextRegion[]>>;
+export {};

package/types/classic/open-eyes.d.ts

@@ -0,0 +1,15 @@
+import type { SpecDriver } from '@applitools/types';
+import type { Core as BaseCore } from '@applitools/types/base';
+import type { Eyes, Target, OpenSettings } from '@applitools/types/classic';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    core: BaseCore;
+    logger?: Logger;
+};
+export declare function makeOpenEyes<TDriver, TContext, TElement, TSelector>({ spec, core, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }: {
+    target?: Target<TDriver>;
+    settings: OpenSettings;
+    logger?: Logger;
+}) => Promise<Eyes<TDriver, TElement, TSelector>>;
+export {};

package/types/classic/utils/take-dom-capture.d.ts

@@ -0,0 +1,13 @@
+import { type Driver } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+import { type PollScriptSettings } from '../../utils/execute-poll-script';
+import { type Fetch } from '@applitools/req';
+export declare type DomCaptureSettings = Partial<PollScriptSettings> & {
+    fetch?: Fetch;
+    chunkByteLength?: number;
+};
+export declare function takeDomCapture<TDriver extends Driver<unknown, unknown, unknown, unknown>>({ driver, settings, logger, }: {
+    driver: TDriver;
+    settings?: DomCaptureSettings;
+    logger: Logger;
+}): Promise<any>;

package/types/classic/utils/transform-check-settings.d.ts

@@ -0,0 +1,11 @@
+import type { CheckSettings as BaseCheckSettings } from '@applitools/types/base';
+import type { CheckSettings } from '@applitools/types/classic';
+import { type Logger } from '@applitools/logger';
+import { type Driver } from '@applitools/driver';
+import { type Screenshot } from '../../automation/utils/take-screenshot';
+export declare function transformCheckSettings<TDriver, TContext, TElement, TSelector>({ driver, settings, screenshot, logger, }: {
+    driver: Driver<TDriver, TContext, TElement, TSelector>;
+    settings: CheckSettings<TElement, TSelector>;
+    screenshot: Screenshot;
+    logger: Logger;
+}): Promise<BaseCheckSettings>;

package/types/close-manager.d.ts

@@ -0,0 +1,18 @@
+import type { Eyes, TestResult, TestResultSummary } from '@applitools/types';
+import type { Core as BaseCore } from '@applitools/types/base';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TElement, TSelector, TType extends 'classic' | 'ufg'> = {
+    core: BaseCore<unknown>;
+    storage: {
+        eyes: Eyes<TDriver, TElement, TSelector, TType>;
+        promise?: Promise<TestResult<TType>[]>;
+    }[];
+    logger?: Logger;
+};
+export declare function makeCloseManager<TDriver, TElement, TSelector, TType extends 'classic' | 'ufg' = 'classic'>({ core, storage, logger: defaultLogger, }: Options<TDriver, TElement, TSelector, TType>): ({ settings, logger, }?: {
+    settings?: {
+        throwErr?: boolean;
+    };
+    logger?: Logger;
+}) => Promise<TestResultSummary<TType>>;
+export {};

package/types/close.d.ts

@@ -0,0 +1,14 @@
+import type { Config, CloseSettings, TestResult } from '@applitools/types';
+import type { Eyes as ClassicEyes } from '@applitools/types/classic';
+import type { Eyes as UFGEyes } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TElement, TSelector> = {
+    eyes: ClassicEyes<TDriver, TElement, TSelector> | UFGEyes<TDriver, TElement, TSelector>;
+    logger: Logger;
+};
+export declare function makeClose<TDriver, TElement, TSelector, TType extends 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TDriver, TElement, TSelector>): ({ settings, config, logger, }?: {
+    settings?: CloseSettings<TType>;
+    config?: Config<TElement, TSelector, TType>;
+    logger?: Logger;
+}) => Promise<TestResult<TType>[]>;
+export {};

package/types/core.d.ts

@@ -0,0 +1,14 @@
+import type { SpecDriver } from '@applitools/types';
+import type { Core as BaseCore } from '@applitools/types/base';
+import type { Core } from '@applitools/types';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    concurrency?: number;
+    core?: BaseCore;
+    agentId?: string;
+    cwd?: string;
+    logger?: Logger;
+};
+export declare function makeCore<TDriver, TContext, TElement, TSelector>({ spec, concurrency, core, agentId, cwd, logger, }: Options<TDriver, TContext, TElement, TSelector>): Core<TDriver, TElement, TSelector>;
+export {};

package/types/errors/test-error.d.ts

@@ -0,0 +1,5 @@
+import type { TestResult } from '@applitools/types/base';
+import { CoreError } from '@applitools/core-base';
+export declare class TestError extends CoreError {
+    constructor(result: TestResult);
+}

package/types/extract-text.d.ts

@@ -0,0 +1,15 @@
+import type { MaybeArray, Target, Config, ExtractTextSettings } from '@applitools/types';
+import type { Eyes as ClassicEyes } from '@applitools/types/classic';
+import type { Eyes as UFGEyes } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TElement, TSelector> = {
+    eyes: ClassicEyes<TDriver, TElement, TSelector> | UFGEyes<TDriver, TElement, TSelector>;
+    logger: Logger;
+};
+export declare function makeExtractText<TDriver, TElement, TSelector, TType extends 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TDriver, TElement, TSelector>): ({ target, settings, config, logger, }: {
+    target?: Target<TDriver, TType>;
+    settings: MaybeArray<ExtractTextSettings<TElement, TSelector, TType>>;
+    config?: Config<TElement, TSelector, TType>;
+    logger?: Logger;
+}) => Promise<string[]>;
+export {};

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './core';
+export * as formatters from './utils/format-results';
+export * from '@applitools/driver/dist/debug';

package/types/locate-text.d.ts

@@ -0,0 +1,15 @@
+import type { TextRegion, Target, Config, LocateTextSettings } from '@applitools/types';
+import type { Eyes as ClassicEyes } from '@applitools/types/classic';
+import type { Eyes as UFGEyes } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TElement, TSelector> = {
+    eyes: ClassicEyes<TDriver, TElement, TSelector> | UFGEyes<TDriver, TElement, TSelector>;
+    logger: Logger;
+};
+export declare function makeLocateText<TDriver, TElement, TSelector, TType extends 'classic' | 'ufg' = 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TDriver, TElement, TSelector>): <TPattern extends string>({ target, settings, config, logger, }: {
+    target?: Target<TDriver, TType>;
+    settings: LocateTextSettings<TPattern, TElement, TSelector, TType>;
+    config?: Config<TElement, TSelector, TType>;
+    logger?: Logger;
+}) => Promise<Record<TPattern, TextRegion[]>>;
+export {};

package/types/locate.d.ts

@@ -0,0 +1,15 @@
+import type { Region, Target, Config, LocateSettings } from '@applitools/types';
+import type { Core as ClassicCore } from '@applitools/types/classic';
+import type { Core as UFGCore } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TElement, TSelector> = {
+    core: ClassicCore<TDriver, TElement, TSelector> | UFGCore<TDriver, TElement, TSelector>;
+    logger: Logger;
+};
+export declare function makeLocate<TDriver, TElement, TSelector, TType extends 'classic' | 'ufg'>({ core, logger: defaultLogger, }: Options<TDriver, TElement, TSelector>): <TLocator extends string>({ target, settings, config, logger, }: {
+    target?: Target<TDriver, TType>;
+    settings: LocateSettings<TLocator, TElement, TSelector>;
+    config?: Config<TElement, TSelector, TType>;
+    logger?: Logger;
+}) => Promise<Record<TLocator, Region[]>>;
+export {};

package/types/make-manager.d.ts

@@ -0,0 +1,19 @@
+import type { EyesManager, SpecDriver } from '@applitools/types';
+import type { Core as BaseCore } from '@applitools/types/base';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    core?: BaseCore;
+    concurrency?: number;
+    agentId?: string;
+    cwd?: string;
+    logger?: Logger;
+};
+export declare function makeMakeManager<TDriver, TContext, TElement, TSelector>({ spec, core, concurrency: defaultConcurrency, agentId: defaultAgentId, cwd, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TType extends "classic" | "ufg" = "classic">({ type, concurrency, legacyConcurrency, agentId, logger, }?: {
+    type?: TType;
+    concurrency?: number;
+    legacyConcurrency?: number;
+    agentId?: string;
+    logger?: Logger;
+}) => Promise<EyesManager<TDriver, TElement, TSelector, TType>>;
+export {};

package/types/open-eyes.d.ts

@@ -0,0 +1,19 @@
+import type { Eyes, Config, OpenSettings, SpecDriver } from '@applitools/types';
+import type { Core as ClassicCore } from '@applitools/types/classic';
+import type { Core as UFGCore } from '@applitools/types/ufg';
+import type { Core as BaseCore } from '@applitools/types/base';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    core?: BaseCore | ClassicCore<TDriver, TElement, TSelector> | UFGCore<TDriver, TElement, TSelector>;
+    concurrency?: number;
+    logger?: Logger;
+};
+export declare function makeOpenEyes<TDriver, TContext, TElement, TSelector>({ spec, core, concurrency, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TType extends "classic" | "ufg" = "classic">({ type, target, settings, config, logger, }: {
+    type?: TType;
+    target?: TDriver;
+    settings?: Partial<OpenSettings<TType>>;
+    config?: Config<TElement, TSelector, TType>;
+    logger?: Logger;
+}) => Promise<Eyes<TDriver, TElement, TSelector, TType, import("@applitools/types").Target<TDriver, TType>>>;
+export {};

package/types/troubleshoot/check-network.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+export declare function checkNetwork({ stream, eyes, ufg }?: {
+    stream?: NodeJS.WriteStream;
+    eyes?: {
+        testFetch(): Promise<void>;
+        testCurl(): Promise<void>;
+        testServer(): Promise<void>;
+        testHttps: () => Promise<void>;
+        url: URL;
+        cmd: string;
+    };
+    ufg?: {
+        testFetch(): Promise<void>;
+        testCurl(): Promise<void>;
+        testServer: () => Promise<void>;
+        testHttps(): Promise<void>;
+        url: URL;
+        getCmd: () => Promise<string>;
+    };
+}): Promise<void>;

package/types/troubleshoot/eyes.d.ts

@@ -0,0 +1,11 @@
+export declare const RENDER_INFO_URL: string;
+export declare const CURL_CMD: string;
+declare const _default: {
+    testFetch(): Promise<void>;
+    testCurl(): Promise<void>;
+    testServer(): Promise<void>;
+    testHttps: () => Promise<void>;
+    url: URL;
+    cmd: string;
+};
+export default _default;

package/types/troubleshoot/ufg.d.ts

@@ -0,0 +1,10 @@
+export declare const getCmd: () => Promise<string>;
+declare const _default: {
+    testFetch(): Promise<void>;
+    testCurl(): Promise<void>;
+    testServer: () => Promise<void>;
+    testHttps(): Promise<void>;
+    url: URL;
+    getCmd: () => Promise<string>;
+};
+export default _default;

package/types/troubleshoot/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const config: any;
+export declare function getProxyCurlArg(): string;
+export declare function presult(promise: any): any;
+export declare function ptimeoutWithError(promiseOrPromiseFunc: any, timeout: any, err: any): Promise<any>;

package/types/ufg/abort.d.ts

@@ -0,0 +1,17 @@
+import type { Renderer } from '@applitools/types';
+import type { Eyes as BaseEyes } from '@applitools/types/base';
+import type { TestResult } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+import { type AbortController } from 'abort-controller';
+declare type Options = {
+    storage: Promise<{
+        eyes: BaseEyes;
+        renderer: Renderer;
+    }>[];
+    controller: AbortController;
+    logger: Logger;
+};
+export declare function makeAbort({ storage, controller, logger: defaultLogger }: Options): ({ logger, }?: {
+    logger?: Logger;
+}) => Promise<TestResult[]>;
+export {};

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

@@ -0,0 +1,17 @@
+import type { SpecDriver } from '@applitools/types';
+import type { Eyes as BaseEyes } from '@applitools/types/base';
+import type { Target, TestInfo } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+import { type UFGClient } from '@applitools/ufg-client';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    getEyes: (options: {
+        rawEnvironment: any;
+    }) => Promise<BaseEyes>;
+    client: UFGClient;
+    test: TestInfo;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    target?: Target<TDriver>;
+    logger?: Logger;
+};
+export declare function makeCheckAndClose<TDriver, TContext, TElement, TSelector>(_options: Options<TDriver, TContext, TElement, TSelector>): any;
+export {};

package/types/ufg/check.d.ts

@@ -0,0 +1,27 @@
+import type { SpecDriver } from '@applitools/types';
+import type { Eyes as BaseEyes } from '@applitools/types/base';
+import type { Target, TestInfo, CheckSettings, CheckResult } from '@applitools/types/ufg';
+import { type AbortSignal } from 'abort-controller';
+import { type Logger } from '@applitools/logger';
+import { type UFGClient } from '@applitools/ufg-client';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    getEyes: (options: {
+        rawEnvironment: any;
+    }) => Promise<BaseEyes>;
+    client: UFGClient;
+    test: TestInfo;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    signal?: AbortSignal;
+    target?: Target<TDriver>;
+    logger?: Logger;
+};
+export declare function makeCheck<TDriver, TContext, TElement, TSelector>({ spec, getEyes, client, test, signal, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }: {
+    target?: Target<TDriver>;
+    settings?: CheckSettings<TElement, TSelector>;
+    logger?: Logger;
+}) => Promise<(CheckResult & {
+    promise: Promise<CheckResult & {
+        eyes: BaseEyes;
+    }>;
+})[]>;
+export {};

package/types/ufg/close.d.ts

@@ -0,0 +1,16 @@
+import type { Renderer } from '@applitools/types';
+import type { Eyes as BaseEyes } from '@applitools/types/base';
+import type { CloseSettings, TestResult } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+declare type Options = {
+    storage: Promise<{
+        eyes: BaseEyes;
+        renderer: Renderer;
+    }>[];
+    logger: Logger;
+};
+export declare function makeClose({ storage, logger: defaultLogger }: Options): ({ settings, logger, }?: {
+    settings?: CloseSettings;
+    logger?: Logger;
+}) => Promise<TestResult[]>;
+export {};

package/types/ufg/core.d.ts

@@ -0,0 +1,16 @@
+import type { SpecDriver } from '@applitools/types';
+import type { Core as BaseCore } from '@applitools/types/base';
+import type { Core } from '@applitools/types/ufg';
+import { type UFGClient } from '@applitools/ufg-client';
+import { type Logger } from '@applitools/logger';
+declare type Options<TDriver, TContext, TElement, TSelector> = {
+    concurrency: number;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    client?: UFGClient;
+    core?: BaseCore;
+    agentId?: string;
+    cwd?: string;
+    logger?: Logger;
+};
+export declare function makeCore<TDriver, TContext, TElement, TSelector>({ concurrency, spec, client, core, agentId, cwd, logger, }: Options<TDriver, TContext, TElement, TSelector>): Core<TDriver, TElement, TSelector>;
+export {};