@applitools/core 1.4.7 → 1.4.8

package/types/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, }?: {
+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<TDriver, TContext, TElement, TSelector, TType> | undefined;
-    settings?: (CheckSettings<TElement, TSelector, TDefaultType> & (TDefaultType extends "ufg" ? import("@applitools/core-base").CloseSettings : import("@applitools/core-base").CloseSettings) & {
-        throwErr?: boolean | undefined;
-    } & CheckSettings<TElement, TSelector, TType> & (TType extends "ufg" ? import("@applitools/core-base").CloseSettings : import("@applitools/core-base").CloseSettings)) | undefined;
-    config?: (Config<TElement, TSelector, TDefaultType> & Config<TElement, TSelector, 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>;
+    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, }?: {
+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<TDriver, TContext, TElement, TSelector, TType> | undefined;
-    settings?: CheckSettings<TElement, TSelector, TType> | undefined;
-    config?: Config<TElement, TSelector, 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, }?: {
+export declare function makeAbort<TSpec extends SpecType>({ eyes, target, spec, logger: defaultLogger }: Options<TSpec>): ({ settings, logger, }?: {
     settings?: AbortSettings | undefined;
     logger?: Logger | undefined;
-}) => Promise<TestResult[]>;
+}) => Promise<void>;
 export {};

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

@@ -1,17 +1,17 @@
-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';
+import { type SpecType, type SpecDriver } from '@applitools/driver';
 import * as utils from '@applitools/utils';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+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> | undefined;
-    settings?: (BaseCheckSettings<utils.Region | (TElement | import("@applitools/driver").Selector<TSelector>)> & import("./types").ScreenshotSettings<TElement, TSelector> & {
+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;

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>;
+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> | undefined;
-    settings?: CheckSettings<TElement, TSelector> | undefined;
+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, }?: {
+export declare function makeClose<TSpec extends SpecType>({ eyes, target, spec, logger: defaultLogger }: Options<TSpec>): ({ settings, logger, }?: {
     settings?: CloseSettings | undefined;
     logger?: Logger | undefined;
-}) => Promise<TestResult[]>;
+}) => 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: defaultLogger, }: 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/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>;
+    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> | undefined;
+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<TDriver, TContext, TElement, TSelector>>;
+}) => 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({ driver, settings, logger, }: {
-    driver: Driver<unknown, unknown, unknown, unknown>;
+export declare function takeDomCapture<TSpec extends SpecType>({ driver, settings, logger, }: {
+    driver: Driver<TSpec>;
     settings?: DomCaptureSettings;
     logger: Logger;
 }): Promise<string>;

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, }?: {
+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<TElement, TSelector, TType> | undefined;
+    config?: Config<TSpec, TType> | undefined;
     logger?: Logger | undefined;
-}) => Promise<TestResult<TType>[]>;
+}) => 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/errors/abort-error.d.ts

@@ -1,2 +1,4 @@
-export declare class AbortError extends Error {
+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?: import("./classic/types").ClassicTarget<TDriver, TContext, TElement, TSelector> | undefined;
-    settings: MaybeArray<ExtractTextSettings<TElement, TSelector, 'classic'>>;
-    config?: Config<TElement, TSelector, "classic"> | undefined;
+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 {};

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

@@ -0,0 +1,14 @@
+import type { Eyes, GetResultsSettings, TestResultSummary } from './types';
+import type { Core as BaseCore } from '@applitools/core-base';
+import { type SpecType } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
+    core: BaseCore<unknown>;
+    storage: Eyes<TSpec, TType>[];
+    logger: Logger;
+};
+export declare function makeGetManagerResults<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ core, storage, logger: defaultLogger, }: Options<TSpec, TType>): ({ settings, logger, }?: {
+    settings?: GetResultsSettings<TType> | undefined;
+    logger?: Logger | undefined;
+}) => Promise<TestResultSummary<TType>>;
+export {};

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

@@ -1,21 +1,22 @@
 import type { DriverTarget, TypedCore, TypedEyes, OpenSettings } from './types';
+import { type SpecType } from '@applitools/driver';
 import { type Renderer } from '@applitools/ufg-client';
 import { type Logger } from '@applitools/logger';
-type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> = {
+type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     type: TType;
     settings: OpenSettings<TType>;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
+    target?: DriverTarget<TSpec>;
     cores: {
-        [TKey in 'classic' | 'ufg']: TypedCore<TDriver, TContext, TElement, TSelector, TKey>;
+        [TKey in 'classic' | 'ufg']: TypedCore<TSpec, TKey>;
     };
     logger?: Logger;
 };
-export declare function makeGetTypedEyes<TDriver, TContext, TElement, TSelector, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, settings: defaultSettings, target, cores, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, settings, logger, }?: {
+export declare function makeGetTypedEyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, settings: defaultSettings, target, cores, logger: defaultLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, settings, logger, }?: {
     type?: TType | undefined;
     settings?: {
         type: 'web' | 'native';
         renderers: Renderer[];
     } | undefined;
     logger?: Logger | undefined;
-}) => Promise<TypedEyes<TDriver, TContext, TElement, TSelector, TType, import("./types").Target<TDriver, TContext, TElement, TSelector, TType>>>;
+}) => Promise<TypedEyes<TSpec, TType, import("./types").Target<TSpec, TType>>>;
 export {};

package/types/index.d.ts

@@ -1,6 +1,6 @@
 export * from './types';
-export { type Selector } from '@applitools/driver';
 export * from './core';
-export { takeDomSnapshots } from './ufg/utils/take-dom-snapshots';
-export * as formatters from './utils/format-results';
+export { type Selector } from '@applitools/driver';
 export * from '@applitools/driver/dist/debug';
+export * as formatters from './utils/format-results';
+export { takeDomSnapshots } from './ufg/utils/take-dom-snapshots';

package/types/locate-text.d.ts

@@ -1,14 +1,16 @@
-import type { DriverTarget, Target, Eyes, Config, LocateTextSettings, LocateTextResult } from './types';
+import type { Target, Config, LocateTextSettings, LocateTextResult } 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 makeLocateText<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg' = 'classic'>({ eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TType>): <TPattern extends string>({ target, settings, config, logger, }: {
-    target?: import("./classic/types").ClassicTarget<TDriver, TContext, TElement, TSelector> | undefined;
-    settings: import("./automation/types").LocateTextSettings<TPattern, TElement, TSelector>;
-    config?: Config<TElement, TSelector, "classic"> | undefined;
+export declare function makeLocateText<TSpec extends SpecType>({ spec, core, logger: defaultLogger }: Options<TSpec>): <TPattern extends string>({ target, settings, config, logger, }: {
+    target: Target<TSpec, 'classic'>;
+    settings: LocateTextSettings<TPattern, TSpec>;
+    config?: Config<TSpec, "classic"> | undefined;
     logger?: Logger | undefined;
 }) => Promise<LocateTextResult<TPattern>>;
 export {};

package/types/locate.d.ts

@@ -1,17 +1,17 @@
 import type { Region } from '@applitools/utils';
-import type { DriverTarget, ImageTarget, Config, LocateSettings } from './types';
+import type { Target, Config, LocateSettings } from './types';
 import type { Core as BaseCore } from '@applitools/core-base';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    spec?: SpecDriver<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 makeLocate<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'>({ spec, core, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TLocator extends string>({ target, settings, config, logger, }: {
-    target: DriverTarget<TDriver, TContext, TElement, TSelector> | ImageTarget;
-    settings: LocateSettings<TLocator, TElement, TSelector>;
-    config?: Config<TElement, TSelector, TType> | undefined;
+export declare function makeLocate<TSpec extends SpecType>({ spec, core, logger: defaultLogger }: Options<TSpec>): <TLocator extends string>({ target, settings, config, logger, }: {
+    target: Target<TSpec, 'classic'>;
+    settings: LocateSettings<TLocator, TSpec>;
+    config?: Config<TSpec, "classic"> | undefined;
     logger?: Logger | undefined;
 }) => Promise<Record<TLocator, Region[]>>;
 export {};

package/types/make-manager.d.ts

@@ -1,16 +1,16 @@
 import type { Batch, EyesManager } from './types';
 import type { Core as BaseCore } from '@applitools/core-base';
 import { type Logger } from '@applitools/logger';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    spec?: SpecDriver<TSpec>;
     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, batch, agentId, logger, }?: {
+export declare function makeMakeManager<TSpec extends SpecType>({ spec, core, concurrency: defaultConcurrency, agentId: defaultAgentId, cwd, logger: defaultLogger, }: Options<TSpec>): <TType extends "classic" | "ufg" = "classic">({ type, concurrency, legacyConcurrency, batch, agentId, logger, }?: {
     type?: TType | undefined;
     concurrency?: number | undefined;
     /** @deprecated */
@@ -18,5 +18,5 @@ export declare function makeMakeManager<TDriver, TContext, TElement, TSelector>(
     batch?: Batch | undefined;
     agentId?: string | undefined;
     logger?: Logger | undefined;
-}) => Promise<EyesManager<TDriver, TContext, TElement, TSelector, TType>>;
+}) => Promise<EyesManager<TSpec, TType>>;
 export {};

package/types/open-eyes.d.ts

@@ -1,23 +1,23 @@
-import type { TypedCore, Batch, Eyes, Config, OpenSettings } from './types';
+import type { TypedCore, Batch, Eyes, Config, OpenSettings, DriverTarget } from './types';
 import type { Core as BaseCore } from '@applitools/core-base';
 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;
     concurrency?: number;
     batch?: Batch;
     core: BaseCore;
     cores?: {
-        [TKey in 'classic' | 'ufg']: TypedCore<TDriver, TContext, TElement, TSelector, TKey>;
+        [TKey in 'classic' | 'ufg']: TypedCore<TSpec, TKey>;
     };
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeOpenEyes<TDriver, TContext, TElement, TSelector, TDefaultType extends 'classic' | 'ufg' = 'classic'>({ type: defaultType, concurrency, batch, core, cores, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, settings, config, target, logger, }: {
+export declare function makeOpenEyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg' = 'classic'>({ type: defaultType, concurrency, batch, core, cores, spec, logger: defaultLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, settings, config, target, logger, }: {
     type?: TType | undefined;
     settings?: Partial<OpenSettings<TDefaultType> & OpenSettings<TType>> | undefined;
-    config?: (Config<TElement, TSelector, TDefaultType> & Config<TElement, TSelector, TType>) | undefined;
-    target?: TDriver | undefined;
+    config?: (Config<TSpec, TDefaultType> & Config<TSpec, TType>) | undefined;
+    target?: DriverTarget<TSpec> | undefined;
     logger?: Logger | undefined;
-}) => Promise<Eyes<TDriver, TContext, TElement, TSelector, TType, import("./types").Target<TDriver, TContext, TElement, TSelector, TType>>>;
+}) => Promise<Eyes<TSpec, TType, import("./types").Target<TSpec, TType>>>;
 export {};