@applitools/core 2.5.2 → 2.5.3-legacy

package/types/automation/extract-text.d.ts

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

package/types/automation/get-nml-client.d.ts

@@ -0,0 +1,16 @@
+import { type SpecType, type Driver } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+import { type NMLClient, type NMLClientSettings } from '@applitools/nml-client';
+type Options = {
+    client?: NMLClient;
+    logger: Logger;
+};
+export declare function makeGetNMLClient({ client, logger: mainLogger }: Options): {
+    getNMLClient: ({ driver, settings, logger, }: {
+        driver: Driver<SpecType>;
+        settings: Omit<NMLClientSettings, 'brokerUrl'>;
+        logger: Logger;
+    }) => Promise<NMLClient>;
+    clearNMLClientCache: (driver: Driver<SpecType>) => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,11 @@
+import type { Eyes, GetResultsSettings, TestResult } from '../ufg/types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    eyes: Eyes<any>;
+    logger: Logger;
+};
+export declare function makeGetResults({ eyes, logger: mainLogger }: Options): ({ settings, logger, }?: {
+    settings?: GetResultsSettings | undefined;
+    logger?: Logger | undefined;
+}) => Promise<TestResult[]>;
+export {};

package/types/automation/get-viewport-size.d.ts

@@ -5,7 +5,7 @@ type Options<TSpec extends SpecType> = {
     spec: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeGetViewportSize<TSpec extends SpecType>({ spec, logger: defaultLogger }: Options<TSpec>): ({ target, logger, }: {
+export declare function makeGetViewportSize<TSpec extends SpecType>({ spec, logger: mainLogger }: Options<TSpec>): ({ target, logger }: {
     target: DriverTarget<TSpec>;
     logger?: Logger | undefined;
 }) => Promise<import("@applitools/utils").Size>;

package/types/automation/locate-text.d.ts

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

package/types/automation/locate.d.ts

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

package/types/automation/set-viewport-size.d.ts

@@ -6,7 +6,7 @@ type Options<TSpec extends SpecType> = {
     spec: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeSetViewportSize<TSpec extends SpecType>({ spec, logger: defaultLogger }: Options<TSpec>): ({ target, size, logger, }: {
+export declare function makeSetViewportSize<TSpec extends SpecType>({ spec, logger: mainLogger }: Options<TSpec>): ({ target, size, logger, }: {
     target: DriverTarget<TSpec>;
     size: Size;
     logger?: Logger | undefined;

package/types/automation/types.d.ts

@@ -1,11 +1,52 @@
-import type { MaybeArray, Size, Region } from '@applitools/utils';
+import type { MaybeArray, Size, Region, ControlledPromise } from '@applitools/utils';
 import type * as BaseCore from '@applitools/core-base/types';
 import { type SpecType, type Driver, type ElementReference, type ContextReference } from '@applitools/driver';
+import { type NMLClient, type NMLClientSettings } from '@applitools/nml-client';
 import { type Logger } from '@applitools/logger';
-export * from '@applitools/core-base/types';
+export type * from '@applitools/core-base/types';
 export type DriverTarget<TSpec extends SpecType> = TSpec['driver'] | Driver<TSpec>;
 export type Target<TSpec extends SpecType> = DriverTarget<TSpec> | BaseCore.Target;
-export interface Core<TSpec extends SpecType> extends BaseCore.Core {
+export interface DesktopBrowserEnvironment {
+    name?: string;
+    width: number;
+    height: number;
+}
+export interface ChromeEmulationDeviceEnvironment {
+    chromeEmulationInfo: {
+        deviceName: string;
+        screenOrientation?: string;
+    };
+}
+export interface IOSDeviceEnvironment {
+    iosDeviceInfo: {
+        deviceName: string;
+        version?: string;
+        screenOrientation?: string;
+    };
+}
+export interface AndroidDeviceEnvironment {
+    androidDeviceInfo: {
+        deviceName: string;
+        version?: string;
+        screenOrientation?: string;
+    };
+}
+export type RenderEnvironment = (DesktopBrowserEnvironment | ChromeEmulationDeviceEnvironment | IOSDeviceEnvironment | AndroidDeviceEnvironment) & {
+    environmentId?: string;
+    os?: string;
+    displayOs?: string;
+    hostingApp?: string;
+    displayHostingApp?: string;
+    properties?: BaseCore.CustomProperty[];
+    fallbackBaselineId?: string;
+};
+export type ExactEnvironment = BaseCore.Environment & {
+    environmentId?: string;
+    requested?: RenderEnvironment;
+    fallbackBaselineId?: string;
+};
+export type Environment = RenderEnvironment | ExactEnvironment;
+export interface Core<TSpec extends SpecType> extends Omit<BaseCore.Core, 'openEyes'> {
     readonly base: BaseCore.Core;
     getViewportSize?(options: {
         target: DriverTarget<TSpec>;
@@ -16,10 +57,16 @@ export interface Core<TSpec extends SpecType> extends BaseCore.Core {
         size: Size;
         logger?: Logger;
     }): Promise<void>;
+    getNMLClient(options: {
+        settings: Omit<NMLClientSettings, 'brokerUrl'>;
+        driver: Driver<TSpec>;
+        logger: Logger;
+    }): Promise<NMLClient>;
+    clearNMLClientCache(driver: Driver<TSpec>): Promise<void>;
     openEyes(options: {
         target?: DriverTarget<TSpec>;
         settings: BaseCore.OpenSettings;
-        base?: BaseCore.Eyes[];
+        storage?: EyesStorage;
         logger?: Logger;
     }): Promise<Eyes<TSpec>>;
     locate<TLocator extends string>(options: {
@@ -38,23 +85,54 @@ export interface Core<TSpec extends SpecType> extends BaseCore.Core {
         logger?: Logger;
     }): Promise<string[]>;
 }
-export interface Eyes<TSpec extends SpecType> extends BaseCore.Eyes {
+export interface Eyes<TSpec extends SpecType> extends Omit<BaseCore.Eyes, 'core' | 'check' | 'checkAndClose'> {
     readonly core: Core<TSpec>;
-    getBaseEyes(options?: {
+    readonly storage: EyesStorage;
+    getBaseEyes(options: {
+        settings: GetBaseEyesSettings<TSpec>;
         logger?: Logger;
-    }): Promise<BaseCore.Eyes[]>;
+    }): Promise<BaseCore.Eyes>;
     check(options?: {
         target?: Target<TSpec>;
         settings?: CheckSettings<TSpec>;
         logger?: Logger;
-    }): Promise<BaseCore.CheckResult[]>;
+    }): Promise<void>;
     checkAndClose(options?: {
         target?: Target<TSpec>;
         settings?: CheckSettings<TSpec> & BaseCore.CloseSettings;
         logger?: Logger;
-    }): Promise<BaseCore.TestResult[]>;
+    }): Promise<void>;
+    close(options?: {
+        settings?: CloseSettings;
+        logger?: Logger;
+    }): Promise<void>;
+    abort(options?: {
+        settings?: AbortSettings;
+        logger?: Logger;
+    }): Promise<void>;
+    getResults(options?: {
+        settings?: BaseCore.GetResultsSettings;
+        logger?: Logger;
+    }): Promise<TestResult[]>;
 }
+export type EyesStorage = Map<string, {
+    eyes: ControlledPromise<BaseCore.Eyes>;
+    jobs: Promise<void>[];
+}>;
+export interface GetBaseEyesSettings<TSpec extends SpecType> {
+    environment: Environment;
+    driver?: Driver<TSpec>;
+}
+export type LazyLoadOptions = {
+    scrollLength?: number;
+    waitingTime?: number;
+    maxAmountToScroll?: number;
+};
+export type MobileOptions = {
+    keepNavigationBar?: boolean;
+};
 export interface ScreenshotSettings<TSpec extends SpecType> extends BaseCore.ImageSettings<Region | ElementReference<TSpec>> {
+    webview?: boolean | string;
     frames?: (ContextReference<TSpec> | {
         frame: ContextReference<TSpec>;
         scrollRootElement?: ElementReference<TSpec>;
@@ -62,6 +140,7 @@ export interface ScreenshotSettings<TSpec extends SpecType> extends BaseCore.Ima
     fully?: boolean;
     scrollRootElement?: ElementReference<TSpec>;
     stitchMode?: 'Scroll' | 'CSS' | 'Resize';
+    screenshotMode?: 'default' | 'applitools-lib';
     hideScrollbars?: boolean;
     hideCaret?: boolean;
     overlap?: {
@@ -70,14 +149,26 @@ export interface ScreenshotSettings<TSpec extends SpecType> extends BaseCore.Ima
     };
     waitBeforeCapture?: number;
     waitBetweenStitches?: number;
-    lazyLoad?: boolean | {
-        scrollLength?: number;
-        waitingTime?: number;
-        maxAmountToScroll?: number;
-    };
-    webview?: boolean | string;
+    lazyLoad?: boolean | LazyLoadOptions;
+    sendDom?: boolean;
+    captureStatusBar?: boolean;
+    mobileOptions?: MobileOptions;
 }
 export type LocateSettings<TLocator extends string, TSpec extends SpecType> = BaseCore.LocateSettings<TLocator, Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
 export type LocateTextSettings<TPattern extends string, TSpec extends SpecType> = BaseCore.LocateTextSettings<TPattern, Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
 export type ExtractTextSettings<TSpec extends SpecType> = BaseCore.ExtractTextSettings<Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
-export type CheckSettings<TSpec extends SpecType> = BaseCore.CheckSettings<Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
+export type CheckSettings<TSpec extends SpecType> = BaseCore.CheckSettings<Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec> & {
+    environments?: Environment[];
+};
+export type CloseSettings = BaseCore.CloseSettings & {
+    environments?: Environment[];
+};
+export type AbortSettings = BaseCore.AbortSettings & {
+    environments?: Environment[];
+};
+export type TestResult = BaseCore.TestResult & {
+    readonly environment: ExactEnvironment;
+};
+export type OpenSettings = BaseCore.OpenSettings & {
+    disableBrokerUrlCache?: boolean;
+};

package/types/automation/utils/report-kobiton.d.ts

@@ -0,0 +1,12 @@
+import type { Driver, SpecType } from '@applitools/driver';
+import type { Logger } from '@applitools/logger';
+type Options<TSpec extends SpecType> = {
+    driver?: Driver<TSpec>;
+    settings: {
+        batchId: string;
+        resultsUrl: string;
+    };
+    logger: Logger;
+};
+export declare function reportKobiton<TSpec extends SpecType>({ driver, settings, logger }: Options<TSpec>): Promise<void>;
+export {};

package/types/automation/utils/take-screenshot.d.ts

@@ -1,14 +1,17 @@
 import type { Region } from '@applitools/utils';
 import type { ScreenshotSettings } from '../../classic/types';
 import { type Logger } from '@applitools/logger';
-import { type Driver, type Element, type ElementReference, type SpecType } from '@applitools/driver';
+import { type Driver, type Element, type ElementReference, type Selector, type SpecType } from '@applitools/driver';
 export type Screenshot<TSpec extends SpecType> = {
     image: any;
     region: Region;
     element: Element<TSpec>;
     scrollingElement: Element<TSpec>;
     restoreState(): Promise<void>;
-    calculatedRegions: [];
+    calculatedRegions: {
+        selector?: Selector;
+        regions: Region[];
+    }[];
 };
 export declare function takeScreenshot<TSpec extends SpecType>({ driver, settings, logger, }: {
     driver: Driver<TSpec>;

package/types/automation/utils/to-base-check-settings.d.ts

@@ -1,12 +1,22 @@
 import type { Region } from '@applitools/utils';
 import type { CheckSettings } from '../types';
 import type { CheckSettings as BaseCheckSettings } from '@applitools/core-base';
-import { type SpecType, type ElementReference, type Selector } from '@applitools/driver';
+import type { SpecType, ElementReference, Selector, Driver } from '@applitools/driver';
+import { Logger } from '@applitools/logger';
+export declare function hasCodedRegions<TSpec extends SpecType>(settings: CheckSettings<TSpec>): boolean;
+export declare function extractMobileElementsIntoCheckSettings<TSpec extends SpecType>({ settings, driver, logger, }: {
+    settings: CheckSettings<TSpec>;
+    driver: Driver<TSpec>;
+    logger: Logger;
+}): Promise<any>;
 export declare function toBaseCheckSettings<TSpec extends SpecType>({ settings }: {
     settings: CheckSettings<TSpec>;
 }): {
-    elementReferencesToCalculate: ElementReference<TSpec>[];
-    elementReferenceToTarget: ElementReference<TSpec> | undefined;
+    elementReferences: {
+        target: ElementReference<TSpec> | undefined;
+        scrolling: ElementReference<TSpec> | undefined;
+        calculate: ElementReference<TSpec>[];
+    };
     getBaseCheckSettings: ({ calculatedRegions, preserveTransformation, }: {
         calculatedRegions: {
             selector?: Selector;

package/types/automation/utils/to-environment-key.d.ts

@@ -0,0 +1,2 @@
+import type { Environment } from '../types';
+export declare function toEnvironmentKey(environment: Environment): string;

package/types/automation/utils/uniquify-environments.d.ts

@@ -0,0 +1,2 @@
+import type { Environment } from '../types';
+export declare function uniquifyEnvironments<TEnvironment extends Environment>(environments: TEnvironment[]): TEnvironment[];

package/types/automation/utils/wait-for-lazy-load.d.ts

@@ -1,14 +1,10 @@
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type Context } from '@applitools/driver';
-export type LazyLoadSettings = {
-    scrollLength?: number;
-    waitingTime?: number;
-    maxAmountToScroll?: number;
-    executionTimeout?: number;
-    pollTimeout?: number;
-};
+import { type LazyLoadOptions } from '../types';
 export declare function waitForLazyLoad<TSpec extends SpecType>({ context, settings, logger, }: {
     context: Context<TSpec>;
-    settings: LazyLoadSettings;
+    settings?: LazyLoadOptions & {
+        pollTimeout?: number;
+    };
     logger: Logger;
 }): Promise<void>;

package/types/autonomous/core.d.ts

@@ -0,0 +1,19 @@
+import type { AutonomousCore } from './types';
+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';
+import { type Core as BaseCore } from '@applitools/core-base';
+type Options<TSpec extends SpecType> = {
+    spec?: SpecDriver<TSpec>;
+    clients?: {
+        ufg?: UFGClient;
+        nml?: NMLClient;
+    };
+    base?: BaseCore;
+    asyncCache?: AsyncCache;
+    agentId?: string;
+    logger?: Logger;
+};
+export declare function makeAutonomousCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, asyncCache, agentId, logger: defaultLogger, }?: Options<TSpec>): AutonomousCore<TSpec>;
+export {};

package/types/autonomous/create-render-results.d.ts

@@ -0,0 +1,10 @@
+import type { StartedRender, RenderResult } from './types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    logger: Logger;
+};
+export declare function makeCreateRenderResults({ logger }: Options): ({ renders, rawResults, }: {
+    renders: StartedRender[];
+    rawResults: any[];
+}) => Promise<RenderResult[]>;
+export {};

package/types/autonomous/create-render-target.d.ts

@@ -0,0 +1,12 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { Snapshot, RenderTargetWithSettings } from './types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: UFGCore<any>;
+    logger: Logger;
+};
+export declare function makeCreateRenderTarget({ core, logger: defaultLogger }: Options): ({ snapshot, logger, }: {
+    snapshot: Snapshot;
+    logger: Logger;
+}) => Promise<RenderTargetWithSettings>;
+export {};

package/types/autonomous/get-render-results.d.ts

@@ -0,0 +1,12 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { StartedRender, RenderResult } from './types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: UFGCore<any>;
+    logger: Logger;
+};
+export declare function makeGetRenderResults({ core, logger: defaultLogger }: Options): ({ renders, logger, }: {
+    renders: StartedRender[];
+    logger: Logger;
+}) => Promise<RenderResult[]>;
+export {};

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

@@ -0,0 +1,13 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { OpenSettings } from './types';
+import type { Eyes as BaseEyes } from '@applitools/core-base/types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: UFGCore<any>;
+    logger: Logger;
+};
+export declare function makeOpenEyes({ core, logger: defaultLogger }: Options): ({ settings, logger, }: {
+    settings: OpenSettings;
+    logger: Logger;
+}) => Promise<BaseEyes>;
+export {};

package/types/autonomous/start-renders.d.ts

@@ -0,0 +1,12 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { RenderTargetWithSettings, StartedRender } from './types';
+import { type Logger } from '@applitools/logger';
+type Options = {
+    core: UFGCore<any>;
+    logger: Logger;
+};
+export declare function makeStartRenders({ core, logger: defaultLogger }: Options): ({ targets, logger, }: {
+    targets: RenderTargetWithSettings[];
+    logger: Logger;
+}) => Promise<StartedRender[]>;
+export {};

package/types/autonomous/take-snapshots.d.ts

@@ -0,0 +1,15 @@
+import type { Core as UFGCore } from '../ufg/types';
+import type { DriverTarget, SnapshotSettings, Snapshot } from './types';
+import { type Logger } from '@applitools/logger';
+import { type SpecDriver, type SpecType } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    core: UFGCore<TSpec>;
+    spec: SpecDriver<TSpec>;
+    logger: Logger;
+};
+export declare function makeTakeSnapshots<TSpec extends SpecType>({ core, spec, logger: defaultLogger }: Options<TSpec>): ({ target, settings, logger, }: {
+    target: DriverTarget<TSpec>;
+    settings: SnapshotSettings<TSpec>;
+    logger?: Logger | undefined;
+}) => Promise<Snapshot[]>;
+export {};

package/types/autonomous/types.d.ts

@@ -0,0 +1,57 @@
+import type { Eyes as BaseEyes, ImageTarget as BaseImageTarget, OpenSettings as BaseOpenSettings, CheckSettings as BaseCheckSettings } from '@applitools/core-base/types';
+import type * as UFGCore from '../ufg/types';
+import { type Logger } from '@applitools/logger';
+import { type SpecType } from '@applitools/driver';
+import { type RenderTarget, type StartedRender as UFGStartedRender } from '@applitools/ufg-client';
+export * from '../ufg/types';
+export interface AutonomousCore<TSpec extends SpecType> {
+    readonly type: 'autonomous';
+    takeSnapshots?(options: {
+        target: UFGCore.DriverTarget<TSpec>;
+        settings?: Partial<SnapshotSettings<TSpec>>;
+        logger?: Logger;
+    }): Promise<UFGCore.Snapshot[]>;
+    createRenderTarget(options: {
+        snapshot: UFGCore.Snapshot;
+        logger?: Logger;
+    }): Promise<RenderTargetWithSettings>;
+    startRenders(options: {
+        targets: RenderTargetWithSettings[];
+        logger?: Logger;
+    }): Promise<StartedRender[]>;
+    getRenderResults(options: {
+        renders: StartedRender[];
+        logger?: Logger;
+    }): Promise<RenderResult[]>;
+    createRenderResults(options: {
+        renders: StartedRender[];
+        rawResults: any[];
+        logger?: Logger;
+    }): Promise<RenderResult[]>;
+    openEyes(options: {
+        settings: Partial<OpenSettings>;
+        logger?: Logger;
+    }): Promise<BaseEyes>;
+}
+export type SnapshotSettings<TSpec extends SpecType> = UFGCore.SnapshotSettings<TSpec> & UFGCore.EyesServerSettings;
+export type RenderTargetWithSettings = {
+    target: RenderTarget;
+    settings: UFGCore.SafeCheckSettings;
+    environment: UFGCore.RenderEnvironment;
+    account: UFGCore.Account;
+};
+export type StartedRender = {
+    render: UFGStartedRender;
+    settings: UFGCore.SafeCheckSettings;
+    environment: UFGCore.ExactEnvironment;
+    account: UFGCore.Account;
+};
+export type RenderResult = {
+    status: 'rendering' | 'rendered' | 'error';
+    error: string;
+    target: BaseImageTarget;
+    settings: BaseCheckSettings;
+    environment: UFGCore.ExactEnvironment;
+    account: UFGCore.Account;
+};
+export type OpenSettings = BaseOpenSettings;

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

@@ -1,4 +1,4 @@
-import type { Target, DriverTarget, Eyes, Config, CheckSettings, CloseSettings, TestResult } from './types';
+import type { Target, DriverTarget, Eyes, Config, CheckSettings, CloseSettings } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
@@ -8,11 +8,11 @@ type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeCheckAndClose<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, target, settings, config, logger, }?: {
+export declare function makeCheckAndClose<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, eyes, target: defaultTarget, spec, logger: mainLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, target, settings, config, logger, }?: {
     type?: TType | undefined;
     target?: Target<TSpec, TType> | undefined;
     settings?: (CheckSettings<TSpec, TDefaultType> & CloseSettings<TDefaultType> & CheckSettings<TSpec, TType> & CloseSettings<TType>) | undefined;
     config?: (Config<TSpec, TDefaultType> & Config<TSpec, TType>) | undefined;
     logger?: Logger | undefined;
-}) => Promise<TestResult<TType>[]>;
+}) => Promise<void>;
 export {};

package/types/check.d.ts

@@ -1,4 +1,4 @@
-import type { Target, DriverTarget, Eyes, Config, CheckSettings, CheckResult } from './types';
+import type { Target, DriverTarget, Eyes, Config, CheckSettings } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
@@ -8,11 +8,11 @@ type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeCheck<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, eyes, target: defaultTarget, spec, logger: defaultLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, target, settings, config, logger, }?: {
+export declare function makeCheck<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, eyes, target: defaultTarget, spec, logger: mainLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, target, settings, config, logger, }?: {
     type?: TType | undefined;
     target?: Target<TSpec, TType> | undefined;
     settings?: CheckSettings<TSpec, TType> | undefined;
     config?: Config<TSpec, TType> | undefined;
     logger?: Logger | undefined;
-}) => Promise<CheckResult<TType>[]>;
+}) => Promise<void>;
 export {};

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

@@ -1,19 +1,26 @@
-import type { Target, DriverTarget, Eyes, CheckSettings, CloseSettings, TestResult } from './types';
-import type { CheckSettings as BaseCheckSettings } from '@applitools/core-base';
+import type { Target, DriverTarget, Eyes, CheckSettings, CloseSettings, Environment } from './types';
+import type { CheckSettings as BaseCheckSettings, CloseSettings as BaseCloseSettings } from '@applitools/core-base';
+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, 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?: (BaseCheckSettings<utils.Region | import("@applitools/driver").ElementReference<TSpec>> & import("./types").ScreenshotSettings<TSpec> & {
+        environments?: Environment[] | undefined;
+    } & {
         retryTimeout?: number | undefined;
-    } & CloseSettings) | undefined;
+    } & BaseCloseSettings & {
+        environments?: Environment[] | undefined;
+    }) | undefined;
     logger?: Logger | undefined;
-}) => Promise<TestResult[]>;
+}) => Promise<void>;
 export {};

package/types/classic/check.d.ts

@@ -1,15 +1,18 @@
-import type { Target, DriverTarget, Eyes, CheckSettings, CheckResult } from './types';
+import type { Target, DriverTarget, 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, logger: defaultLogger, }: Options<TSpec>): ({ target, settings, logger, }?: {
+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 {};

package/types/classic/core.d.ts

@@ -1,13 +1,19 @@
 import type { Core } from './types';
+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?: {
+        nml?: NMLClient;
+    };
     base?: BaseCore;
+    concurrency?: number;
     agentId?: string;
-    cwd?: string;
     logger?: Logger;
+    offlineLocationPath?: string;
+    maskLog?: boolean;
 };
-export declare function makeCore<TSpec extends SpecType>({ spec, base, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
+export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, concurrency, agentId, logger: defaultLogger, maskLog, offlineLocationPath, }: Options<TSpec>): Core<TSpec>;
 export {};