@applitools/core 1.4.6 → 1.4.8

package/types/automation/types.d.ts

@@ -1,72 +1,68 @@
 import type { MaybeArray, Size, Region } from '@applitools/utils';
 import type * as BaseCore from '@applitools/core-base/types';
-import { type Driver, type Selector } from '@applitools/driver';
+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<TDriver, TContext, TElement, TSelector> = TDriver | Driver<TDriver, TContext, TElement, TSelector>;
-export interface Core<TDriver, TContext, TElement, TSelector, TEyes = Eyes<TDriver, TContext, TElement, TSelector>> extends BaseCore.Core<TEyes> {
-    isDriver(driver: any): driver is TDriver;
-    isElement(element: any): element is TElement;
-    isSelector(selector: any): selector is TSelector;
-    getViewportSize(options: {
-        target: DriverTarget<TDriver, TContext, TElement, TSelector>;
+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<TDriver, TContext, TElement, TSelector>;
+    setViewportSize?(options: {
+        target: DriverTarget<TSpec>;
         size: Size;
         logger?: Logger;
     }): Promise<void>;
     openEyes(options: {
-        target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
+        target?: DriverTarget<TSpec>;
         settings: BaseCore.OpenSettings;
         eyes?: BaseCore.Eyes[];
         logger?: Logger;
     }): Promise<TEyes>;
     locate<TLocator extends string>(options: {
-        target: DriverTarget<TDriver, TContext, TElement, TSelector> | BaseCore.ImageTarget;
-        settings: LocateSettings<TLocator, TElement, TSelector>;
+        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<TDriver, TContext, TElement, TSelector, TTarget = DriverTarget<TDriver, TContext, TElement, TSelector>> extends BaseCore.Eyes<TTarget> {
+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<TElement, TSelector>;
+        settings?: CheckSettings<TSpec>;
         logger?: Logger;
     }): Promise<BaseCore.CheckResult[]>;
     checkAndClose(options?: {
         target?: TTarget;
-        settings?: CheckSettings<TElement, TSelector> & BaseCore.CloseSettings;
+        settings?: CheckSettings<TSpec> & BaseCore.CloseSettings;
         logger?: Logger;
     }): Promise<BaseCore.TestResult[]>;
-    locateText?<TPattern extends string>(options: {
-        target?: TTarget;
-        settings: LocateTextSettings<TPattern, TElement, TSelector>;
-        logger?: Logger;
-    }): Promise<BaseCore.LocateTextResult<TPattern>>;
-    extractText?(options: {
-        target?: TTarget;
-        settings: MaybeArray<ExtractTextSettings<TElement, TSelector>>;
-        logger?: Logger;
-    }): Promise<string[]>;
 }
-type RegionReference<TElement, TSelector> = Region | ElementReference<TElement, TSelector>;
-type ElementReference<TElement, TSelector> = TElement | Selector<TSelector>;
-type FrameReference<TElement, TSelector> = ElementReference<TElement, TSelector> | string | number;
-type ContextReference<TElement, TSelector> = {
-    frame: FrameReference<TElement, TSelector>;
-    scrollRootElement?: ElementReference<TElement, TSelector>;
-};
-type StitchMode = 'Scroll' | 'CSS';
-export interface ScreenshotSettings<TElement, TSelector> extends BaseCore.ImageSettings<RegionReference<TElement, TSelector>> {
-    frames?: (ContextReference<TElement, TSelector> | FrameReference<TElement, TSelector>)[];
+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<TElement, TSelector>;
-    stitchMode?: StitchMode;
+    scrollRootElement?: ElementReference<TSpec>;
+    stitchMode?: 'Scroll' | 'CSS';
     hideScrollbars?: boolean;
     hideCaret?: boolean;
     overlap?: {
@@ -82,7 +78,7 @@ export interface ScreenshotSettings<TElement, TSelector> extends BaseCore.ImageS
     };
     webview?: boolean | string;
 }
-export type LocateSettings<TLocator extends string, TElement, TSelector> = BaseCore.LocateSettings<TLocator, RegionReference<TElement, TSelector>> & ScreenshotSettings<TElement, TSelector>;
-export type CheckSettings<TElement, TSelector> = BaseCore.CheckSettings<RegionReference<TElement, TSelector>> & ScreenshotSettings<TElement, TSelector>;
-export type LocateTextSettings<TPattern extends string, TElement, TSelector> = BaseCore.LocateTextSettings<TPattern, RegionReference<TElement, TSelector>> & ScreenshotSettings<TElement, TSelector>;
-export type ExtractTextSettings<TElement, TSelector> = BaseCore.ExtractTextSettings<RegionReference<TElement, TSelector>> & ScreenshotSettings<TElement, TSelector>;
+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 +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 } from '@applitools/driver';
-export type Screenshot = {
+import { type Driver, type Element, type ElementReference, type SpecType } from '@applitools/driver';
+export type Screenshot<TSpec extends SpecType> = {
     image: any;
     region: Region;
-    element: Element<unknown, unknown, unknown, unknown>;
-    scrollingElement: Element<unknown, unknown, unknown, unknown>;
+    element: Element<TSpec>;
+    scrollingElement: Element<TSpec>;
     restoreState(): Promise<void>;
     calculatedRegions: [];
 };
-export declare function takeScreenshot<TDriver, TContext, TElement, TSelector>({ driver, settings, logger, }: {
-    driver: Driver<TDriver, TContext, TElement, TSelector>;
-    settings: ScreenshotSettings<TElement, TSelector> & {
-        regionsToCalculate?: any[];
+export declare function takeScreenshot<TSpec extends SpecType>({ driver, settings, logger, }: {
+    driver: Driver<TSpec>;
+    settings: ScreenshotSettings<TSpec> & {
+        regionsToCalculate?: ElementReference<TSpec>[];
     };
     logger: Logger;
-}): Promise<Screenshot>;
+}): 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/{utils → automation/utils}/wait-for-lazy-load.d.ts

@@ -1,5 +1,5 @@
 import { type Logger } from '@applitools/logger';
-import { type Context } from '@applitools/driver';
+import { type SpecType, type Context } from '@applitools/driver';
 export type LazyLoadSettings = {
     scrollLength?: number;
     waitingTime?: number;
@@ -7,8 +7,8 @@ export type LazyLoadSettings = {
     executionTimeout?: number;
     pollTimeout?: number;
 };
-export declare function waitForLazyLoad<TContext extends Context<unknown, unknown, unknown, unknown>>({ context, settings, logger, }: {
-    context: TContext;
+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,20 +1,18 @@
 import type { Target, DriverTarget, Eyes, Config, CheckSettings, CloseSettings, TestResult } from './types';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> = {
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     type?: TType;
-    eyes: Eyes<TDriver, TContext, TElement, TSelector, TType>;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    eyes: Eyes<TSpec, TType>;
+    target?: DriverTarget<TSpec>;
+    spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeCheckAndClose<TDriver, TContext, TElement, TSelector, TDefaultType extends 'classic' | 'ufg' = 'classic'>({ type: defaultType, eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, target, settings, config, logger, }?: {
-    type?: TType;
-    target?: Target<TDriver, TContext, TElement, TSelector, TType>;
-    settings?: CheckSettings<TElement, TSelector, TDefaultType> & (TDefaultType extends "ufg" ? import("@applitools/core-base").CloseSettings : import("@applitools/core-base").CloseSettings) & {
-        throwErr?: boolean;
-    } & CheckSettings<TElement, TSelector, TType> & (TType extends "ufg" ? import("@applitools/core-base").CloseSettings : import("@applitools/core-base").CloseSettings);
-    config?: Config<TElement, TSelector, TDefaultType> & Config<TElement, TSelector, TType>;
-    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 +1,18 @@
 import type { Target, DriverTarget, Eyes, Config, CheckSettings, CheckResult } from './types';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> = {
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     type?: TType;
-    eyes: Eyes<TDriver, TContext, TElement, TSelector, TType>;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    logger?: Logger;
+    eyes: Eyes<TSpec, TType>;
+    target?: DriverTarget<TSpec>;
+    spec?: SpecDriver<TSpec>;
+    logger: Logger;
 };
-export declare function makeCheck<TDriver, TContext, TElement, TSelector, TDefaultType extends 'classic' | 'ufg' = 'classic'>({ type: defaultType, eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, target, settings, config, logger, }?: {
-    type?: TType;
-    target?: Target<TDriver, TContext, TElement, TSelector, TType>;
-    settings?: CheckSettings<TElement, TSelector, TType>;
-    config?: Config<TElement, TSelector, TType>;
-    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 +1,16 @@
-import type { AbortSettings, TestResult } from './types';
+import type { AbortSettings } from './types';
 import type { Eyes } from './types';
 import { type Logger } from '@applitools/logger';
 import type { DriverTarget } from './types';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+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<TDriver, TContext, TElement, TSelector>({ eyes, target, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ settings, logger, }?: {
-    settings?: AbortSettings;
-    logger?: Logger;
-}) => Promise<TestResult[]>;
+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,15 +1,19 @@
-import type { ClassicTarget, DriverTarget, Eyes, CheckSettings, CloseSettings, TestResult } from './types';
+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 SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    logger?: 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<TDriver, TContext, TElement, TSelector>({ eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }?: {
-    target?: ClassicTarget<TDriver, TContext, TElement, TSelector>;
-    settings?: CheckSettings<TElement, TSelector> & CloseSettings;
-    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 +1,15 @@
-import type { ClassicTarget, DriverTarget, Eyes, CheckSettings, CheckResult } from './types';
+import type { Target, DriverTarget, Eyes, CheckSettings, CheckResult } from './types';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    logger?: 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<TDriver, TContext, TElement, TSelector>({ eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }?: {
-    target?: ClassicTarget<TDriver, TContext, TElement, TSelector>;
-    settings?: CheckSettings<TElement, TSelector>;
-    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

@@ -1,16 +1,16 @@
-import type { CloseSettings, TestResult } from './types';
+import type { CloseSettings } from './types';
 import type { Eyes } from './types';
 import { type Logger } from '@applitools/logger';
 import type { DriverTarget } from './types';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+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<TDriver, TContext, TElement, TSelector>({ eyes, target, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ settings, logger, }?: {
-    settings?: CloseSettings;
-    logger?: Logger;
-}) => Promise<TestResult[]>;
+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

@@ -1,13 +1,13 @@
 import type { Core } from './types';
-import { type SpecDriver } from '@applitools/driver';
+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<TDriver, TContext, TElement, TSelector> = {
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+type Options<TSpec extends SpecType> = {
+    spec?: SpecDriver<TSpec>;
     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, TContext, TElement, TSelector>;
+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

@@ -2,13 +2,13 @@ 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;
+    settings: OpenSettings;
+    core: BaseCore;
     eyes?: BaseEyes[];
-    core?: BaseCore;
-    logger?: Logger;
+    logger: Logger;
 };
 export declare function makeGetBaseEyes({ settings, core, eyes, logger: defaultLogger }: Options): (({ logger }?: {
-    logger?: 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;

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

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

package/types/classic/types.d.ts

@@ -1,27 +1,27 @@
 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 type ClassicTarget<TDriver, TContext, TElement, TSelector> = AutomationCore.DriverTarget<TDriver, TContext, TElement, TSelector> | AutomationCore.ImageTarget;
-export interface Core<TDriver, TContext, TElement, TSelector, TEyes = Eyes<TDriver, TContext, TElement, TSelector>> extends AutomationCore.Core<TDriver, TContext, TElement, TSelector, TEyes> {
+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<TDriver, TContext, TElement, TSelector>;
+        target?: AutomationCore.DriverTarget<TSpec>;
         settings: OpenSettings;
         eyes?: BaseCore.Eyes[];
         logger?: Logger;
     }): Promise<TEyes>;
 }
-export interface Eyes<TDriver, TContext, TElement, TSelector, TTarget = ClassicTarget<TDriver, TContext, TElement, TSelector>> extends AutomationCore.Eyes<TDriver, TContext, TElement, TSelector, TTarget> {
+export interface Eyes<TSpec extends SpecType, TTarget = AutomationCore.Target<TSpec>> extends AutomationCore.Eyes<TSpec, TTarget> {
     readonly type: 'classic';
     check(options?: {
         target?: TTarget;
-        settings?: CheckSettings<TElement, TSelector>;
+        settings?: CheckSettings<TSpec>;
         logger?: Logger;
     }): Promise<AutomationCore.CheckResult[]>;
     checkAndClose(options?: {
         target?: TTarget;
-        settings?: CheckSettings<TElement, TSelector> & AutomationCore.CloseSettings;
+        settings?: CheckSettings<TSpec> & AutomationCore.CloseSettings;
         logger?: Logger;
     }): Promise<AutomationCore.TestResult[]>;
 }
@@ -29,6 +29,6 @@ export type OpenSettings = AutomationCore.OpenSettings & {
     keepPlatformNameAsIs?: boolean;
     useCeilForViewportSize?: boolean;
 };
-export type CheckSettings<TElement, TSelector> = AutomationCore.CheckSettings<TElement, TSelector> & {
+export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
     retryTimeout?: number;
 };

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

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

package/types/close-batch.d.ts

@@ -8,6 +8,6 @@ type Options = {
 };
 export declare function makeCloseBatch({ core, logger: defaultLogger }: Options): ({ settings, logger, }: {
     settings: MaybeArray<CloseBatchSettings>;
-    logger?: Logger;
+    logger?: Logger | undefined;
 }) => Promise<void>;
 export {};

package/types/close.d.ts

@@ -1,12 +1,13 @@
-import type { Eyes, Config, CloseSettings, TestResult } from './types';
+import type { Eyes, Config, CloseSettings } from './types';
+import { type SpecType } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
-type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> = {
-    eyes: Eyes<TDriver, TContext, TElement, TSelector, TType>;
+type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
+    eyes: Eyes<TSpec, TType>;
     logger: Logger;
 };
-export declare function makeClose<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TType>): ({ settings, config, logger, }?: {
-    settings?: CloseSettings<TType>;
-    config?: Config<TElement, TSelector, TType>;
-    logger?: Logger;
-}) => Promise<TestResult<TType>[]>;
+export declare function makeClose<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TSpec, TType>): ({ settings, config, logger, }?: {
+    settings?: CloseSettings<TType> | undefined;
+    config?: Config<TSpec, TType> | undefined;
+    logger?: Logger | undefined;
+}) => Promise<void>;
 export {};

package/types/core.d.ts

@@ -1,14 +1,14 @@
 import type { Core } from './types';
 import type { Core as BaseCore } from '@applitools/core-base';
-import { type SpecDriver } from '@applitools/driver';
+import { type SpecType, type SpecDriver } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+type Options<TSpec extends SpecType> = {
+    spec?: SpecDriver<TSpec>;
     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, TContext, TElement, TSelector>;
+export declare function makeCore<TSpec extends SpecType>({ spec, concurrency, core, agentId, cwd, logger, }?: Options<TSpec>): Core<TSpec, 'classic' | 'ufg'>;
 export {};

package/types/delete-test.d.ts

@@ -8,6 +8,6 @@ type Options = {
 };
 export declare function makeDeleteTest({ core, logger: defaultLogger }: Options): ({ settings, logger, }: {
     settings: MaybeArray<DeleteTestSettings>;
-    logger?: Logger;
+    logger?: Logger | undefined;
 }) => Promise<void>;
 export {};

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

@@ -1,3 +1,4 @@
-export declare class AbortError extends Error {
-    info: Record<string, any>;
+import { CoreError } from '@applitools/core-base';
+export declare class AbortError extends CoreError {
+    constructor(message: string, info?: Record<string, any>);
 }

package/types/extract-text.d.ts

@@ -1,15 +1,17 @@
 import type { MaybeArray } from '@applitools/utils';
-import type { Target, DriverTarget, Eyes, Config, ExtractTextSettings } from './types';
+import type { Target, Config, ExtractTextSettings } from './types';
+import type { Core as BaseCore } from '@applitools/core-base';
 import { type Logger } from '@applitools/logger';
-type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> = {
-    eyes: Eyes<TDriver, TContext, TElement, TSelector, TType>;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    spec?: SpecDriver<TSpec>;
+    core: BaseCore;
     logger: Logger;
 };
-export declare function makeExtractText<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg' = 'classic'>({ eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TType>): ({ target, settings, config, logger, }: {
-    target?: Target<TDriver, TContext, TElement, TSelector, 'classic'>;
-    settings: MaybeArray<ExtractTextSettings<TElement, TSelector, 'classic'>>;
-    config?: Config<TElement, TSelector, 'classic'>;
-    logger?: Logger;
+export declare function makeExtractText<TSpec extends SpecType>({ spec, core, logger: defaultLogger }: Options<TSpec>): ({ target, settings, config, logger, }: {
+    target: Target<TSpec, 'classic'>;
+    settings: MaybeArray<ExtractTextSettings<TSpec>>;
+    config?: Config<TSpec, "classic"> | undefined;
+    logger?: Logger | undefined;
 }) => Promise<string[]>;
 export {};

package/types/get-eyes-results.d.ts

@@ -0,0 +1,12 @@
+import type { Eyes, GetResultsSettings, TestResult } from './types';
+import { type SpecType } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
+    eyes: Eyes<TSpec, TType>;
+    logger: Logger;
+};
+export declare function makeGetEyesResults<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TSpec, TType>): ({ settings, logger, }?: {
+    settings?: GetResultsSettings<TType> | undefined;
+    logger?: Logger | undefined;
+}) => Promise<TestResult<TType>[]>;
+export {};