@applitools/core 3.9.0 → 3.10.0

package/types/classic/types.d.ts

@@ -1,4 +1,3 @@
-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';
@@ -8,7 +7,7 @@ export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec>
     openEyes(options: {
         target?: AutomationCore.DriverTarget<TSpec>;
         settings: OpenSettings;
-        base?: BaseCore.Eyes[];
+        storage?: AutomationCore.EyesStorage;
         logger?: Logger;
     }): Promise<Eyes<TSpec>>;
 }
@@ -19,7 +18,7 @@ export interface Eyes<TSpec extends SpecType> extends AutomationCore.Eyes<TSpec>
         target?: AutomationCore.Target<TSpec>;
         settings?: CheckSettings<TSpec>;
         logger?: Logger;
-    }): Promise<AutomationCore.CheckResult[]>;
+    }): Promise<void>;
     checkAndClose(options?: {
         target?: AutomationCore.Target<TSpec>;
         settings?: CheckSettings<TSpec> & AutomationCore.CloseSettings;
@@ -27,8 +26,8 @@ export interface Eyes<TSpec extends SpecType> extends AutomationCore.Eyes<TSpec>
     }): Promise<void>;
 }
 export type OpenSettings = AutomationCore.OpenSettings & {
-    keepPlatformNameAsIs?: boolean;
     useCeilForViewportSize?: boolean;
+    keepPlatformNameAsIs?: boolean;
 };
 export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
     retryTimeout?: number;

package/types/classic/utils/extract-default-renderers.d.ts

@@ -0,0 +1,9 @@
+import type { EnvironmentRenderer, Environment } from '../types';
+import { type SpecType, type Driver } from '@applitools/driver';
+export declare function extractDefaultRenderers<TSpec extends SpecType>({ driver, settings, }: {
+    driver?: Driver<TSpec>;
+    settings?: {
+        keepPlatformNameAsIs?: boolean;
+        environment?: Environment;
+    };
+}): Promise<EnvironmentRenderer[]>;

package/types/classic/utils/take-screenshots.d.ts

@@ -0,0 +1,18 @@
+import type { ScreenshotSettings, Renderer } from '../types';
+import type { Target as BaseTarget } from '@applitools/core-base';
+import { type Logger } from '@applitools/logger';
+import { type SpecType, type Driver, type ElementReference } from '@applitools/driver';
+import { type DomCaptureSettings } from './take-dom-capture';
+export type ScreenshotsSettings<TSpec extends SpecType> = ScreenshotSettings<TSpec> & {
+    renderers: Renderer[];
+    regionsToCalculate?: ElementReference<TSpec>[];
+    calculateView?: boolean;
+    domSettings?: DomCaptureSettings;
+};
+export declare function takeScreenshots<TSpec extends SpecType>({ driver, settings, logger, }: {
+    driver: Driver<TSpec>;
+    settings: ScreenshotsSettings<TSpec>;
+    logger: Logger;
+}): Promise<(BaseTarget & {
+    calculatedRegions: any;
+})[]>;

package/types/close.d.ts

@@ -1,11 +1,12 @@
-import type { Eyes, Config, CloseSettings } from './types';
+import type { Eyes, Config, CloseSettings, Renderer } 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>;
+    renderers?: Renderer[];
     logger: Logger;
 };
-export declare function makeClose<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ eyes, logger: mainLogger, }: Options<TSpec, TType>): ({ settings, config, logger, }?: {
+export declare function makeClose<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ eyes, renderers: defaultRenderers, logger: mainLogger, }: Options<TSpec, TType>): ({ settings, config, logger, }?: {
     settings?: CloseSettings<TType> | undefined;
     config?: Config<TSpec, TType> | undefined;
     logger?: Logger | undefined;

package/types/core.d.ts

@@ -1,9 +1,15 @@
 import type { Core } from './types';
 import type { Core as BaseCore } from '@applitools/core-base';
+import { type UFGClient } from '@applitools/ufg-client';
+import { type NMLClient } from '@applitools/nml-client';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 type Options<TSpec extends SpecType> = {
     spec?: SpecDriver<TSpec>;
+    clients?: {
+        ufg?: UFGClient;
+        nml?: NMLClient;
+    };
     concurrency?: number;
     base?: BaseCore;
     agentId?: string;
@@ -11,5 +17,5 @@ type Options<TSpec extends SpecType> = {
     cwd?: string;
     logger?: Logger;
 };
-export declare function makeCore<TSpec extends SpecType>({ spec, concurrency, base: defaultBase, environment: defaultEnvironment, agentId, cwd, logger: defaultLogger, }?: Options<TSpec>): Core<TSpec, 'classic' | 'ufg'>;
+export declare function makeCore<TSpec extends SpecType>({ spec, clients, concurrency, base: defaultBase, environment: defaultEnvironment, agentId, cwd, logger: defaultLogger, }?: Options<TSpec>): Core<TSpec, 'classic' | 'ufg'>;
 export {};

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

@@ -1,6 +1,5 @@
-import type { DriverTarget, TypedCore, TypedEyes, OpenSettings } from './types';
+import type { DriverTarget, TypedCore, TypedEyes, OpenSettings, Renderer } from './types';
 import { type SpecType } from '@applitools/driver';
-import { type RenderEnvironmentSettings } from '@applitools/ufg-client';
 import { type Logger } from '@applitools/logger';
 type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     type: TType;
@@ -11,9 +10,11 @@ type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     };
     logger: Logger;
 };
-export declare function makeGetTypedEyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, settings: defaultSettings, target, cores, logger: mainLogger, }: Options<TSpec, 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: mainLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, logger, }?: {
     type?: TType | undefined;
-    settings?: RenderEnvironmentSettings[] | undefined;
+    settings?: {
+        renderers?: Renderer[] | undefined;
+    } | undefined;
     logger?: Logger | undefined;
 }) => Promise<TypedEyes<TSpec, TType>>;
 export {};

package/types/make-manager.d.ts

@@ -1,9 +1,15 @@
 import type { Core, EyesManager, ManagerSettings } from './types';
 import type { Core as BaseCore } from '@applitools/core-base';
+import { type UFGClient } from '@applitools/ufg-client';
+import { type NMLClient } from '@applitools/nml-client';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     spec?: SpecDriver<TSpec>;
+    clients?: {
+        ufg?: UFGClient;
+        nml?: NMLClient;
+    };
     concurrency?: number;
     core: Core<TSpec>;
     base?: BaseCore;
@@ -12,7 +18,7 @@ type Options<TSpec extends SpecType> = {
     cwd?: string;
     logger: Logger;
 };
-export declare function makeMakeManager<TSpec extends SpecType>({ spec, concurrency: defaultConcurrency, core, base, agentId: defaultAgentId, environment, cwd, logger: mainLogger, }: Options<TSpec>): <TType extends "classic" | "ufg" = "classic">({ type, settings, logger, }?: {
+export declare function makeMakeManager<TSpec extends SpecType>({ spec, clients, concurrency: defaultConcurrency, core, base, agentId: defaultAgentId, environment, cwd, logger: mainLogger, }: Options<TSpec>): <TType extends "classic" | "ufg" = "classic">({ type, settings, logger, }?: {
     type?: TType | undefined;
     settings?: ManagerSettings | undefined;
     logger?: Logger | undefined;

package/types/open-eyes.d.ts

@@ -1,8 +1,14 @@
 import type { DriverTarget, Core, TypedCore, Batch, Eyes, Config, OpenSettings } from './types';
+import { type UFGClient } from '@applitools/ufg-client';
+import { type NMLClient } from '@applitools/nml-client';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     type?: TType;
+    clients?: {
+        ufg?: UFGClient;
+        nml?: NMLClient;
+    };
     concurrency?: number;
     batch?: Batch;
     core: Core<TSpec, TType>;
@@ -13,7 +19,7 @@ type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     environment?: Record<string, any>;
     logger: Logger;
 };
-export declare function makeOpenEyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg' = 'classic'>({ type: defaultType, concurrency, batch, core, cores, spec, environment, logger: mainLogger, }: Options<TSpec, 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, clients, concurrency, batch, core, cores, spec, environment, logger: mainLogger, }: 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;

package/types/types.d.ts

@@ -4,9 +4,8 @@ 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';
 import { type ECClient, type ECClientSettings } from '@applitools/ec-client';
-export { ECClient, Renderer };
+export { ECClient };
 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'> = TType extends 'ufg' ? UFGCore.Eyes<TSpec> : ClassicCore.Eyes<TSpec>;
@@ -64,7 +63,6 @@ export interface Eyes<TSpec extends SpecType, TDefaultType extends 'classic' | '
     readonly core: Core<TSpec, TDefaultType>;
     getTypedEyes<TType extends 'classic' | 'ufg' = TDefaultType>(options?: {
         type?: TType;
-        settings?: any;
         logger?: Logger;
     }): Promise<TypedEyes<TSpec, TType>>;
     check<TType extends 'classic' | 'ufg' = TDefaultType>(options?: {
@@ -73,7 +71,7 @@ export interface Eyes<TSpec extends SpecType, TDefaultType extends 'classic' | '
         settings?: Partial<CheckSettings<TSpec, TDefaultType> & CheckSettings<TSpec, TType>>;
         config?: Config<TSpec, TDefaultType> & Config<TSpec, TType>;
         logger?: Logger;
-    }): Promise<CheckResult<TType>[]>;
+    }): Promise<void>;
     checkAndClose<TType extends 'classic' | 'ufg' = TDefaultType>(options?: {
         type?: TType;
         target?: Target<TSpec, TType>;
@@ -122,12 +120,11 @@ export type GetEyesResultsSettings<TType extends 'classic' | 'ufg'> = GetResults
 export type GetManagerResultsSettings<TType extends 'classic' | 'ufg'> = GetEyesResultsSettings<TType> & {
     removeDuplicateTests?: boolean;
 };
-export type CheckResult<TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.CheckResult : ClassicCore.CheckResult;
 export type TestResult<TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.TestResult : ClassicCore.TestResult;
 export interface TestResultContainer<TType extends 'classic' | 'ufg'> {
     readonly error?: Error;
     readonly result?: TestResult<TType>;
-    readonly renderer?: TType extends 'ufg' ? Renderer : never;
+    readonly renderer?: TType extends 'ufg' ? AutomationCore.Renderer : never;
     readonly userTestId?: string;
 }
 export interface TestResultSummary<TType extends 'classic' | 'ufg'> {

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

@@ -1,27 +1,21 @@
 import type { Region } from '@applitools/utils';
-import type { DriverTarget, Target, Eyes, CheckSettings, CloseSettings } from './types';
-import type { Eyes as BaseEyes } from '@applitools/core-base';
-import { type Renderer } from '@applitools/ufg-client';
+import type { DriverTarget, Target, Eyes, CheckSettings, CloseSettings, Renderer } from './types';
 import { type AbortSignal } from 'abort-controller';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     eyes: Eyes<TSpec>;
-    storage: Map<string, Promise<{
-        renderer: Renderer;
-        eyes: BaseEyes;
-    }>[]>;
     target?: DriverTarget<TSpec>;
+    renderers?: Renderer[];
     spec?: SpecDriver<TSpec>;
     signal?: AbortSignal;
     logger: Logger;
 };
-export declare function makeCheckAndClose<TSpec extends SpecType>({ eyes, storage, target: defaultTarget, spec, signal, logger: mainLogger, }: Options<TSpec>): ({ target, settings, logger, }?: {
+export declare function makeCheckAndClose<TSpec extends SpecType>({ eyes, target: defaultTarget, renderers: defaultRenderers, spec, signal, logger: mainLogger, }: 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?: (Renderer & {
-            properties?: import("@applitools/core-base").CustomProperty[] | undefined;
-        })[] | undefined;
+        renderers?: Renderer[] | undefined;
+    } & {
         hooks?: {
             beforeCaptureScreenshot: string;
         } | undefined;
@@ -36,7 +30,9 @@ export declare function makeCheckAndClose<TSpec extends SpecType>({ eyes, storag
             domains?: string[] | undefined;
         }) | undefined;
         headers?: Record<string, string> | undefined;
-    } & CloseSettings) | undefined;
+    } & import("@applitools/core-base").CloseSettings & {
+        renderers?: Renderer[] | undefined;
+    }) | undefined;
     logger?: Logger | undefined;
 }) => Promise<void>;
 export {};

package/types/ufg/check.d.ts

@@ -1,23 +1,18 @@
-import type { DriverTarget, Target, Eyes, CheckSettings, CheckResult } from './types';
-import type { Eyes as BaseEyes } from '@applitools/core-base';
-import { type Renderer } from '@applitools/ufg-client';
+import type { DriverTarget, Target, Eyes, CheckSettings, Renderer } from './types';
 import { type AbortSignal } from 'abort-controller';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     eyes: Eyes<TSpec>;
-    storage: Map<string, Promise<{
-        renderer: Renderer;
-        eyes: BaseEyes;
-    }>[]>;
     target?: DriverTarget<TSpec>;
+    renderers?: Renderer[];
     spec?: SpecDriver<TSpec>;
     signal?: AbortSignal;
     logger: Logger;
 };
-export declare function makeCheck<TSpec extends SpecType>({ eyes, storage, target: defaultTarget, spec, signal, logger: mainLogger, }: Options<TSpec>): ({ target, settings, logger, }?: {
+export declare function makeCheck<TSpec extends SpecType>({ eyes, target: defaultTarget, renderers: defaultRenderers, spec, signal, logger: mainLogger, }: Options<TSpec>): ({ target, settings, logger, }?: {
     settings?: CheckSettings<TSpec> | undefined;
     target?: Target<TSpec> | undefined;
     logger?: Logger | undefined;
-}) => Promise<CheckResult[]>;
+}) => Promise<void>;
 export {};

package/types/ufg/core.d.ts

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

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

@@ -8,12 +8,8 @@ type Options<TSpec extends SpecType> = {
     base?: BaseEyes[];
     logger: Logger;
 };
-export declare function makeGetBaseEyes<TSpec extends SpecType>({ settings: defaultSettings, eyes, base, logger: mainLogger, }: Options<TSpec>): (({ settings, logger, }?: {
-    settings?: GetBaseEyesSettings | undefined;
+export declare function makeGetBaseEyes<TSpec extends SpecType>({ settings: defaultSettings, eyes, logger: mainLogger, }: Options<TSpec>): ({ settings, logger, }: {
+    settings: GetBaseEyesSettings;
     logger?: Logger | undefined;
-}) => Promise<BaseEyes[]>) & {
-    getCachedValues(): Promise<BaseEyes[]>[];
-    setCachedValue(key: any, value: Promise<BaseEyes[]>): void;
-    clearCache(): void;
-};
+}) => Promise<BaseEyes>;
 export {};

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

@@ -1,5 +1,4 @@
-import type { DriverTarget, Core, Eyes, OpenSettings } from './types';
-import type { Eyes as BaseEyes } from '@applitools/core-base';
+import type { DriverTarget, Core, Eyes, EyesStorage, OpenSettings } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
@@ -7,10 +6,10 @@ type Options<TSpec extends SpecType> = {
     spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: mainLogger }: Options<TSpec>): ({ target, settings, base, logger, }: {
+export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: mainLogger }: Options<TSpec>): ({ target, settings, storage, logger, }: {
     target?: DriverTarget<TSpec> | undefined;
     settings: OpenSettings;
-    base?: BaseEyes[] | undefined;
+    storage?: EyesStorage | undefined;
     logger?: Logger | undefined;
 }) => Promise<Eyes<TSpec>>;
 export {};

package/types/ufg/types.d.ts

@@ -1,10 +1,9 @@
 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 UFGClient, type UFGClientSettings, type RenderEnvironmentSettings, type Renderer, type DomSnapshot, type AndroidSnapshot, type IOSSnapshot } from '@applitools/ufg-client';
+import { type UFGClient, type UFGClientSettings, 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>;
@@ -17,39 +16,25 @@ export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec>
     openEyes(options: {
         target?: AutomationCore.DriverTarget<TSpec>;
         settings: AutomationCore.OpenSettings;
-        base?: BaseCore.Eyes[];
+        storage?: AutomationCore.EyesStorage;
         logger?: Logger;
     }): Promise<Eyes<TSpec>>;
 }
 export interface Eyes<TSpec extends SpecType> extends AutomationCore.Eyes<TSpec> {
     readonly type: 'ufg';
     readonly core: Core<TSpec>;
-    getBaseEyes(options?: {
-        settings?: GetBaseEyesSettings;
-        logger?: Logger;
-    }): Promise<BaseCore.Eyes[]>;
     check(options?: {
         target?: Target<TSpec>;
         settings?: CheckSettings<TSpec>;
         logger?: Logger;
-    }): Promise<CheckResult[]>;
+    }): Promise<void>;
     checkAndClose(options?: {
         target?: Target<TSpec>;
         settings?: CheckSettings<TSpec> & AutomationCore.CloseSettings;
         logger?: Logger;
     }): Promise<void>;
-    getResults(options?: {
-        settings?: AutomationCore.GetResultsSettings;
-        logger?: Logger;
-    }): Promise<TestResult[]>;
 }
-export type GetBaseEyesSettings = RenderEnvironmentSettings & {
-    properties?: BaseCore.CustomProperty[];
-};
 export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
-    renderers?: (Renderer & {
-        properties?: BaseCore.CustomProperty[];
-    })[];
     hooks?: {
         beforeCaptureScreenshot: string;
     };
@@ -65,9 +50,3 @@ export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings
     };
     headers?: Record<string, string>;
 };
-export type CheckResult = AutomationCore.CheckResult & {
-    readonly renderer: Renderer;
-};
-export type TestResult = AutomationCore.TestResult & {
-    readonly renderer: Renderer;
-};

package/types/ufg/utils/extract-default-renderers.d.ts

@@ -0,0 +1,5 @@
+import type { Renderer } from '../types';
+import { type SpecType, type Driver } from '@applitools/driver';
+export declare function extractDefaultRenderers<TSpec extends SpecType>({ driver, }: {
+    driver?: Driver<TSpec>;
+}): Promise<Renderer[]>;

package/types/universal/spec-driver.d.ts

@@ -1,11 +1,12 @@
 import type { Ref, ServerSocket, UniversalSpecDriver } from './types';
-import type { SpecType as BaseSpecType, SpecDriver, CommonSelector } from '@applitools/driver';
+import type { SpecType, SpecDriver as BaseSpecDriver, CommonSelector } from '@applitools/driver';
 export type Driver = Ref;
 export type Context = Ref;
 export type Element = Ref;
 export type Selector = string | CommonSelector | Ref;
-export type SpecType = BaseSpecType<Driver, Context, Element, Selector>;
+export type PrimarySpecType = SpecType<Driver, Context, Element, Selector>;
+export type SpecDriver = BaseSpecDriver<PrimarySpecType>;
 export declare function makeSpec({ socket, spec, }: {
-    socket: ServerSocket<SpecType, any>;
-    spec: (keyof UniversalSpecDriver<SpecType>)[];
-}): SpecDriver<SpecType>;
+    socket: ServerSocket<PrimarySpecType, any>;
+    spec: (keyof UniversalSpecDriver<PrimarySpecType>)[];
+}): SpecDriver;

package/types/universal/types.d.ts

@@ -56,16 +56,6 @@ export interface UniversalSpecDriver<T extends SpecType> {
         element1: T['element'];
         element2: T['element'];
     }): Promise<boolean>;
-    mainContext(options: {
-        context: T['context'];
-    }): Promise<T['context']>;
-    parentContext(options: {
-        context: T['context'];
-    }): Promise<T['context']>;
-    childContext(options: {
-        context: T['context'];
-        element: T['element'];
-    }): Promise<T['context']>;
     executeScript(options: {
         context: T['context'];
         script: string;
@@ -87,6 +77,15 @@ export interface UniversalSpecDriver<T extends SpecType> {
         parent?: T['element'];
         options?: WaitOptions;
     }): Promise<T['element'] | null>;
+    getElementRegion(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<Region>;
+    getElementAttribute(options: {
+        context: T['context'];
+        element: T['element'];
+        attr: string;
+    }): Promise<string>;
     setElementText(options: {
         context: T['context'];
         element: T['element'];
@@ -96,6 +95,30 @@ export interface UniversalSpecDriver<T extends SpecType> {
         context: T['context'];
         element: T['element'];
     }): Promise<string>;
+    hover(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<void>;
+    click(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<void>;
+    mainContext(options: {
+        context: T['context'];
+    }): Promise<T['context']>;
+    parentContext(options: {
+        context: T['context'];
+    }): Promise<T['context']>;
+    childContext(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<T['context']>;
+    getDriverInfo(options: {
+        driver: T['driver'];
+    }): Promise<DriverInfo>;
+    getCapabilities(options: {
+        driver: T['driver'];
+    }): Promise<Record<string, any>>;
     setWindowSize(options: {
         driver: T['driver'];
         size: Size;
@@ -110,40 +133,6 @@ export interface UniversalSpecDriver<T extends SpecType> {
     getViewportSize(options: {
         driver: T['driver'];
     }): Promise<Size>;
-    getCookies(options: {
-        driver: T['driver'] | T['context'];
-        context?: boolean;
-    }): Promise<Cookie[]>;
-    getDriverInfo(options: {
-        driver: T['driver'];
-    }): Promise<DriverInfo>;
-    getCapabilities(options: {
-        driver: T['driver'];
-    }): Promise<Record<string, any>>;
-    getTitle(options: {
-        driver: T['driver'];
-    }): Promise<string>;
-    getUrl(options: {
-        driver: T['driver'];
-    }): Promise<string>;
-    takeScreenshot(options: {
-        driver: T['driver'];
-    }): Promise<string>;
-    click(options: {
-        context: T['context'];
-        element: T['element'] | T['selector'];
-    }): Promise<void>;
-    visit(options: {
-        driver: T['driver'];
-        url: string;
-    }): Promise<void>;
-    getOrientation(options: {
-        driver: T['driver'];
-    }): Promise<'portrait' | 'landscape' | 'portrait-secondary' | 'landscape-secondary'>;
-    setOrientation(options: {
-        driver: T['driver'];
-        orientation: 'portrait' | 'landscape' | 'portrait-secondary' | 'landscape-secondary';
-    }): Promise<void>;
     getSystemBars(options: {
         driver: T['driver'];
     }): Promise<{
@@ -162,19 +151,34 @@ export interface UniversalSpecDriver<T extends SpecType> {
             width: number;
         };
     }>;
-    getElementRegion(options: {
+    getOrientation(options: {
         driver: T['driver'];
-        element: T['element'];
-    }): Promise<Region>;
-    getElementAttribute(options: {
+    }): Promise<'portrait' | 'landscape' | 'portrait-secondary' | 'landscape-secondary'>;
+    setOrientation(options: {
+        driver: T['driver'];
+        orientation: 'portrait' | 'landscape' | 'portrait-secondary' | 'landscape-secondary';
+    }): Promise<void>;
+    getCookies(options: {
+        driver: T['driver'] | T['context'];
+        context?: boolean;
+    }): Promise<Cookie[]>;
+    getTitle(options: {
+        driver: T['driver'];
+    }): Promise<string>;
+    getUrl(options: {
+        driver: T['driver'];
+    }): Promise<string>;
+    takeScreenshot(options: {
         driver: T['driver'];
-        element: T['element'];
-        attr: string;
     }): Promise<string>;
     performAction(options: {
         driver: T['driver'];
         steps: any[];
     }): Promise<void>;
+    visit(options: {
+        driver: T['driver'];
+        url: string;
+    }): Promise<void>;
     getCurrentWorld(options: {
         driver: T['driver'];
     }): Promise<string>;

package/dist/classic/abort.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeAbort = void 0;
-const driver_1 = require("@applitools/driver");
-function makeAbort({ eyes, target, spec, logger: mainLogger }) {
-    return async function abort({ settings, logger = mainLogger, } = {}) {
-        logger = logger.extend(mainLogger);
-        logger.log('Command "abort" is called with settings', settings);
-        settings !== null && settings !== void 0 ? settings : (settings = {});
-        if (!settings.testMetadata) {
-            try {
-                const driver = (0, driver_1.isDriver)(target, spec) ? await (0, driver_1.makeDriver)({ spec, driver: target, logger }) : null;
-                settings.testMetadata = await (driver === null || driver === void 0 ? void 0 : driver.getSessionMetadata());
-            }
-            catch (error) {
-                logger.warn('Command "abort" received an error during extracting driver metadata', error);
-            }
-        }
-        const baseEyes = await eyes.getBaseEyes();
-        await Promise.all(baseEyes.map(baseEyes => baseEyes.abort({ settings, logger })));
-    };
-}
-exports.makeAbort = makeAbort;

package/dist/classic/close.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeClose = void 0;
-const driver_1 = require("@applitools/driver");
-function makeClose({ eyes, target, spec, logger: mainLogger }) {
-    return async function close({ settings, logger = mainLogger, } = {}) {
-        logger = logger.extend(mainLogger);
-        logger.log('Command "close" is called with settings', settings);
-        settings !== null && settings !== void 0 ? settings : (settings = {});
-        if (!settings.testMetadata) {
-            try {
-                const driver = (0, driver_1.isDriver)(target, spec) ? await (0, driver_1.makeDriver)({ spec, driver: target, logger }) : null;
-                settings.testMetadata = await (driver === null || driver === void 0 ? void 0 : driver.getSessionMetadata());
-            }
-            catch (error) {
-                logger.warn('Command "close" received an error during extracting driver metadata', error);
-            }
-        }
-        const baseEyes = await eyes.getBaseEyes();
-        await Promise.all(baseEyes.map(baseEyes => baseEyes.close({ settings, logger })));
-    };
-}
-exports.makeClose = makeClose;