@applitools/core 2.5.2 → 2.5.3-legacy

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

@@ -1,18 +1,14 @@
-import type { Eyes, OpenSettings } from './types';
+import type { Eyes, GetBaseEyesSettings, OpenSettings } from './types';
 import type { Eyes as BaseEyes } from '@applitools/core-base';
 import { type SpecType } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 type Options<TSpec extends SpecType> = {
     settings: OpenSettings;
     eyes: Eyes<TSpec>;
-    base?: BaseEyes[];
     logger: Logger;
 };
-export declare function makeGetBaseEyes<TSpec extends SpecType>({ settings, eyes, base, logger: defaultLogger }: Options<TSpec>): (({ logger }?: {
+export declare function makeGetBaseEyes<TSpec extends SpecType>({ settings: defaultSettings, eyes, logger: mainLogger, }: Options<TSpec>): ({ settings, logger, }: {
+    settings: GetBaseEyesSettings<TSpec>;
     logger?: Logger | undefined;
-}) => Promise<BaseEyes[]>) & {
-    getCachedValues(): Promise<BaseEyes[]>[];
-    setCachedValue(key: any, value: Promise<BaseEyes[]>): void;
-    clearCache(): void;
-};
+}) => Promise<BaseEyes>;
 export {};

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

@@ -1,5 +1,4 @@
-import type { Core, DriverTarget, 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: defaultLogger }: 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/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,16 +18,16 @@ 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;
         logger?: Logger;
-    }): Promise<AutomationCore.TestResult[]>;
+    }): 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-environments.d.ts

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

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

@@ -8,6 +8,14 @@ export type DomCaptureSettings = {
     chunkByteLength?: number;
     proxy?: Proxy;
     fetch?: Fetch;
+    domCaptureArgs?: {
+        styleProps?: string[] | boolean;
+        rectProps?: string[];
+        elementProps?: string[];
+        capturePseudo?: boolean;
+        addStats?: boolean;
+        fetchTimeLimit?: number;
+    };
 };
 export declare function takeDomCapture<TSpec extends SpecType>({ driver, settings, logger, }: {
     driver: Driver<TSpec>;

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

@@ -0,0 +1,18 @@
+import type { ScreenshotSettings, Environment } 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> & {
+    environments: Environment[];
+    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-batch.d.ts

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

package/types/close.d.ts

@@ -1,11 +1,12 @@
-import type { Eyes, Config, CloseSettings } from './types';
+import type { Eyes, Config, CloseSettings, Environment } 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>;
+    environments?: Environment[];
     logger: Logger;
 };
-export declare function makeClose<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TSpec, TType>): ({ settings, config, logger, }?: {
+export declare function makeClose<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ eyes, environments: defaultEnvironments, 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,14 +1,23 @@
 import type { Core } from './types';
 import type { Core as BaseCore } from '@applitools/core-base';
+import { type AsyncCache, 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>;
-    concurrency?: number;
+    clients?: {
+        ufg?: UFGClient;
+        nml?: NMLClient;
+    };
     base?: BaseCore;
+    concurrency?: number;
+    environment?: Record<string, any>;
     agentId?: string;
     cwd?: string;
     logger?: Logger;
+    asyncCache?: AsyncCache;
+    maskLog?: boolean;
 };
-export declare function makeCore<TSpec extends SpecType>({ spec, concurrency, base: defaultBase, agentId, cwd, logger: defaultLogger, }?: Options<TSpec>): Core<TSpec, 'classic' | 'ufg'>;
+export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, concurrency, environment: defaultEnvironment, agentId, cwd, maskLog, logger: defaultLogger, asyncCache, }?: Options<TSpec>): Core<TSpec, 'classic' | 'ufg'>;
 export {};

package/types/delete-test.d.ts

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

package/types/extract-text.d.ts

@@ -7,7 +7,7 @@ type Options<TSpec extends SpecType> = {
     core: Core<TSpec>;
     logger: Logger;
 };
-export declare function makeExtractText<TSpec extends SpecType>({ spec, core, logger: defaultLogger }: Options<TSpec>): ({ target, settings, config, logger, }: {
+export declare function makeExtractText<TSpec extends SpecType>({ spec, core, logger: mainLogger }: Options<TSpec>): ({ target, settings, config, logger, }: {
     target: Target<TSpec, 'classic'>;
     settings: MaybeArray<ExtractTextSettings<TSpec>>;
     config?: Config<TSpec, "classic"> | undefined;

package/types/get-account-info.d.ts

@@ -0,0 +1,11 @@
+import type { Core, Account, EyesServerSettings } from './types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: Core<any>;
+    logger: Logger;
+};
+export declare function makeGetAccountInfo({ core, logger: mainLogger }: Options): ({ settings, logger, }: {
+    settings: EyesServerSettings;
+    logger?: Logger | undefined;
+}) => Promise<Account>;
+export {};

package/types/get-ec-client.d.ts

@@ -3,7 +3,7 @@ import { type Logger } from '@applitools/logger';
 type Options = {
     logger: Logger;
 };
-export declare function makeGetECClient({ logger: defaultLogger }: Options): (({ settings, logger, }?: {
+export declare function makeGetECClient({ logger: mainLogger }: Options): (({ settings, logger, }?: {
     settings?: Partial<ECClientSettings> | undefined;
     logger?: Logger | undefined;
 }) => Promise<ECClient>) & {

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

@@ -5,7 +5,7 @@ type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     eyes: Eyes<TSpec, TType>;
     logger: Logger;
 };
-export declare function makeGetEyesResults<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TSpec, TType>): ({ settings, logger, }?: {
+export declare function makeGetEyesResults<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ eyes, logger: mainLogger, }: Options<TSpec, TType>): ({ settings, logger, }?: {
     settings?: GetEyesResultsSettings<TType> | undefined;
     logger?: Logger | undefined;
 }) => Promise<TestResult<TType>[]>;

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

@@ -6,7 +6,7 @@ type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     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, }?: {
+export declare function makeGetManagerResults<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ core, storage, logger: mainLogger, }: Options<TSpec, TType>): ({ settings, logger, }?: {
     settings?: GetManagerResultsSettings<TType> | undefined;
     logger?: Logger | undefined;
 }) => Promise<TestResultSummary<TType>>;

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

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

package/types/index.d.ts

@@ -2,7 +2,8 @@ export * from './types';
 export * from './core';
 export * from './universal/core-server';
 export * from './universal/core-server-process';
+export * from './autonomous/core';
 export { type SpecType, type SpecDriver, 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';
+export * as logs from './troubleshoot/logs';

package/types/lang.d.ts

@@ -0,0 +1,32 @@
+export declare const matchLevelContentDeprecatedWarning = "The \"Content\" match level value has been deprecated, use \"IgnoreColors\" instead.";
+export declare const edgeUfgEnvironmentDeprecatedWarning = "The 'edge' option that is being used in your browsers' configuration will soon be deprecated. Please change it to either 'edgelegacy' for the legacy version or to 'edgechromium' for the new Chromium-based version. Please note, when using the built-in BrowserType enum, then the values are BrowserType.EDGE_LEGACY and BrowserType.EDGE_CHROMIUM, respectively.";
+export declare const outdatedSdkVersionWarning: (options: {
+    name: string;
+    currentVersion: string;
+    latestVersion: string;
+}) => string;
+export declare const requestedEnvironmentSmallerThenBreakpointWarning: (options: {
+    breakpoint: number;
+    browsers: {
+        name: string;
+        width: number;
+    }[];
+}) => string;
+export declare const breakpointOutOfDriverBoundsWarning: (options: {
+    requiredWidth: number;
+    actualWidth: number;
+    browsers: {
+        name: string;
+        width: number;
+    }[];
+}) => string;
+export declare const requestedEnvironmentOutOfDriverBoundsWarning: (options: {
+    requiredWidth: number;
+    actualWidth: number;
+    browsers: {
+        name: string;
+    }[];
+}) => string;
+export declare const applitoolsLibConflictingCapabilitiesWarning: (options: {
+    conflictingCapabilities: Record<string, any>;
+}) => string;

package/types/locate-text.d.ts

@@ -6,7 +6,7 @@ type Options<TSpec extends SpecType> = {
     core: Core<TSpec>;
     logger: Logger;
 };
-export declare function makeLocateText<TSpec extends SpecType>({ spec, core, logger: defaultLogger }: Options<TSpec>): <TPattern extends string>({ target, settings, config, logger, }: {
+export declare function makeLocateText<TSpec extends SpecType>({ spec, core, logger: mainLogger }: Options<TSpec>): <TPattern extends string>({ target, settings, config, logger, }: {
     target: Target<TSpec, 'classic'>;
     settings: LocateTextSettings<TPattern, TSpec>;
     config?: Config<TSpec, "classic"> | undefined;

package/types/locate.d.ts

@@ -7,7 +7,7 @@ type Options<TSpec extends SpecType> = {
     core: Core<TSpec>;
     logger: Logger;
 };
-export declare function makeLocate<TSpec extends SpecType>({ spec, core, logger: defaultLogger }: Options<TSpec>): <TLocator extends string>({ target, settings, config, logger, }: {
+export declare function makeLocate<TSpec extends SpecType>({ spec, core, logger: mainLogger }: Options<TSpec>): <TLocator extends string>({ target, settings, config, logger, }: {
     target: Target<TSpec, 'classic'>;
     settings: LocateSettings<TLocator, TSpec>;
     config?: Config<TSpec, "classic"> | undefined;

package/types/make-manager.d.ts

@@ -1,17 +1,26 @@
 import type { Core, EyesManager, ManagerSettings } from './types';
 import type { Core as BaseCore } from '@applitools/core-base';
+import { type AsyncCache, 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>;
-    concurrency?: number;
+    clients?: {
+        ufg?: UFGClient;
+        nml?: NMLClient;
+    };
     core: Core<TSpec>;
     base?: BaseCore;
     agentId?: string;
+    environment?: Record<string, any>;
     cwd?: string;
     logger: Logger;
+    asyncCache?: AsyncCache;
+    offlineLocationPath?: string;
+    maskLog?: boolean;
 };
-export declare function makeMakeManager<TSpec extends SpecType>({ spec, concurrency: defaultConcurrency, core, base, agentId: defaultAgentId, cwd, logger: defaultLogger, }: Options<TSpec>): <TType extends "classic" | "ufg" = "classic">({ type, settings, logger, }?: {
+export declare function makeMakeManager<TSpec extends SpecType>({ spec, clients, core, base: defaultBase, agentId: defaultAgentId, environment, cwd, logger: mainLogger, asyncCache, offlineLocationPath, maskLog, }: Options<TSpec>): <TType extends "classic" | "ufg" = "classic">({ type, settings, logger, }?: {
     type?: TType | undefined;
     settings?: ManagerSettings | undefined;
     logger?: Logger | undefined;

package/types/offline/merge-configs.d.ts

@@ -0,0 +1 @@
+export declare function mergeConfigs<TBase extends Record<string, any>>(base: TBase, other: Record<string, any>): TBase;

package/types/offline/run-offline-snapshots.d.ts

@@ -0,0 +1,11 @@
+import { Config, type EyesServerSettings } from '../types';
+import { type Logger } from '@applitools/logger';
+import type { TestResult } from '@applitools/core-base';
+import type { SpecType } from '@applitools/driver';
+export type OfflineSnapshotsSettings = EyesServerSettings & {
+    offlineLocationPath: string;
+    failOnDiff: boolean;
+    config: Config<SpecType, 'ufg'>;
+    logger?: Logger;
+};
+export declare function runOfflineSnapshots(options: OfflineSnapshotsSettings): Promise<TestResult[]>;

package/types/open-eyes.d.ts

@@ -1,18 +1,27 @@
 import type { DriverTarget, Core, TypedCore, Batch, Eyes, Config, OpenSettings } from './types';
+import { type AsyncCache, 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;
-    concurrency?: number;
+    clients?: {
+        ufg?: UFGClient;
+        nml?: NMLClient;
+    };
     batch?: Batch;
+    removeDuplicateTests?: boolean;
     core: Core<TSpec, TType>;
     cores?: {
         [TKey in 'classic' | 'ufg']: TypedCore<TSpec, TKey>;
     };
     spec?: SpecDriver<TSpec>;
+    environment?: Record<string, any>;
     logger: Logger;
+    asyncCache?: AsyncCache;
+    cwd?: string;
 };
-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, }: {
+export declare function makeOpenEyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg' = 'classic'>({ type: defaultType, clients, batch, removeDuplicateTests, core, cores, spec, environment, logger: mainLogger, asyncCache, cwd, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, settings: openSettings, config, target, logger, }: {
     type?: TType | undefined;
     settings?: Partial<OpenSettings<TDefaultType> & OpenSettings<TType>> | undefined;
     config?: (Config<TSpec, TDefaultType> & Config<TSpec, TType>) | undefined;

package/types/run-offline-snapshots.d.ts

@@ -0,0 +1,6 @@
+import { type EyesServerSettings } from './types';
+export type OfflineSnapshotsSettings = EyesServerSettings & {
+    offlineLocationPath: string;
+    failOnDiff: boolean;
+};
+export declare function runOfflineSnapshots(options: OfflineSnapshotsSettings): Promise<void>;

package/types/troubleshoot/logs.d.ts

@@ -0,0 +1,25 @@
+interface Log {
+    label?: string;
+    tags?: string[][];
+    timestamp?: string;
+    level?: string;
+    message: string;
+}
+interface GroupedLog<TGroupedLog extends GroupedLog<TGroupedLog>> {
+    [key: string]: TGroupedLog;
+}
+type StructuredLog = GroupedLog<StructuredLog> & {
+    logs?: Log[];
+};
+type AnalyzedLog = GroupedLog<AnalyzedLog> & {
+    logs?: string[];
+    startedAt: number;
+    finishedAt: number;
+    time: number;
+    conclusion: string;
+};
+export declare function parseLogs(logs: string): Log[];
+export declare function stringifyLog(log: Log): string;
+export declare function structureLogs(logs: Log[]): StructuredLog;
+export declare function analyzeLogs({ logs, ...groups }: StructuredLog): AnalyzedLog;
+export {};

package/types/types.d.ts

@@ -1,12 +1,12 @@
 import type { MaybeArray } from '@applitools/utils';
+import type * as BaseCore from '@applitools/core-base/types';
 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';
 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>;
@@ -46,8 +46,16 @@ export interface Core<TSpec extends SpecType, TDefaultType extends 'classic' | '
         config?: Config<TSpec, TDefaultType>;
         logger?: Logger;
     }): Promise<string[]>;
+    takeSnapshots?(options: {
+        driver: AutomationCore.DriverTarget<TSpec>;
+        settings?: UFGCore.SnapshotSettings<TSpec>;
+        account: BaseCore.Account;
+        logger?: Logger;
+    }): Promise<UFGCore.Snapshot[]>;
 }
 export interface EyesManager<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg' = 'classic' | 'ufg'> {
+    readonly concurrency: number | undefined;
+    readonly base: BaseCore.Core;
     openEyes<TType extends 'classic' | 'ufg' = TDefaultType>(options: {
         type?: TType;
         target?: AutomationCore.DriverTarget<TSpec>;
@@ -64,7 +72,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,14 +80,14 @@ 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>;
         settings?: Partial<CheckSettings<TSpec, TDefaultType> & CloseSettings<TDefaultType> & CheckSettings<TSpec, TType> & CloseSettings<TType>>;
         config?: Config<TSpec, TDefaultType> & Config<TSpec, TType>;
         logger?: Logger;
-    }): Promise<TestResult<TType>[]>;
+    }): Promise<void>;
     close(options?: {
         settings?: Partial<CloseSettings<TDefaultType>>;
         config?: Config<TSpec, TDefaultType>;
@@ -99,15 +106,17 @@ export interface Eyes<TSpec extends SpecType, TDefaultType extends 'classic' | '
 }
 export interface ManagerSettings {
     concurrency?: number;
+    fetchConcurrency?: number;
     /** @deprecated */
     legacyConcurrency?: number;
-    agentId?: string;
     batch?: AutomationCore.Batch;
+    agentId?: string;
+    removeDuplicateTests?: boolean;
 }
 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'>>;
+    screenshot: Partial<Omit<AutomationCore.ScreenshotSettings<TSpec>, 'userCommandId'>>;
+    check: Partial<Omit<CheckSettings<TSpec, TType>, 'userCommandId'>>;
     close: Partial<Omit<CloseSettings<TType>, 'userCommandId'>>;
 };
 export type OpenSettings<TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.OpenSettings : ClassicCore.OpenSettings;
@@ -121,12 +130,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 error?: unknown;
     readonly result?: TestResult<TType>;
-    readonly renderer?: TType extends 'ufg' ? Renderer : never;
+    readonly environment: AutomationCore.ExactEnvironment;
     readonly userTestId?: string;
 }
 export interface TestResultSummary<TType extends 'classic' | 'ufg'> {

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

@@ -1,31 +1,39 @@
-import type { Region } from '@applitools/utils';
-import type { DriverTarget, Target, Eyes, CheckSettings, TestResult, CloseSettings } from './types';
+import type { DriverTarget, Target, Eyes, CheckSettings, CloseSettings, Environment } from './types';
 import { type AbortSignal } from 'abort-controller';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
+import * as utils from '@applitools/utils';
 type Options<TSpec extends SpecType> = {
     eyes: Eyes<TSpec>;
     target?: DriverTarget<TSpec>;
+    environments?: Environment[];
     spec?: SpecDriver<TSpec>;
     signal?: AbortSignal;
     logger: Logger;
 };
-export declare function makeCheckAndClose<TSpec extends SpecType>({ eyes, target: defaultTarget, spec, signal, logger: defaultLogger, }: Options<TSpec>): ({ target, settings, logger, }: {
+export declare function makeCheckAndClose<TSpec extends SpecType>({ eyes, target: defaultTarget, environments: defaultEnvironments, 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?: import("@applitools/ufg-client").Renderer[] | undefined;
+    settings?: (import("@applitools/core-base").CheckSettings<utils.Region | import("@applitools/driver").ElementReference<TSpec>> & import("./types").ScreenshotSettings<TSpec> & {
+        environments?: Environment[] | undefined;
+    } & {
+        disableBrowserFetching?: boolean | undefined;
+        layoutBreakpoints?: {
+            breakpoints: boolean | number[];
+            reload?: boolean | undefined;
+        } | undefined;
         hooks?: {
             beforeCaptureScreenshot: string;
         } | undefined;
-        disableBrowserFetching?: boolean | undefined;
-        layoutBreakpoints?: boolean | number[] | undefined;
         ufgOptions?: Record<string, any> | undefined;
-        nmgOptions?: Record<string, any> | undefined;
+        prefixRenderId?: string | undefined;
         autProxy?: (import("@applitools/req").Proxy & {
             mode?: "Allow" | "Block" | undefined;
             domains?: string[] | undefined;
         }) | undefined;
-    } & CloseSettings) | undefined;
+        headers?: Record<string, string> | undefined;
+    } & import("@applitools/core-base").CloseSettings & {
+        environments?: Environment[] | undefined;
+    }) | undefined;
     logger?: Logger | undefined;
-}) => Promise<TestResult[]>;
+}) => Promise<void>;
 export {};

package/types/ufg/check.d.ts

@@ -1,17 +1,18 @@
-import type { DriverTarget, Target, Eyes, CheckSettings, CheckResult } from './types';
+import type { DriverTarget, Target, Eyes, CheckSettings, Environment } 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>;
     target?: DriverTarget<TSpec>;
+    environments?: Environment[];
     spec?: SpecDriver<TSpec>;
     signal?: AbortSignal;
     logger: Logger;
 };
-export declare function makeCheck<TSpec extends SpecType>({ eyes, target: defaultTarget, spec, signal, logger: defaultLogger, }: Options<TSpec>): ({ target, settings, logger, }: {
-    settings?: CheckSettings<TSpec> | undefined;
+export declare function makeCheck<TSpec extends SpecType>({ eyes, target: defaultTarget, environments: defaultEnvironments, spec, signal, logger: mainLogger, }: Options<TSpec>): ({ target, settings, logger, }?: {
     target?: Target<TSpec> | undefined;
+    settings?: CheckSettings<TSpec> | undefined;
     logger?: Logger | undefined;
-}) => Promise<CheckResult[]>;
+}) => Promise<void>;
 export {};