@applitools/core 2.3.1 → 2.3.3

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Unreleased
 
+## 2.3.3 - 2023/2/16
+
+### Features
+### Bug fixes
+- Fixed debug mode
+- Fixed logs
+
+## 2.3.2 - 2023/2/16
+
+### Features
+- Added arm64 binary
+### Bug fixes
+
 ## 2.3.1 - 2023/2/15
 
 ### Features

package/dist/universal/core-server.js

@@ -11,6 +11,7 @@ const ws_server_1 = require("./ws-server");
 const logger_1 = require("@applitools/logger");
 const core_1 = require("../core");
 const refer_1 = require("./refer");
+const history_1 = require("./history");
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 async function makeCoreServer({ debug = false, shutdownMode = 'lazy', idleTimeout = 900000, // 15min
@@ -57,6 +58,7 @@ printStdout = false, ...handlerOptions } = {}) {
             transport: 'ws',
             logger: baseLogger,
         });
+        const getHistory = debug ? (0, history_1.withHistory)(socket) : () => null;
         if (shutdownMode === 'lazy' && idleTimeout) {
             clearTimeout(idle);
             socket.on('close', () => {
@@ -79,6 +81,7 @@ printStdout = false, ...handlerOptions } = {}) {
                 agentId: `eyes-universal/${require('../../package.json').version}/${agentId}`,
                 spec: spec === 'webdriver' ? spec_driver_webdriver_1.default : (0, spec_driver_1.makeSpec)({ socket, spec }),
                 cwd,
+                logger,
             });
         });
         socket.command('Core.getAccountInfo', async (options) => {
@@ -144,6 +147,9 @@ printStdout = false, ...handlerOptions } = {}) {
             refer.destroy(eyes);
             return results;
         });
+        socket.command('Debug.getHistory', async () => {
+            return getHistory();
+        });
     });
     return { port, close: () => server.close() };
 }

package/dist/universal/history.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withHistory = void 0;
+//TODO Design a better history tracker
+function withHistory(socket) {
+    const history = {
+        managers: new Map(),
+        eyes: new Map(),
+        startedAt: new Date().toISOString(),
+    };
+    const originalCommand = socket.command;
+    socket.command = function command(name, fn) {
+        return originalCommand(name, async (payload) => {
+            let result, error;
+            try {
+                result = await fn(payload);
+                return result;
+            }
+            catch (err) {
+                error = err;
+                throw error;
+            }
+            finally {
+                if (name === 'Core.makeManager') {
+                    const managerRef = result;
+                    history.managers.set(extractRefId(managerRef), { ...payload, manager: result, eyes: [] });
+                }
+                else if (name.startsWith('EyesManager.')) {
+                    const managerRef = payload.manager;
+                    const managerHistory = history.managers.get(extractRefId(managerRef));
+                    if (managerHistory) {
+                        if (name === 'EyesManager.openEyes') {
+                            if (error) {
+                                managerHistory.eyes.push({ ...payload, error });
+                            }
+                            else {
+                                const eyesRef = result;
+                                managerHistory.eyes.push(eyesRef);
+                                history.eyes.set(extractRefId(eyesRef), { ...payload, eyes: eyesRef, commands: [] });
+                            }
+                        }
+                    }
+                }
+                else if (name.startsWith('Eyes.')) {
+                    const eyesRef = payload.eyes;
+                    const eyesHistory = history.eyes.get(extractRefId(eyesRef));
+                    if (eyesHistory) {
+                        if (name === 'Eyes.check') {
+                            const command = { name, ...payload };
+                            if (error)
+                                command.error = error;
+                            else
+                                command.result = result;
+                            eyesHistory.commands.push(command);
+                        }
+                        else if (name === 'Eyes.close') {
+                            eyesHistory.closed = true;
+                        }
+                        else if (name === 'Eyes.abort') {
+                            eyesHistory.aborted = true;
+                        }
+                        else if (name === 'Eyes.getResults') {
+                            eyesHistory.result = error !== null && error !== void 0 ? error : result;
+                        }
+                    }
+                }
+            }
+        });
+    };
+    return function getHistory() {
+        return {
+            managers: Array.from(history.managers.values(), managerMeta => ({
+                ...managerMeta,
+                eyes: managerMeta.eyes.map(eyesRefOrError => {
+                    return eyesRefOrError instanceof Error ? eyesRefOrError : history.eyes.get(extractRefId(eyesRefOrError));
+                }),
+            })),
+            startedAt: history.startedAt,
+            requestedAt: new Date().toISOString(),
+        };
+    };
+    function extractRefId(ref) {
+        return ref['applitools-ref-id'];
+    }
+}
+exports.withHistory = withHistory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -73,19 +73,19 @@
     ]
   },
   "dependencies": {
-    "@applitools/core-base": "1.1.37",
+    "@applitools/core-base": "1.1.38",
     "@applitools/dom-capture": "11.2.1",
     "@applitools/dom-snapshot": "4.7.3",
-    "@applitools/driver": "1.11.30",
-    "@applitools/ec-client": "1.2.8",
-    "@applitools/logger": "1.1.45",
-    "@applitools/nml-client": "1.3.34",
+    "@applitools/driver": "1.11.31",
+    "@applitools/ec-client": "1.2.9",
+    "@applitools/logger": "1.1.46",
+    "@applitools/nml-client": "1.3.35",
     "@applitools/req": "1.1.30",
-    "@applitools/screenshoter": "3.7.26",
+    "@applitools/screenshoter": "3.7.27",
     "@applitools/snippets": "2.4.15",
-    "@applitools/socket": "1.0.6",
-    "@applitools/spec-driver-webdriver": "1.0.8",
-    "@applitools/ufg-client": "1.1.25",
+    "@applitools/socket": "1.0.7",
+    "@applitools/spec-driver-webdriver": "1.0.10",
+    "@applitools/ufg-client": "1.1.26",
     "@applitools/utils": "1.3.30",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
@@ -97,10 +97,10 @@
   },
   "devDependencies": {
     "@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.25",
-    "@applitools/test-server": "^1.1.25",
+    "@applitools/spec-driver-puppeteer": "^1.1.43",
+    "@applitools/spec-driver-selenium": "^1.5.28",
+    "@applitools/spec-driver-webdriverio": "^1.4.26",
+    "@applitools/test-server": "^1.1.26",
     "@applitools/test-utils": "^1.5.12",
     "@types/mocha": "^9.1.1",
     "@types/node": "12",

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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,15 @@
+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 {};

package/types/classic/close.d.ts

@@ -0,0 +1,16 @@
+import type { CloseSettings } 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 makeClose<TSpec extends SpecType>({ eyes, target, spec, logger: defaultLogger }: Options<TSpec>): ({ settings, logger, }?: {
+    settings?: CloseSettings | undefined;
+    logger?: Logger | undefined;
+}) => Promise<void>;
+export {};

package/types/classic/core.d.ts

@@ -0,0 +1,13 @@
+import type { Core } from './types';
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+import { type Core as BaseCore } from '@applitools/core-base';
+type Options<TSpec extends SpecType> = {
+    spec?: SpecDriver<TSpec>;
+    core?: BaseCore;
+    agentId?: string;
+    cwd?: string;
+    logger?: Logger;
+};
+export declare function makeCore<TSpec extends SpecType>({ spec, core, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
+export {};

package/types/classic/get-base-eyes.d.ts

@@ -0,0 +1,17 @@
+import type { OpenSettings } from './types';
+import type { Core as BaseCore, Eyes as BaseEyes } from '@applitools/core-base';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    settings: OpenSettings;
+    core: BaseCore;
+    eyes?: BaseEyes[];
+    logger: Logger;
+};
+export declare function makeGetBaseEyes({ settings, core, eyes, logger: defaultLogger }: Options): (({ logger }?: {
+    logger?: Logger | undefined;
+}) => Promise<BaseEyes[]>) & {
+    getCachedValues(): Promise<BaseEyes<import("@applitools/core-base").ImageTarget>[]>[];
+    setCachedValue(key: any, value: Promise<BaseEyes<import("@applitools/core-base").ImageTarget>[]>): void;
+    clearCache(): void;
+};
+export {};

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

@@ -0,0 +1,16 @@
+import type { DriverTarget, Eyes, OpenSettings } from './types';
+import type { Core as BaseCore, Eyes as BaseEyes } 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 makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: defaultLogger }: Options<TSpec>): ({ target, settings, eyes, logger, }: {
+    target?: DriverTarget<TSpec> | undefined;
+    settings: OpenSettings;
+    eyes?: BaseEyes<import("@applitools/core-base").ImageTarget>[] | undefined;
+    logger?: Logger | undefined;
+}) => Promise<Eyes<TSpec>>;
+export {};

package/types/classic/types.d.ts

@@ -0,0 +1,34 @@
+import type * as BaseCore from '@applitools/core-base/types';
+import type * as AutomationCore from '../automation/types';
+import { type SpecType } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+export * from '../automation/types';
+export interface Core<TSpec extends SpecType, TTarget = AutomationCore.Target<TSpec>, TEyes extends Eyes<TSpec, TTarget> = Eyes<TSpec, TTarget>> extends AutomationCore.Core<TSpec, TTarget, TEyes> {
+    readonly type: 'classic';
+    openEyes(options: {
+        target?: AutomationCore.DriverTarget<TSpec>;
+        settings: OpenSettings;
+        eyes?: BaseCore.Eyes[];
+        logger?: Logger;
+    }): Promise<TEyes>;
+}
+export interface Eyes<TSpec extends SpecType, TTarget = AutomationCore.Target<TSpec>> extends AutomationCore.Eyes<TSpec, TTarget> {
+    readonly type: 'classic';
+    check(options?: {
+        target?: TTarget;
+        settings?: CheckSettings<TSpec>;
+        logger?: Logger;
+    }): Promise<AutomationCore.CheckResult[]>;
+    checkAndClose(options?: {
+        target?: TTarget;
+        settings?: CheckSettings<TSpec> & AutomationCore.CloseSettings;
+        logger?: Logger;
+    }): Promise<AutomationCore.TestResult[]>;
+}
+export type OpenSettings = AutomationCore.OpenSettings & {
+    keepPlatformNameAsIs?: boolean;
+    useCeilForViewportSize?: boolean;
+};
+export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
+    retryTimeout?: number;
+};

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

@@ -0,0 +1,14 @@
+import { type SpecType, type Driver } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+import { type Fetch } from '@applitools/req';
+export type DomCaptureSettings = {
+    fetch?: Fetch;
+    executionTimeout?: number;
+    pollTimeout?: number;
+    chunkByteLength?: number;
+};
+export declare function takeDomCapture<TSpec extends SpecType>({ driver, settings, logger, }: {
+    driver: Driver<TSpec>;
+    settings?: DomCaptureSettings;
+    logger: Logger;
+}): Promise<string>;

package/types/cli/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/close-batch.d.ts

@@ -0,0 +1,13 @@
+import type { MaybeArray } from '@applitools/utils';
+import type { CloseBatchSettings } from './types';
+import type { Core as BaseCore } from '@applitools/core-base';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: BaseCore;
+    logger: Logger;
+};
+export declare function makeCloseBatch({ core, logger: defaultLogger }: Options): ({ settings, logger, }: {
+    settings: MaybeArray<CloseBatchSettings>;
+    logger?: Logger | undefined;
+}) => Promise<void>;
+export {};