@applitools/core 1.4.9 → 1.4.10

package/types/types.d.ts

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

package/types/ufg/abort.d.ts

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

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

@@ -1,20 +1,20 @@
 import type { Region } from '@applitools/utils';
-import type { DriverTarget, Target, Eyes, CheckSettings, TestResult, CloseSettings } from './types';
+import type { DriverTarget, UFGTarget, 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 SpecType, type SpecDriver } from '@applitools/driver';
-type Options<TSpec extends SpecType> = {
-    eyes: Eyes<TSpec>;
+import { type SpecDriver, type Selector } from '@applitools/driver';
+type Options<TDriver, TContext, TElement, TSelector> = {
+    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
     client: UFGClient;
-    target?: DriverTarget<TSpec>;
-    spec?: SpecDriver<TSpec>;
+    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     signal?: AbortSignal;
     logger: Logger;
 };
-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> & {
+export declare function makeCheckAndClose<TDriver, TContext, TElement, TSelector>({ spec, eyes, client, signal, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }: {
+    target?: UFGTarget<TDriver, TContext, TElement, TSelector> | undefined;
+    settings?: (import("@applitools/core-base").CheckSettings<Region | (TElement | Selector<TSelector>)> & import("./types").ScreenshotSettings<TElement, TSelector> & {
         renderers?: import("@applitools/ufg-client").Renderer[] | undefined;
         hooks?: {
             beforeCaptureScreenshot: string;

package/types/ufg/check.d.ts

@@ -1,19 +1,19 @@
-import type { DriverTarget, Target, Eyes, CheckSettings, CheckResult } from './types';
+import type { DriverTarget, UFGTarget, 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 SpecType, type SpecDriver } from '@applitools/driver';
-type Options<TSpec extends SpecType> = {
-    eyes: Eyes<TSpec>;
+import { type SpecDriver } from '@applitools/driver';
+type Options<TDriver, TContext, TElement, TSelector> = {
+    eyes: Eyes<TDriver, TContext, TElement, TSelector>;
     client: UFGClient;
-    target?: DriverTarget<TSpec>;
-    spec?: SpecDriver<TSpec>;
+    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     signal?: AbortSignal;
     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;
+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> | undefined;
+    target?: UFGTarget<TDriver, TContext, TElement, TSelector> | undefined;
     logger?: Logger | undefined;
 }) => Promise<CheckResult[]>;
 export {};

package/types/ufg/close.d.ts

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

package/types/ufg/core.d.ts

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

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

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

package/types/ufg/types.d.ts

@@ -1,23 +1,22 @@
 import type { MaybeArray } from '@applitools/utils';
 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';
 import { type Proxy } from '@applitools/req';
 import { type Renderer, type DomSnapshot, type AndroidSnapshot, type IOSSnapshot } from '@applitools/ufg-client';
 export * from '../automation/types';
 export type SnapshotTarget = MaybeArray<DomSnapshot> | MaybeArray<AndroidSnapshot> | MaybeArray<IOSSnapshot>;
-export type Target<TSpec extends SpecType> = SnapshotTarget | AutomationCore.Target<TSpec>;
-export interface Core<TSpec extends SpecType, TTarget = AutomationCore.Target<TSpec>, TEyes extends Eyes<TSpec, TTarget | SnapshotTarget> = Eyes<TSpec, TTarget | SnapshotTarget>> extends AutomationCore.Core<TSpec, TTarget, TEyes> {
+export type UFGTarget<TDriver, TContext, TElement, TSelector> = AutomationCore.DriverTarget<TDriver, TContext, TElement, TSelector> | SnapshotTarget;
+export interface Core<TDriver, TContext, TElement, TSelector, TEyes = Eyes<TDriver, TContext, TElement, TSelector>> extends AutomationCore.Core<TDriver, TContext, TElement, TSelector, TEyes> {
     readonly type: 'ufg';
     openEyes(options: {
-        target?: AutomationCore.DriverTarget<TSpec>;
+        target?: AutomationCore.DriverTarget<TDriver, TContext, TElement, TSelector>;
         settings: OpenSettings;
         eyes?: BaseCore.Eyes[];
         logger?: Logger;
     }): Promise<TEyes>;
 }
-export interface Eyes<TSpec extends SpecType, TTarget = Target<TSpec>> extends AutomationCore.Eyes<TSpec, TTarget> {
+export interface Eyes<TDriver, TContext, TElement, TSelector, TTarget = UFGTarget<TDriver, TContext, TElement, TSelector>> extends AutomationCore.Eyes<TDriver, TContext, TElement, TSelector, TTarget> {
     readonly type: 'ufg';
     getBaseEyes(options?: {
         settings?: {
@@ -28,23 +27,28 @@ export interface Eyes<TSpec extends SpecType, TTarget = Target<TSpec>> extends A
     }): Promise<BaseCore.Eyes[]>;
     check(options?: {
         target?: TTarget;
-        settings?: CheckSettings<TSpec>;
+        settings?: CheckSettings<TElement, TSelector>;
         logger?: Logger;
     }): Promise<CheckResult[]>;
     checkAndClose(options?: {
         target?: TTarget;
-        settings?: CheckSettings<TSpec> & AutomationCore.CloseSettings;
+        settings?: CheckSettings<TElement, TSelector> & AutomationCore.CloseSettings;
         logger?: Logger;
     }): Promise<TestResult[]>;
-    getResults(options?: {
-        settings?: AutomationCore.GetResultsSettings;
+    locateText: never;
+    extractText: never;
+    close(options?: {
+        settings?: AutomationCore.CloseSettings;
+        logger?: Logger;
+    }): Promise<TestResult[]>;
+    abort(options?: {
         logger?: Logger;
     }): Promise<TestResult[]>;
 }
 export type OpenSettings = AutomationCore.OpenSettings & {
     renderConcurrency?: number;
 };
-export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
+export type CheckSettings<TElement, TSelector> = AutomationCore.CheckSettings<TElement, TSelector> & {
     renderers?: Renderer[];
     hooks?: {
         beforeCaptureScreenshot: string;
@@ -59,11 +63,11 @@ export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings
     };
 };
 export type CheckResult = AutomationCore.CheckResult & {
-    readonly renderer: Renderer;
-    readonly promise: Promise<Omit<CheckResult, 'promise'> & {
+    readonly renderer?: Renderer;
+    readonly promise?: Promise<Omit<CheckResult, 'promise'> & {
         eyes: BaseCore.Eyes;
     }>;
 };
 export type TestResult = AutomationCore.TestResult & {
-    readonly renderer: Renderer;
+    readonly renderer?: Renderer;
 };

package/types/ufg/utils/extract-broker-url.d.ts

@@ -1,6 +1,6 @@
-import { type SpecType, type Driver } from '@applitools/driver';
+import { type Driver } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
-export declare function extractBrokerUrl<TSpec extends SpecType>({ driver, logger, }: {
-    driver: Driver<TSpec>;
+export declare function extractBrokerUrl({ driver, logger, }: {
+    driver: Driver<unknown, unknown, unknown, unknown>;
     logger: Logger;
 }): Promise<string | null>;

package/types/ufg/utils/generate-safe-selectors.d.ts

@@ -1,16 +1,16 @@
-import { type SpecType, type Context, type ElementReference, type CommonSelector } from '@applitools/driver';
-export declare function generateSafeSelectors<TSpec extends SpecType>({ context, elementReferences, }: {
-    context: Context<TSpec>;
-    elementReferences: ElementReference<TSpec>[];
+import { type Context, type Selector } from '@applitools/driver';
+export declare function generateSafeSelectors<TElement, TSelector>({ context, elementReferences, }: {
+    context: Context<unknown, unknown, TElement, TSelector>;
+    elementReferences: (TElement | Selector<TSelector>)[];
 }): Promise<{
     selectors: ({
         safeSelector: null;
         originalSelector: null;
-        elementReference: ElementReference<TSpec>;
+        elementReference: TElement | Selector<TSelector>;
     } | {
-        safeSelector: CommonSelector<never>;
-        originalSelector: import("@applitools/driver").Selector<never> | null;
-        elementReference: ElementReference<TSpec>;
+        safeSelector: Selector<never>;
+        originalSelector: Selector<never> | null;
+        elementReference: TElement | Selector<TSelector>;
     })[];
     cleanupGeneratedSelectors: () => Promise<void>;
 }>;

package/types/ufg/utils/take-dom-snapshot.d.ts

@@ -1,5 +1,5 @@
 import { type Logger } from '@applitools/logger';
-import { type SpecType, type Context } from '@applitools/driver';
+import { type Context } from '@applitools/driver';
 import { type DomSnapshot } from '@applitools/ufg-client';
 type RawDomSnapshot = {
     url: string;
@@ -29,8 +29,8 @@ export type DomSnapshotSettings = {
     pollTimeout?: number;
     showLogs?: boolean;
 };
-export declare function takeDomSnapshot<TSpec extends SpecType>({ context, settings, logger, }: {
-    context: Context<TSpec>;
+export declare function takeDomSnapshot<TContext extends Context<unknown, unknown, unknown, unknown>>({ context, settings, logger, }: {
+    context: TContext;
     settings?: DomSnapshotSettings;
     logger: Logger;
 }): Promise<DomSnapshot>;

package/types/ufg/utils/take-dom-snapshots.d.ts

@@ -1,6 +1,6 @@
 import type { Size } from '@applitools/utils';
 import { type Logger } from '@applitools/logger';
-import { type SpecType, type Driver } from '@applitools/driver';
+import { type Driver } from '@applitools/driver';
 import { type DomSnapshot, type Renderer, type ChromeEmulationDevice, type IOSDevice, type ScreenOrientation } from '@applitools/ufg-client';
 import { type DomSnapshotSettings } from './take-dom-snapshot';
 export * from './take-dom-snapshot';
@@ -9,8 +9,8 @@ export type DomSnapshotsSettings = DomSnapshotSettings & {
     waitBeforeCapture?: number | (() => void);
     layoutBreakpoints?: number[] | boolean;
 };
-export declare function takeDomSnapshots<TSpec extends SpecType>({ driver, settings, hooks, provides, logger, }: {
-    driver: Driver<TSpec>;
+export declare function takeDomSnapshots<TDriver extends Driver<unknown, unknown, unknown, unknown>>({ driver, settings, hooks, provides, logger, }: {
+    driver: TDriver;
     settings: DomSnapshotsSettings;
     hooks?: {
         beforeSnapshots?(): void | Promise<void>;

package/types/ufg/utils/take-snapshots.d.ts

@@ -1,13 +1,13 @@
 import type { Size } from '@applitools/utils';
 import { type Logger } from '@applitools/logger';
-import { type SpecType, type Driver } from '@applitools/driver';
+import { type Driver } from '@applitools/driver';
 import { type DomSnapshot, type AndroidSnapshot, type IOSSnapshot, type ChromeEmulationDevice, type IOSDevice, type ScreenOrientation } from '@applitools/ufg-client';
 import { type DomSnapshotsSettings } from './take-dom-snapshots';
 import { type VHSesSettings } from './take-vhses';
 export * from './take-dom-snapshots';
 export * from './take-vhses';
-export declare function takeSnapshots<TSpec extends SpecType>({ driver, settings, hooks, provides, logger, }: {
-    driver: Driver<TSpec>;
+export declare function takeSnapshots<TDriver extends Driver<unknown, unknown, unknown, unknown>>({ driver, settings, hooks, provides, logger, }: {
+    driver: TDriver;
     settings: DomSnapshotsSettings & VHSesSettings;
     hooks: {
         beforeSnapshots?(): void | Promise<void>;

package/types/ufg/utils/take-vhses.d.ts

@@ -1,13 +1,13 @@
 import type { ServerSettings } from '../types';
 import { type Logger } from '@applitools/logger';
-import { type SpecType, type Driver } from '@applitools/driver';
+import { type Driver } from '@applitools/driver';
 import { type Renderer, type AndroidSnapshot, type IOSSnapshot } from '@applitools/ufg-client';
 export type VHSesSettings = ServerSettings & {
     renderers: Renderer[];
     waitBeforeCapture?: number;
 };
-export declare function takeVHSes<TSpec extends SpecType>({ driver, settings, hooks, logger, }: {
-    driver: Driver<TSpec>;
+export declare function takeVHSes<TDriver extends Driver<unknown, unknown, unknown, unknown>>({ driver, settings, hooks, logger, }: {
+    driver: TDriver;
     settings: VHSesSettings;
     hooks?: {
         beforeSnapshots?(): void | Promise<void>;

package/dist/get-eyes-results.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeGetEyesResults = void 0;
-const test_error_1 = require("./errors/test-error");
-function makeGetEyesResults({ eyes, logger: defaultLogger, }) {
-    return async function getEyesResults({ settings, logger = defaultLogger, } = {}) {
-        const typedEyes = await eyes.getTypedEyes({ logger });
-        const results = await typedEyes.getResults({ settings, logger });
-        if (settings === null || settings === void 0 ? void 0 : settings.throwErr) {
-            results.forEach(result => {
-                if (result.status !== 'Passed')
-                    throw new test_error_1.TestError(result);
-            });
-        }
-        return results;
-    };
-}
-exports.makeGetEyesResults = makeGetEyesResults;

package/dist/ufg/get-results.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeGetResults = void 0;
-const abort_error_1 = require("../errors/abort-error");
-function makeGetResults({ storage, logger: defaultLogger }) {
-    return async function getResults({ settings, logger = defaultLogger, } = {}) {
-        logger.log('Command "getResults" is called with settings', settings);
-        return Promise.all(Array.from(storage.values(), async (promises) => {
-            var _a;
-            try {
-                const [{ eyes, renderer }] = await Promise.all(promises);
-                const [result] = await eyes.getResults({ settings, logger });
-                return { ...result, renderer };
-            }
-            catch (error) {
-                if (error instanceof abort_error_1.AbortError && ((_a = error.info) === null || _a === void 0 ? void 0 : _a.eyes)) {
-                    logger.warn('Command "getResults" received an abort error during performing', settings);
-                    const [result] = await error.info.eyes.getResults({ settings, logger });
-                    return { ...result, renderer: error.info.renderer };
-                }
-                logger.fatal('Command "getResults" received an error during performing', settings);
-                throw error;
-            }
-        }));
-    };
-}
-exports.makeGetResults = makeGetResults;