@applitools/core 1.4.6 → 1.4.8

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, }?: {
-    type?: TType;
+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[];
-    };
-    logger?: Logger;
-}) => Promise<TypedEyes<TDriver, TContext, TElement, TSelector, TType, import("./types").Target<TDriver, TContext, TElement, TSelector, TType>>>;
+    } | undefined;
+    logger?: Logger | undefined;
+}) => 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?: Target<TDriver, TContext, TElement, TSelector, 'classic'>;
-    settings: import("./automation/types").LocateTextSettings<TPattern, TElement, TSelector>;
-    config?: Config<TElement, TSelector, 'classic'>;
-    logger?: Logger;
+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>;
-    logger?: Logger;
+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-ec-client.d.ts

@@ -5,9 +5,9 @@ type Options = {
     core: BaseCore;
     logger: Logger;
 };
-export declare function makeMakeECClient({ core, logger: defaultLogger }: Options): (({ settings, logger, }?: {
-    settings?: ECClientSettings;
-    logger?: Logger;
+export declare function makeMakeECClient({ logger: defaultLogger }: Options): (({ settings, logger, }?: {
+    settings?: Partial<ECClientSettings> | undefined;
+    logger?: Logger | undefined;
 }) => Promise<ECClient>) & {
     getCachedValues(): Promise<ECClient>[];
     setCachedValue(key: any, value: Promise<ECClient>): void;

package/types/make-manager.d.ts

@@ -1,22 +1,22 @@
 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;
+    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, }?: {
-    type?: TType;
-    concurrency?: number;
+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 */
-    legacyConcurrency?: number;
-    batch?: Batch;
-    agentId?: string;
-    logger?: Logger;
-}) => Promise<EyesManager<TDriver, TContext, TElement, TSelector, TType>>;
+    legacyConcurrency?: number | undefined;
+    batch?: Batch | undefined;
+    agentId?: string | undefined;
+    logger?: Logger | undefined;
+}) => 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>;
-    logger?: Logger;
+    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, }: {
-    type?: TType;
-    settings?: Partial<OpenSettings<TDefaultType> & OpenSettings<TType>>;
-    config?: Config<TElement, TSelector, TDefaultType> & Config<TElement, TSelector, TType>;
-    target?: TDriver;
-    logger?: Logger;
-}) => Promise<Eyes<TDriver, TContext, TElement, TSelector, TType, import("./types").Target<TDriver, TContext, TElement, TSelector, TType>>>;
+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<TSpec, TDefaultType> & Config<TSpec, TType>) | undefined;
+    target?: DriverTarget<TSpec> | undefined;
+    logger?: Logger | undefined;
+}) => Promise<Eyes<TSpec, TType, import("./types").Target<TSpec, TType>>>;
 export {};

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /// <reference types="node" />
 export declare function checkNetwork({ stream, eyes, ufg }?: {
-    stream?: NodeJS.WriteStream;
+    stream?: NodeJS.WriteStream | undefined;
     eyes?: {
         testFetch(): Promise<void>;
         testCurl(): Promise<void>;
@@ -9,7 +9,7 @@ export declare function checkNetwork({ stream, eyes, ufg }?: {
         testHttps: () => Promise<void>;
         url: URL;
         cmd: string;
-    };
+    } | undefined;
     ufg?: {
         testFetch(): Promise<void>;
         testCurl(): Promise<void>;
@@ -17,5 +17,5 @@ export declare function checkNetwork({ stream, eyes, ufg }?: {
         testHttps(): Promise<void>;
         url: URL;
         getCmd: () => Promise<string>;
-    };
+    } | undefined;
 }): Promise<void>;

package/types/troubleshoot/utils.d.ts

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

package/types/types.d.ts

@@ -3,131 +3,111 @@ import type { ECClient } from '@applitools/ec-client';
 import type * as AutomationCore from './automation/types';
 import type * as ClassicCore from './classic/types';
 import type * as UFGCore from './ufg/types';
+import { type SpecType } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 import { type Renderer } from '@applitools/ufg-client';
-export * from '@applitools/core-base/types';
+export { ECClient };
 export * from './automation/types';
-export type TypedCore<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.Core<TDriver, TContext, TElement, TSelector> : ClassicCore.Core<TDriver, TContext, TElement, TSelector>;
-export type TypedEyes<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg', TTarget = Target<TDriver, TContext, TElement, TSelector, TType>> = TType extends 'ufg' ? UFGCore.Eyes<TDriver, TContext, TElement, TSelector, TTarget> : ClassicCore.Eyes<TDriver, TContext, TElement, TSelector, TTarget>;
-export type Target<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.UFGTarget<TDriver, TContext, TElement, TSelector> : ClassicCore.ClassicTarget<TDriver, TContext, TElement, TSelector>;
-export interface Core<TDriver, TContext, TElement, TSelector> extends AutomationCore.Core<TDriver, TContext, TElement, TSelector> {
+export type TypedCore<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.Core<TSpec> : ClassicCore.Core<TSpec>;
+export type TypedEyes<TSpec extends SpecType, TType extends 'classic' | 'ufg', TTarget = Target<TSpec, TType>> = TType extends 'ufg' ? UFGCore.Eyes<TSpec, TTarget> : ClassicCore.Eyes<TSpec, TTarget>;
+export type Target<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.Target<TSpec> : ClassicCore.Target<TSpec>;
+export interface Core<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'> extends AutomationCore.Core<TSpec> {
     makeECClient(options?: {
         settings?: any;
         logger?: Logger;
     }): Promise<ECClient>;
-    makeManager<TType extends 'classic' | 'ufg' = 'classic'>(options?: {
+    makeManager<TType extends 'classic' | 'ufg' = TDefaultType>(options?: {
         type: TType;
         concurrency?: TType extends 'ufg' ? number : never;
         agentId?: string;
         logger?: Logger;
-    }): Promise<EyesManager<TDriver, TContext, TElement, TSelector, TType>>;
-    openEyes<TType extends 'classic' | 'ufg' = 'classic'>(options: {
+    }): Promise<EyesManager<TSpec, TType>>;
+    openEyes<TType extends 'classic' | 'ufg' = TDefaultType>(options: {
         type?: TType;
-        target?: AutomationCore.DriverTarget<TDriver, TContext, TElement, TSelector>;
+        target?: AutomationCore.DriverTarget<TSpec>;
         settings?: Partial<OpenSettings<TType>>;
-        config?: Config<TElement, TSelector, TType>;
+        config?: Config<TSpec, TType>;
         logger?: Logger;
-    }): Promise<Eyes<TDriver, TContext, TElement, TSelector, TType>>;
+    }): Promise<Eyes<TSpec, TType>>;
     locate<TLocator extends string>(options: {
-        target?: AutomationCore.DriverTarget<TDriver, TContext, TElement, TSelector> | AutomationCore.ImageTarget;
-        settings?: Partial<LocateSettings<TLocator, TElement, TSelector>>;
-        config?: Config<TElement, TSelector, 'classic'>;
+        target?: AutomationCore.Target<TSpec>;
+        settings?: Partial<AutomationCore.LocateSettings<TLocator, TSpec>>;
+        config?: Config<TSpec, TDefaultType>;
         logger?: Logger;
     }): Promise<AutomationCore.LocateResult<TLocator>>;
-}
-export interface EyesManager<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> {
-    openEyes(options: {
-        target?: TDriver;
-        settings?: Partial<OpenSettings<TType>>;
-        config?: Config<TElement, TSelector, TType>;
-        logger?: Logger;
-    }): Promise<Eyes<TDriver, TContext, TElement, TSelector, TType>>;
-    closeManager: (options?: {
-        settings?: {
-            throwErr?: boolean;
-        };
-        logger?: Logger;
-    }) => Promise<TestResultSummary<TType>>;
-}
-export interface ClassicEyes<TDriver, TContext, TElement, TSelector, TTarget = Target<TDriver, TContext, TElement, TSelector, 'classic'>> extends ClassicCore.Eyes<TDriver, TContext, TElement, TSelector, TTarget> {
-    getTypedEyes<TType extends 'classic' | 'ufg' = 'classic'>(options?: {
-        type?: TType;
-        logger?: Logger;
-    }): Promise<TypedEyes<TDriver, TContext, TElement, TSelector, TType>>;
-    check<TType extends 'classic' | 'ufg' = 'classic'>(options?: {
-        type?: TType;
-        target?: TTarget;
-        settings?: Partial<CheckSettings<TElement, TSelector, 'classic'> & CheckSettings<TElement, TSelector, TType>>;
-        config?: Config<TElement, TSelector, 'classic'> & Config<TElement, TSelector, TType>;
-        logger?: Logger;
-    }): Promise<CheckResult<TType>[]>;
-    checkAndClose<TType extends 'classic' | 'ufg' = 'classic'>(options?: {
-        type?: TType;
-        target?: TTarget;
-        settings?: Partial<CheckSettings<TElement, TSelector, 'classic'> & CloseSettings<'classic'> & CheckSettings<TElement, TSelector, TType> & CloseSettings<TType>>;
-        config?: Config<TElement, TSelector, 'classic'> & Config<TElement, TSelector, TType>;
-        logger?: Logger;
-    }): Promise<TestResult<TType>[]>;
     locateText<TPattern extends string>(options: {
-        target?: TTarget;
-        settings: Partial<LocateTextSettings<TPattern, TElement, TSelector, 'classic'>>;
-        config?: Config<TElement, TSelector, 'classic'>;
+        target?: AutomationCore.Target<TSpec>;
+        settings: Partial<AutomationCore.LocateTextSettings<TPattern, TSpec>>;
+        config?: Config<TSpec, TDefaultType>;
         logger?: Logger;
     }): Promise<AutomationCore.LocateTextResult<TPattern>>;
     extractText(options: {
-        target?: TTarget;
-        settings: MaybeArray<Partial<ExtractTextSettings<TElement, TSelector, 'classic'>>>;
-        config?: Config<TElement, TSelector, 'classic'>;
+        target?: AutomationCore.Target<TSpec>;
+        settings: MaybeArray<Partial<AutomationCore.ExtractTextSettings<TSpec>>>;
+        config?: Config<TSpec, TDefaultType>;
         logger?: Logger;
     }): Promise<string[]>;
-    close(options?: {
-        settings?: Partial<CloseSettings<'classic'>>;
-        config?: Config<TElement, TSelector, 'classic'>;
+}
+export interface EyesManager<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'> {
+    openEyes<TType extends 'classic' | 'ufg' = TDefaultType>(options: {
+        type?: TType;
+        target?: AutomationCore.DriverTarget<TSpec>;
+        settings?: Partial<OpenSettings<TType>>;
+        config?: Config<TSpec, TType>;
+        logger?: Logger;
+    }): Promise<Eyes<TSpec, TType>>;
+    getResults: (options?: {
+        settings?: GetResultsSettings<TDefaultType>;
         logger?: Logger;
-    }): Promise<TestResult<'classic'>[]>;
+    }) => Promise<TestResultSummary<'classic' | 'ufg'>>;
 }
-export interface UFGEyes<TDriver, TContext, TElement, TSelector, TTarget = Target<TDriver, TContext, TElement, TSelector, 'ufg'>> extends UFGCore.Eyes<TDriver, TContext, TElement, TSelector, TTarget> {
-    getTypedEyes<TType extends 'classic' | 'ufg' = 'classic'>(options?: {
+export interface Eyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg', TTarget = Target<TSpec, TDefaultType>> extends AutomationCore.Eyes<TSpec> {
+    getTypedEyes<TType extends 'classic' | 'ufg' = TDefaultType>(options?: {
         type?: TType;
-        settings?: {
-            type: 'web' | 'native';
-            renderers: Renderer[];
-        };
+        settings?: any;
         logger?: Logger;
-    }): Promise<TypedEyes<TDriver, TContext, TElement, TSelector, TType>>;
-    check<TType extends 'classic' | 'ufg' = 'ufg'>(options?: {
+    }): Promise<TypedEyes<TSpec, TType>>;
+    check<TType extends 'classic' | 'ufg' = TDefaultType>(options?: {
         type?: TType;
         target?: TTarget;
-        settings?: Partial<CheckSettings<TElement, TSelector, 'ufg'> & CheckSettings<TElement, TSelector, TType>>;
-        config?: Config<TElement, TSelector, 'ufg'> & Config<TElement, TSelector, TType>;
+        settings?: Partial<CheckSettings<TSpec, TDefaultType> & CheckSettings<TSpec, TType>>;
+        config?: Config<TSpec, TDefaultType> & Config<TSpec, TType>;
         logger?: Logger;
     }): Promise<CheckResult<TType>[]>;
-    checkAndClose<TType extends 'classic' | 'ufg' = 'ufg'>(options?: {
+    checkAndClose<TType extends 'classic' | 'ufg' = TDefaultType>(options?: {
         type?: TType;
         target?: TTarget;
-        settings?: Partial<CheckSettings<TElement, TSelector, 'ufg'> & CloseSettings<'ufg'> & CheckSettings<TElement, TSelector, TType> & CloseSettings<TType>>;
-        config?: Config<TElement, TSelector, 'ufg'> & Config<TElement, TSelector, TType>;
+        settings?: Partial<CheckSettings<TSpec, TDefaultType> & CloseSettings<TDefaultType> & CheckSettings<TSpec, TType> & CloseSettings<TType>>;
+        config?: Config<TSpec, TDefaultType> & Config<TSpec, TType>;
         logger?: Logger;
     }): Promise<TestResult<TType>[]>;
     close(options?: {
-        settings?: Partial<CloseSettings<'ufg'>>;
-        config?: Config<TElement, TSelector, 'ufg'>;
+        settings?: Partial<CloseSettings<TDefaultType>>;
+        config?: Config<TSpec, TDefaultType>;
+        logger?: Logger;
+    }): Promise<void>;
+    abort(options?: {
+        settings?: Partial<AbortSettings<TDefaultType>>;
+        config?: Config<TSpec, TDefaultType>;
+        logger?: Logger;
+    }): Promise<void>;
+    getResults(options?: {
+        settings?: Partial<GetResultsSettings<TDefaultType>>;
+        config?: Config<TSpec, TDefaultType>;
         logger?: Logger;
-    }): Promise<TestResult<'ufg'>[]>;
+    }): Promise<TestResult<TDefaultType>[]>;
 }
-export type Eyes<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg', TTarget = Target<TDriver, TContext, TElement, TSelector, TType>> = TType extends 'ufg' ? UFGEyes<TDriver, TContext, TElement, TSelector, TTarget> : ClassicEyes<TDriver, TContext, TElement, TSelector, TTarget>;
-export type Config<TElement, TSelector, TType extends 'classic' | 'ufg'> = {
-    open: Partial<OpenSettings<TType>>;
-    screenshot: Partial<ClassicCore.ScreenshotSettings<TElement, TSelector>>;
-    check: Partial<Omit<CheckSettings<TElement, TSelector, TType>, keyof ClassicCore.ScreenshotSettings<TElement, TSelector>>>;
-    close: Partial<CloseSettings<TType>>;
+export type Config<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
+    open: Partial<Omit<OpenSettings<TType>, 'userCommandId'>>;
+    screenshot: Partial<Omit<ClassicCore.ScreenshotSettings<TSpec>, 'userCommandId'>>;
+    check: Partial<Omit<CheckSettings<TSpec, TType>, keyof ClassicCore.ScreenshotSettings<TSpec> | 'userCommandId'>>;
+    close: Partial<Omit<CloseSettings<TType>, 'userCommandId'>>;
 };
-export type LocateSettings<TLocator extends string, TElement, TSelector> = AutomationCore.LocateSettings<TLocator, TElement, TSelector>;
 export type OpenSettings<TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.OpenSettings : ClassicCore.OpenSettings;
-export type CheckSettings<TElement, TSelector, TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.CheckSettings<TElement, TSelector> : ClassicCore.CheckSettings<TElement, TSelector>;
-export type LocateTextSettings<TPattern extends string, TElement, TSelector, TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.LocateTextSettings<TPattern, TElement, TSelector> : ClassicCore.LocateTextSettings<TPattern, TElement, TSelector>;
-export type ExtractTextSettings<TElement, TSelector, TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.ExtractTextSettings<TElement, TSelector> : ClassicCore.ExtractTextSettings<TElement, TSelector>;
-export type CloseSettings<TType extends 'classic' | 'ufg'> = (TType extends 'ufg' ? UFGCore.CloseSettings : ClassicCore.CloseSettings) & {
+export type CheckSettings<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.CheckSettings<TSpec> : ClassicCore.CheckSettings<TSpec>;
+export type CloseSettings<TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.CloseSettings : ClassicCore.CloseSettings;
+export type AbortSettings<TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.AbortSettings : ClassicCore.AbortSettings;
+export type GetResultsSettings<TType extends 'classic' | 'ufg'> = (TType extends 'ufg' ? UFGCore.GetResultsSettings : ClassicCore.GetResultsSettings) & {
     throwErr?: boolean;
 };
 export type CheckResult<TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.CheckResult : ClassicCore.CheckResult;

package/types/ufg/abort.d.ts

@@ -1,25 +1,21 @@
-import type { AbortSettings, TestResult } from './types';
-import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { DriverTarget, AbortSettings } from './types';
 import { type Logger } from '@applitools/logger';
-import { type Renderer } from '@applitools/ufg-client';
 import { type AbortController } from 'abort-controller';
-import type { DriverTarget } from './types';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    storage: {
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+import { Renderer } from '@applitools/ufg-client';
+import { Eyes as baseEyes } from '@applitools/core-base';
+type Options<TSpec extends SpecType> = {
+    storage: Map<string, Promise<{
         renderer: Renderer;
-        promise: Promise<{
-            eyes: BaseEyes;
-            renderer: Renderer;
-        }>;
-    }[];
+        eyes: baseEyes;
+    }>[]>;
     controller: AbortController;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    target?: DriverTarget<TSpec>;
+    spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeAbort<TDriver, TContext, TElement, TSelector>({ storage, target, spec, controller, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ settings, logger, }?: {
-    settings?: AbortSettings;
-    logger?: Logger;
-}) => Promise<TestResult[]>;
+export declare function makeAbort<TSpec extends SpecType>({ storage, target, spec, controller, logger: defaultLogger, }: Options<TSpec>): ({ settings, logger, }?: {
+    settings?: AbortSettings | undefined;
+    logger?: Logger | undefined;
+}) => Promise<void>;
 export {};

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

@@ -1,21 +1,33 @@
-import type { DriverTarget, UFGTarget, Eyes, CheckSettings, TestResult, CloseSettings } from './types';
-import { type DomSnapshot, type AndroidSnapshot, type IOSSnapshot } from '@applitools/ufg-client';
+import type { Region } from '@applitools/utils';
+import type { DriverTarget, Target, Eyes, CheckSettings, TestResult, CloseSettings } from './types';
 import { type AbortSignal } from 'abort-controller';
 import { type Logger } from '@applitools/logger';
 import { type UFGClient } from '@applitools/ufg-client';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    eyes: Eyes<TSpec>;
     client: UFGClient;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    target?: DriverTarget<TSpec>;
+    spec?: SpecDriver<TSpec>;
     signal?: AbortSignal;
-    logger?: Logger;
+    logger: Logger;
 };
-export declare function makeCheckAndClose<TDriver, TContext, TElement, TSelector>({ spec, eyes, client, signal, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, snapshots, }: {
-    target?: UFGTarget<TDriver, TContext, TElement, TSelector>;
-    settings?: CheckSettings<TElement, TSelector> & CloseSettings;
-    logger?: Logger;
-    snapshots?: DomSnapshot[] | AndroidSnapshot[] | IOSSnapshot[];
+export declare function makeCheckAndClose<TSpec extends SpecType>({ spec, eyes, client, signal, target: defaultTarget, logger: defaultLogger, }: Options<TSpec>): ({ target, settings, logger, }: {
+    target?: Target<TSpec> | undefined;
+    settings?: (import("@applitools/core-base").CheckSettings<Region | import("@applitools/driver").ElementReference<TSpec>> & import("./types").ScreenshotSettings<TSpec> & {
+        renderers?: import("@applitools/ufg-client").Renderer[] | undefined;
+        hooks?: {
+            beforeCaptureScreenshot: string;
+        } | undefined;
+        disableBrowserFetching?: boolean | undefined;
+        layoutBreakpoints?: boolean | number[] | undefined;
+        ufgOptions?: Record<string, any> | undefined;
+        nmgOptions?: Record<string, any> | undefined;
+        autProxy?: (import("@applitools/req").Proxy & {
+            mode?: "Allow" | "Block" | undefined;
+            domains?: string[] | undefined;
+        }) | undefined;
+    } & CloseSettings) | undefined;
+    logger?: Logger | undefined;
 }) => Promise<TestResult[]>;
 export {};

package/types/ufg/check.d.ts

@@ -1,19 +1,19 @@
-import type { DriverTarget, UFGTarget, Eyes, CheckSettings, CheckResult } from './types';
+import type { DriverTarget, Target, Eyes, CheckSettings, CheckResult } from './types';
 import { type AbortSignal } from 'abort-controller';
 import { type Logger } from '@applitools/logger';
 import { type UFGClient } from '@applitools/ufg-client';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    eyes: Eyes<TSpec>;
     client: UFGClient;
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    target?: DriverTarget<TSpec>;
+    spec?: SpecDriver<TSpec>;
     signal?: AbortSignal;
-    logger?: Logger;
+    logger: Logger;
 };
-export declare function makeCheck<TDriver, TContext, TElement, TSelector>({ eyes, client, target: defaultTarget, spec, signal, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }: {
-    settings?: CheckSettings<TElement, TSelector>;
-    target?: UFGTarget<TDriver, TContext, TElement, TSelector>;
-    logger?: Logger;
+export declare function makeCheck<TSpec extends SpecType>({ eyes, client, target: defaultTarget, spec, signal, logger: defaultLogger, }: Options<TSpec>): ({ target, settings, logger, }: {
+    settings?: CheckSettings<TSpec> | undefined;
+    target?: Target<TSpec> | undefined;
+    logger?: Logger | undefined;
 }) => Promise<CheckResult[]>;
 export {};

package/types/ufg/close.d.ts

@@ -1,23 +1,19 @@
-import type { CloseSettings, TestResult } from './types';
-import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { DriverTarget, CloseSettings } from './types';
 import { type Logger } from '@applitools/logger';
-import { type Renderer } from '@applitools/ufg-client';
-import type { DriverTarget } from './types';
-import { type SpecDriver } from '@applitools/driver';
-type Options<TDriver, TContext, TElement, TSelector> = {
-    storage: {
+import { type SpecType, type SpecDriver } from '@applitools/driver';
+import { Renderer } from '@applitools/ufg-client';
+import { Eyes as baseEyes } from '@applitools/core-base';
+type Options<TSpec extends SpecType> = {
+    storage: Map<string, Promise<{
         renderer: Renderer;
-        promise: Promise<{
-            eyes: BaseEyes;
-            renderer: Renderer;
-        }>;
-    }[];
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
-    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
+        eyes: baseEyes;
+    }>[]>;
+    target?: DriverTarget<TSpec>;
+    spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeClose<TDriver, TContext, TElement, TSelector>({ storage, target, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ settings, logger, }?: {
-    settings?: CloseSettings;
-    logger?: Logger;
-}) => Promise<TestResult[]>;
+export declare function makeClose<TSpec extends SpecType>({ storage, target, spec, logger: defaultLogger }: Options<TSpec>): ({ settings, logger, }?: {
+    settings?: CloseSettings | undefined;
+    logger?: Logger | undefined;
+}) => Promise<void>;
 export {};