@applitools/eyes 1.33.3 → 1.34.0

package/types/enums/IosMultiDeviceTarget.d.ts

@@ -0,0 +1,26 @@
+export declare enum IosMultiDeviceTargetEnum {
+    iPhone_SE_3 = "iPhone SE (3rd generation)",
+    iPhone_SE_2 = "iPhone SE (2nd generation)",
+    iPhone_8 = "iPhone 8",
+    iPhone_8_Plus = "iPhone 8 Plus",
+    iPhone_13_mini = "iPhone 13 mini",
+    iPhone_12_mini = "iPhone 12 mini",
+    iPhone_11_Pro = "iPhone 11 Pro",
+    iPhone_X = "iPhone X",
+    iPhone_XR = "iPhone XR",
+    iPhone_Xs = "iPhone Xs",
+    iPhone_Xs_Max = "iPhone Xs Max",
+    iPhone_11 = "iPhone 11",
+    iPhone_11_Pro_Max = "iPhone 11 Pro Max",
+    iPhone_12 = "iPhone 12",
+    iPhone_12_Pro = "iPhone 12 Pro",
+    iPhone_12_Pro_Max = "iPhone 12 Pro Max",
+    iPhone_13 = "iPhone 13",
+    iPhone_13_Pro = "iPhone 13 Pro",
+    iPhone_13_Pro_Max = "iPhone 13 Pro Max",
+    iPhone_14 = "iPhone 14",
+    iPhone_14_Pro = "iPhone 14 Pro",
+    iPhone_14_Plus = "iPhone 14 Plus",
+    iPhone_14_Pro_Max = "iPhone 14 Pro Max"
+}
+export type IosMultiDeviceTarget = `${IosMultiDeviceTargetEnum}`;

package/types/enums/IosVersion.d.ts

@@ -0,0 +1,7 @@
+export declare enum IosVersionEnum {
+    LATEST = "latest",
+    ONE_VERSION_BACK = "latest-1",
+    /** @deprecated */
+    LATEST_ONE_VERSION_BACK = "latest-1"
+}
+export type IosVersion = `${IosVersionEnum}`;

package/types/enums/MatchLevel.d.ts

@@ -0,0 +1,12 @@
+export declare enum MatchLevelEnum {
+    None = "None",
+    LegacyLayout = "Layout1",
+    Layout = "Layout",
+    Layout2 = "Layout2",
+    Content = "Content",
+    IgnoreColors = "IgnoreColors",
+    Strict = "Strict",
+    Dynamic = "Dynamic",
+    Exact = "Exact"
+}
+export type MatchLevel = `${MatchLevelEnum}`;

package/types/enums/ScreenOrientation.d.ts

@@ -0,0 +1,5 @@
+export declare enum ScreenOrientationEnum {
+    PORTRAIT = "portrait",
+    LANDSCAPE = "landscape"
+}
+export type ScreenOrientation = `${ScreenOrientationEnum}`;

package/types/enums/SessionType.d.ts

@@ -0,0 +1,5 @@
+export declare enum SessionTypeEnum {
+    SEQUENTIAL = "SEQUENTIAL",
+    PROGRESSION = "PROGRESSION"
+}
+export type SessionType = `${SessionTypeEnum}`;

package/types/enums/StitchMode.d.ts

@@ -0,0 +1,8 @@
+export declare enum StitchModeEnum {
+    SCROLL = "Scroll",
+    Scroll = "Scroll",
+    CSS = "CSS",
+    RESIZE = "Resize",
+    Resize = "Resize"
+}
+export type StitchMode = `${StitchModeEnum}`;

package/types/enums/TestResultsStatus.d.ts

@@ -0,0 +1,6 @@
+export declare enum TestResultsStatusEnum {
+    Passed = "Passed",
+    Unresolved = "Unresolved",
+    Failed = "Failed"
+}
+export type TestResultsStatus = `${TestResultsStatusEnum}`;

package/types/errors/DiffsFoundError.d.ts

@@ -0,0 +1,6 @@
+import { TestFailedError } from './TestFailedError';
+import { TestResults } from '../output/TestResults';
+export declare class DiffsFoundError extends TestFailedError {
+    constructor(message: string, results?: TestResults);
+    constructor(results: TestResults);
+}

package/types/errors/EyesError.d.ts

@@ -0,0 +1,2 @@
+export declare class EyesError extends Error {
+}

package/types/errors/NewTestError.d.ts

@@ -0,0 +1,6 @@
+import { TestFailedError } from './TestFailedError';
+import { TestResults } from '../output/TestResults';
+export declare class NewTestError extends TestFailedError {
+    constructor(message: string, results?: TestResults);
+    constructor(results: TestResults);
+}

package/types/errors/TestFailedError.d.ts

@@ -0,0 +1,9 @@
+import { EyesError } from './EyesError';
+import { TestResults, TestResultsData } from '../output/TestResults';
+export declare class TestFailedError extends EyesError {
+    private _result;
+    constructor(message: string, results: TestResults);
+    constructor(results: TestResults);
+    get testResults(): TestResults;
+    getTestResults(): TestResultsData;
+}

package/types/index.d.ts

@@ -0,0 +1,60 @@
+export { BrowserType as BrowserTypePlain, BrowserTypeEnum as BrowserType } from './enums/BrowserType';
+export { CorsIframeHandle as CorsIframeHandlePlain, CorsIframeHandleEnum as CorsIframeHandle, } from './enums/CorsIframeHandle';
+export { DeviceName as DeviceNamePlain, DeviceNameEnum as DeviceName } from './enums/DeviceName';
+export { FailureReport as FailureReportPlain, FailureReportEnum as FailureReport } from './enums/FailureReport';
+export { IosDeviceName as IosDeviceNamePlain, IosDeviceNameEnum as IosDeviceName } from './enums/IosDeviceName';
+export { IosVersion as IosVersionPlain, IosVersionEnum as IosVersion } from './enums/IosVersion';
+export { MatchLevel as MatchLevelPlain, MatchLevelEnum as MatchLevel } from './enums/MatchLevel';
+export { ScreenOrientation as ScreenOrientationPlain, ScreenOrientationEnum as ScreenOrientation, } from './enums/ScreenOrientation';
+export { SessionType as SessionTypePlain, SessionTypeEnum as SessionType } from './enums/SessionType';
+export { StitchMode as StitchModePlain, StitchModeEnum as StitchMode } from './enums/StitchMode';
+export { TestResultsStatus as TestResultsStatusPlain, TestResultsStatusEnum as TestResultsStatus, } from './enums/TestResultsStatus';
+export { AccessibilityGuidelinesVersion as AccessibilityGuidelinesVersionPlain, AccessibilityGuidelinesVersionEnum as AccessibilityGuidelinesVersion, } from './enums/AccessibilityGuidelinesVersion';
+export { AccessibilityLevel as AccessibilityLevelPlain, AccessibilityLevelEnum as AccessibilityLevel, } from './enums/AccessibilityLevel';
+export { AccessibilityRegionType as AccessibilityRegionTypePlain, AccessibilityRegionTypeEnum as AccessibilityRegionType, } from './enums/AccessibilityRegionType';
+export { AccessibilityStatus as AccessibilityStatusPlain, AccessibilityStatusEnum as AccessibilityStatus, } from './enums/AccessibilityStatus';
+export { DynamicTextType as DynamicTextTypePlain, DynamicTextTypeEnum as DynamicTextType } from './enums/DynamicTextType';
+export { EyesError } from './errors/EyesError';
+export { TestFailedError } from './errors/TestFailedError';
+export { DiffsFoundError } from './errors/DiffsFoundError';
+export { NewTestError } from './errors/NewTestError';
+export { AccessibilityMatchSettings as AccessibilityMatchSettingsPlain, AccessibilityMatchSettingsData as AccessibilityMatchSettings, } from './input/AccessibilityMatchSettings';
+export { AccessibilitySettings } from './input/AccessibilitySettings';
+export { BatchInfo as BatchInfoPlain, BatchInfoData as BatchInfo } from './input/BatchInfo';
+export { Image } from './input/Image';
+export { CheckSettingsImage as CheckSettingsImagePlain, CheckSettingsImageFluent as CheckSettingsImage, CheckSettingsAutomation as CheckSettingsAutomationPlain, CheckSettingsAutomationFluent as CheckSettingsAutomation, TargetImage, TargetAutomation, Target, } from './input/CheckSettings';
+export { Configuration as ConfigurationPlain, ConfigurationData as Configuration } from './input/Configuration';
+export { CutProvider as CutProviderPlain, CutProviderData as CutProvider, FixedCutProviderData as FixedCutProvider, UnscaledFixedCutProviderData as UnscaledFixedCutProvider, } from './input/CutProvider';
+export { ExactMatchSettings as ExactMatchSettingsPlain, ExactMatchSettingsData as ExactMatchSettings, } from './input/ExactMatchSettings';
+export { FloatingMatchSettings as FloatingMatchSettingsPlain, FloatingMatchSettingsData as FloatingMatchSettings, } from './input/FloatingMatchSettings';
+export { ImageMatchSettings as ImageMatchSettingsPlain, ImageMatchSettingsData as ImageMatchSettings, } from './input/ImageMatchSettings';
+export { ImageRotation as ImageRotationPlain, ImageRotationData as ImageRotation } from './input/ImageRotation';
+export { Location as LocationPlain, LocationData as Location } from './input/Location';
+export { LogHandler as LogHandlerPlain, CustomLogHandler as CustomLogHandlerPlain, FileLogHandler as FileLogHandlerPlain, ConsoleLogHandler as ConsoleLogHandlerPlain, LogHandlerData as LogHandler, FileLogHandlerData as FileLogHandler, ConsoleLogHandlerData as ConsoleLogHandler, NullLogHandlerData as NullLogHandler, } from './input/LogHandler';
+export { OCRRegion } from './input/OCRRegion';
+export { OCRSettings } from './input/OCRSettings';
+export { PropertyData as PropertyDataPlain, PropertyDataData as PropertyData } from './input/PropertyData';
+export { ProxySettings as ProxySettingsPlain, ProxySettingsData as ProxySettings } from './input/ProxySettings';
+export { RectangleSize as RectangleSizePlain, RectangleSizeData as RectangleSize } from './input/RectangleSize';
+export { Region as RegionPlain, LegacyRegion as LegacyRegionPlain, RegionData as Region } from './input/Region';
+export { DesktopBrowserInfo, ChromeEmulationInfo, IOSDeviceInfo } from './input/RenderInfo';
+export { RunnerOptions as RunnerOptionsPlain, RunnerOptionsFluent, RunnerOptionsFluentInit as RunnerOptions, } from './input/RunnerOptions';
+export { VisualLocatorSettings } from './input/VisualLocatorSettings';
+export { ApiUrls as ApiUrlsPlain, ApiUrlsData as ApiUrls } from './output/ApiUrls';
+export { AppUrls as AppUrlsPlain, AppUrlsData as AppUrls } from './output/AppUrls';
+export { MatchResult as MatchResultPlain, MatchResultData as MatchResult } from './output/MatchResult';
+export { SessionUrls as SessionUrlsPlain, SessionUrlsData as SessionUrls } from './output/SessionUrls';
+export { StepInfo as StepInfoPlain, StepInfoData as StepInfo } from './output/StepInfo';
+export { TestAccessibilityStatus } from './output/TestAccessibilityStatus';
+export { TestResults as TestResultsPlain, TestResultsData as TestResults } from './output/TestResults';
+export { TestResultContainer as TestResultContainerPlain, TestResultContainerData as TestResultContainer, } from './output/TestResultContainer';
+export { TestResultsSummary as TestResultsSummaryPlain, TestResultsSummaryData as TestResultsSummary, } from './output/TestResultsSummary';
+export { TextRegion } from './output/TextRegion';
+export { ValidationInfo as ValidationInfoPlain, ValidationInfoData as ValidationInfo } from './output/ValidationInfo';
+export { ValidationResult as ValidationResultPlain, ValidationResultData as ValidationResult, } from './output/ValidationResult';
+export { EyesSelector } from './input/EyesSelector';
+export { Logger } from './Logger';
+export { Eyes } from './Eyes';
+export { BatchClose, closeBatch } from './BatchClose';
+export { EyesRunner, ClassicRunner, VisualGridRunner } from './Runners';
+export { SessionEventHandler, SessionEventHandlers, RemoteSessionEventHandler } from './SessionEventHandlers';

package/types/input/AUTProxySettings.d.ts

@@ -0,0 +1,5 @@
+import { ProxySettings } from './ProxySettings';
+export type AUTProxySettings = ProxySettings & {
+    mode?: 'Allow' | 'Block';
+    domains?: string[];
+};

package/types/input/AccessibilityMatchSettings.d.ts

@@ -0,0 +1,34 @@
+import { AccessibilityRegionType, AccessibilityRegionTypeEnum } from '../enums/AccessibilityRegionType';
+import { Region, RegionData } from './Region';
+export type AccessibilityMatchSettings = {
+    region: Region;
+    type?: AccessibilityRegionType;
+};
+export declare class AccessibilityMatchSettingsData implements Required<AccessibilityMatchSettings> {
+    private _settings;
+    constructor(settings: AccessibilityMatchSettings);
+    constructor(region: Region);
+    constructor(x: number, y: number, width: number, height: number, type?: AccessibilityRegionType);
+    get region(): Region;
+    set region(region: Region);
+    getRegion(): RegionData;
+    setRegion(region: Region): void;
+    getLeft(): number;
+    setLeft(left: number): void;
+    getTop(): number;
+    setTop(top: number): void;
+    getWidth(): number;
+    setWidth(width: number): void;
+    getHeight(): number;
+    setHeight(height: number): void;
+    get type(): AccessibilityRegionType;
+    set type(type: AccessibilityRegionType);
+    getType(): AccessibilityRegionTypeEnum;
+    setType(type: AccessibilityRegionType): void;
+    /** @internal */
+    toObject(): AccessibilityMatchSettings;
+    /** @internal */
+    toJSON(): AccessibilityMatchSettings;
+    /** @internal */
+    toString(): string;
+}

package/types/input/AccessibilitySettings.d.ts

@@ -0,0 +1,6 @@
+import { AccessibilityLevel } from '../enums/AccessibilityLevel';
+import { AccessibilityGuidelinesVersion } from '../enums/AccessibilityGuidelinesVersion';
+export type AccessibilitySettings = {
+    level?: AccessibilityLevel;
+    guidelinesVersion?: AccessibilityGuidelinesVersion;
+};

package/types/input/BatchInfo.d.ts

@@ -0,0 +1,47 @@
+import { PropertyData, PropertyDataData } from './PropertyData';
+export type BatchInfo = {
+    id?: string;
+    name?: string;
+    sequenceName?: string;
+    startedAt?: Date | string;
+    notifyOnCompletion?: boolean;
+    properties?: PropertyData[];
+};
+export declare class BatchInfoData implements Required<BatchInfo> {
+    private _batch;
+    constructor();
+    constructor(batch?: BatchInfo);
+    constructor(name?: string, startedAt?: Date | string, id?: string);
+    get id(): string;
+    set id(id: string);
+    getId(): string;
+    setId(id: string): this;
+    get name(): string;
+    set name(name: string);
+    getName(): string;
+    setName(name: string): this;
+    get sequenceName(): string;
+    set sequenceName(sequenceName: string);
+    getSequenceName(): string;
+    setSequenceName(sequenceName: string): this;
+    get startedAt(): Date | string;
+    set startedAt(startedAt: Date | string);
+    getStartedAt(): Date | string;
+    setStartedAt(startedAt: Date | string): this;
+    get notifyOnCompletion(): boolean;
+    set notifyOnCompletion(notifyOnCompletion: boolean);
+    getNotifyOnCompletion(): boolean;
+    setNotifyOnCompletion(notifyOnCompletion: boolean): this;
+    get properties(): PropertyData[];
+    set properties(properties: PropertyData[]);
+    getProperties(): PropertyDataData[];
+    setProperties(properties: PropertyData[]): this;
+    addProperty(name: string, value: string): this;
+    addProperty(prop: PropertyData): this;
+    /** @internal */
+    toObject(): BatchInfo;
+    /** @internal */
+    toJSON(): BatchInfo;
+    /** @internal */
+    toString(): string;
+}

package/types/input/CheckSettings.d.ts

@@ -0,0 +1,280 @@
+/// <reference types="node" />
+import type * as Core from '@applitools/core';
+import { EyesSelector } from './EyesSelector';
+import { Image } from './Image';
+import { AccessibilityRegionType } from '../enums/AccessibilityRegionType';
+import { MatchLevel } from '../enums/MatchLevel';
+import { Region, LegacyRegion } from './Region';
+import { Location } from './Location';
+import { LazyLoadOptions } from './LazyLoadOptions';
+import { DensityMetrics } from './DensityMetrics';
+import * as utils from '@applitools/utils';
+import { DynamicTextType } from '../enums/DynamicTextType';
+import { type StitchMode } from '../enums/StitchMode';
+type RegionReference<TSpec extends Core.SpecType> = Region | LegacyRegion | ElementReference<TSpec>;
+type ElementReference<TSpec extends Core.SpecType> = TSpec['element'] | SelectorReference<TSpec>;
+type SelectorReference<TSpec extends Core.SpecType> = EyesSelector<TSpec['selector']>;
+type FrameReference<TSpec extends Core.SpecType> = ElementReference<TSpec> | string | number;
+type ContextReference<TSpec extends Core.SpecType> = {
+    frame: FrameReference<TSpec>;
+    scrollRootElement?: ElementReference<TSpec>;
+};
+type CodedRegion<TRegion = never> = {
+    region: Region | LegacyRegion | TRegion;
+    padding?: number | {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    regionId?: string;
+};
+type CodedFloatingRegion<TRegion = never> = CodedRegion<TRegion> & {
+    offset?: {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    };
+};
+/** @deprecated */
+type LegacyCodedFloatingRegion<TRegion = never> = CodedRegion<TRegion> & {
+    maxUpOffset?: number;
+    maxDownOffset?: number;
+    maxLeftOffset?: number;
+    maxRightOffset?: number;
+};
+type CodedAccessibilityRegion<TRegion = never> = CodedRegion<TRegion> & {
+    type?: AccessibilityRegionType;
+};
+type DynamicTextTypeOrPattern = DynamicTextType | string;
+type CodedDynamicRegion<TRegion = never> = CodedRegion<TRegion> & {
+    type?: DynamicTextTypeOrPattern | DynamicTextTypeOrPattern[];
+};
+export type CheckSettingsBase<TRegion = never> = {
+    name?: string;
+    region?: Region | LegacyRegion | TRegion;
+    matchLevel?: MatchLevel;
+    useDom?: boolean;
+    sendDom?: boolean;
+    enablePatterns?: boolean;
+    ignoreDisplacements?: boolean;
+    ignoreMismatch?: boolean;
+    ignoreCaret?: boolean;
+    ignoreRegions?: (CodedRegion<TRegion> | Region | LegacyRegion | TRegion)[];
+    layoutRegions?: (CodedRegion<TRegion> | Region | LegacyRegion | TRegion)[];
+    strictRegions?: (CodedRegion<TRegion> | Region | LegacyRegion | TRegion)[];
+    contentRegions?: (CodedRegion<TRegion> | Region | LegacyRegion | TRegion)[];
+    floatingRegions?: (CodedFloatingRegion<TRegion> | LegacyCodedFloatingRegion<TRegion> | Region | LegacyRegion | TRegion)[];
+    accessibilityRegions?: (CodedAccessibilityRegion<TRegion> | Region | LegacyRegion | TRegion)[];
+    dynamicRegions?: (CodedDynamicRegion<TRegion> | Region | TRegion)[];
+    pageId?: string;
+    variationGroupId?: string;
+    densityMetrics?: DensityMetrics;
+    stitchMode?: StitchMode;
+};
+export type CheckSettingsImage = CheckSettingsBase;
+type LayoutBreakpoints = boolean | number[] | {
+    breakpoints: number[] | boolean;
+    reload?: boolean;
+} | {
+    breakpoints: boolean;
+    heightBreakpoints: boolean;
+    reload?: boolean;
+};
+export type CheckSettingsAutomation<TSpec extends Core.SpecType> = CheckSettingsBase<RegionReference<TSpec>> & {
+    frames?: (ContextReference<TSpec> | FrameReference<TSpec>)[];
+    webview?: boolean | string;
+    scrollRootElement?: ElementReference<TSpec>;
+    fully?: boolean;
+    disableBrowserFetching?: boolean;
+    layoutBreakpoints?: LayoutBreakpoints;
+    /** @deprecated */
+    visualGridOptions?: {
+        [key: string]: any;
+    };
+    ufgOptions?: {
+        [key: string]: any;
+    };
+    /** @deprecated */
+    nmgOptions?: {
+        [key: string]: any;
+    };
+    useSystemScreenshot?: boolean;
+    hooks?: {
+        beforeCaptureScreenshot: string;
+    };
+    timeout?: number;
+    waitBeforeCapture?: number | (() => Promise<void>);
+    lazyLoad?: boolean | LazyLoadOptions;
+};
+export declare class CheckSettingsBaseFluent<TRegion = never> {
+    protected _settings: CheckSettingsBase<TRegion>;
+    protected parent?: this;
+    protected childs: this[];
+    constructor(settings?: CheckSettingsBase<TRegion> | CheckSettingsBaseFluent<TRegion>, parent?: CheckSettingsBaseFluent<TRegion>);
+    region(region: Region | LegacyRegion | TRegion): typeof this;
+    name(name: string): typeof this;
+    withName(name: string): this;
+    ignoreRegion(region: CodedRegion<TRegion> | Region | LegacyRegion | TRegion): typeof this;
+    ignoreRegions(...regions: (CodedRegion<TRegion> | Region | LegacyRegion | TRegion)[]): typeof this;
+    /** @deprecated */
+    ignore(region: Region | LegacyRegion | TRegion): this;
+    /** @deprecated */
+    ignores(...regions: (Region | LegacyRegion | TRegion)[]): typeof this;
+    layoutRegion(region: CodedRegion<TRegion> | Region | LegacyRegion | TRegion): typeof this;
+    layoutRegions(...regions: (CodedRegion<TRegion> | Region | LegacyRegion | TRegion)[]): typeof this;
+    strictRegion(region: CodedRegion<TRegion> | Region | LegacyRegion | TRegion): typeof this;
+    strictRegions(...regions: (CodedRegion<TRegion> | Region | LegacyRegion | TRegion)[]): typeof this;
+    contentRegion(region: CodedRegion<TRegion> | Region | LegacyRegion | TRegion): typeof this;
+    contentRegions(...regions: (CodedRegion<TRegion> | Region | LegacyRegion | TRegion)[]): typeof this;
+    floatingRegion(region: CodedFloatingRegion<TRegion>): this;
+    floatingRegion(region: LegacyCodedFloatingRegion<TRegion>): this;
+    floatingRegion(region: Region | LegacyRegion | TRegion, maxUpOffset?: number, maxDownOffset?: number, maxLeftOffset?: number, maxRightOffset?: number): this;
+    floatingRegions(...regions: (CodedFloatingRegion<TRegion> | Region | LegacyRegion | TRegion)[]): this;
+    floatingRegions(maxOffset: number, ...regions: (Region | LegacyRegion | TRegion)[]): this;
+    /** @deprecated */
+    floating(region: CodedFloatingRegion<TRegion>): this;
+    /** @deprecated */
+    floating(region: Region | LegacyRegion | TRegion): this;
+    /** @deprecated */
+    floatings(...regions: (CodedFloatingRegion<TRegion> | Region | LegacyRegion | TRegion)[]): this;
+    /** @deprecated */
+    floatings(maxOffset: number, ...regions: (Region | LegacyRegion | TRegion)[]): this;
+    accessibilityRegion(region: CodedAccessibilityRegion<TRegion>): this;
+    accessibilityRegion(region: Region | LegacyRegion | TRegion, type?: AccessibilityRegionType): this;
+    accessibilityRegions(...regions: (CodedAccessibilityRegion<TRegion> | Region | LegacyRegion | TRegion)[]): this;
+    accessibilityRegions(type: AccessibilityRegionType, ...regions: (Region | LegacyRegion | TRegion)[]): this;
+    dynamicRegion(region: CodedDynamicRegion<TRegion>): this;
+    dynamicRegion(region: Region | TRegion): this;
+    dynamicRegion(region: Region | TRegion, type?: DynamicTextTypeOrPattern | DynamicTextTypeOrPattern[]): this;
+    dynamicRegions(...regions: (CodedDynamicRegion<TRegion> | Region | TRegion)[]): this;
+    matchLevel(matchLevel: MatchLevel): typeof this;
+    layout(): typeof this;
+    exact(): typeof this;
+    strict(): typeof this;
+    ignoreColors(): typeof this;
+    dynamic(): typeof this;
+    /** @deprecated */
+    content(): typeof this;
+    enablePatterns(enablePatterns?: boolean): typeof this;
+    ignoreDisplacements(ignoreDisplacements?: boolean): typeof this;
+    ignoreCaret(ignoreCaret?: boolean): typeof this;
+    useDom(useDom?: boolean): typeof this;
+    sendDom(sendDom?: boolean): typeof this;
+    pageId(pageId: string): typeof this;
+    variationGroupId(variationGroupId: string): typeof this;
+    /** @internal */
+    toObject(): CheckSettingsBase<TRegion>;
+    /** @internal */
+    toString(): string;
+    /** @internal */
+    protected assumesMutability(): true | undefined;
+    protected static makeMutableTreeProxy<K, T extends CheckSettingsBaseFluent<K>>(self: T, ctor: new (...args: any[]) => T): T;
+    protected toCoreCodedRegion(region: CodedRegion<TRegion> | Region | LegacyRegion | TRegion): Core.CodedRegion<TRegion | utils.Region> | utils.Region | TRegion;
+    protected toCoreCodedFloatingRegion(region: CodedFloatingRegion<TRegion> | LegacyCodedFloatingRegion<TRegion> | Region | LegacyRegion | TRegion): Core.FloatingRegion<TRegion | utils.Region> | utils.Region | TRegion;
+    protected toCoreRegion(region: Region | LegacyRegion | TRegion): utils.Region | TRegion;
+}
+export declare class CheckSettingsImageFluent extends CheckSettingsBaseFluent {
+    protected _target: Image;
+    constructor(settings?: CheckSettingsImage | CheckSettingsImageFluent, target?: Image, parent?: CheckSettingsImageFluent);
+    image(image: Buffer | URL | string): typeof this;
+    buffer(imageBuffer: Buffer): typeof this;
+    base64(imageBase64: Buffer): typeof this;
+    path(imagePath: string): typeof this;
+    url(imageUrl: URL | string): typeof this;
+    name(name: string): typeof this;
+    withDom(dom: string): typeof this;
+    withLocation(locationInViewport: Location): typeof this;
+    /** @internal */
+    toJSON(): {
+        target: Image;
+        settings: Core.CheckSettings<never, 'classic'>;
+    };
+}
+export declare class CheckSettingsAutomationFluent<TSpec extends Core.SpecType = Core.SpecType> extends CheckSettingsBaseFluent<RegionReference<TSpec>> {
+    protected _settings: CheckSettingsAutomation<TSpec>;
+    protected static readonly _spec: Core.SpecDriver<Core.SpecType>;
+    protected _spec: Core.SpecDriver<TSpec>;
+    protected _isElementReference(value: any): value is ElementReference<TSpec>;
+    protected _isSelectorReference(selector: any): selector is SelectorReference<TSpec>;
+    protected _isFrameReference(value: any): value is FrameReference<TSpec>;
+    constructor(settings?: CheckSettingsAutomation<TSpec> | CheckSettingsAutomationFluent<TSpec>);
+    /** @internal */
+    constructor(settings?: CheckSettingsAutomation<TSpec> | CheckSettingsAutomationFluent<TSpec>, spec?: Core.SpecDriver<TSpec>, parent?: CheckSettingsAutomationFluent<TSpec>);
+    region(region: RegionReference<TSpec>): this;
+    shadow(selector: SelectorReference<TSpec>): typeof this;
+    frame(context: ContextReference<TSpec>): this;
+    frame(frame: FrameReference<TSpec>, scrollRootElement?: ElementReference<TSpec>): this;
+    webview(webview?: string | boolean): typeof this;
+    scrollRootElement(scrollRootElement: ElementReference<TSpec>): typeof this;
+    fully(fully?: boolean): typeof this;
+    /** @deprecated */
+    stitchContent(stitchContent?: boolean): this;
+    disableBrowserFetching(disableBrowserFetching: boolean): typeof this;
+    layoutBreakpoints(breakpoints: boolean, heightBreakpoints: boolean, settings?: {
+        reload?: boolean;
+    }): this;
+    layoutBreakpoints(breakpoints: boolean | number[], settings?: {
+        reload?: boolean;
+    }): this;
+    hook(name: string, script: string): typeof this;
+    beforeRenderScreenshotHook(script: string): typeof this;
+    /** @deprecated */
+    webHook(script: string): typeof this;
+    ufgOption(key: string, value: any): this;
+    ufgOptions(options: {
+        [key: string]: any;
+    }): this;
+    /** @deprecated */
+    nmgOption(key: string, value: any): this;
+    /** @deprecated */
+    nmgOptions(options: {
+        [key: string]: any;
+    }): this;
+    /** @deprecated */
+    visualGridOption(key: string, value: any): this;
+    /** @deprecated */
+    visualGridOptions(options: {
+        [key: string]: any;
+    }): this;
+    useSystemScreenshot(useSystemScreenshot?: boolean): this;
+    timeout(timeout: number): typeof this;
+    waitBeforeCapture(waitBeforeCapture: number | (() => Promise<void>)): typeof this;
+    lazyLoad(options?: LazyLoadOptions | boolean): typeof this;
+    densityMetrics(options: DensityMetrics): typeof this;
+    stitchMode(stitchMode: StitchMode): typeof this;
+    /** @internal */
+    protected toLayoutBreakpoints(): {
+        breakpoints: number[] | boolean;
+        heightBreakpoints?: boolean;
+        reload?: boolean;
+    };
+    /** @internal */
+    toJSON(): {
+        target: undefined;
+        settings: Core.CheckSettings<TSpec, 'classic'> & Core.CheckSettings<TSpec, 'ufg'>;
+    };
+}
+export type TargetImage = {
+    image(image: Buffer | URL | string): CheckSettingsImageFluent;
+    buffer(imageBuffer: Buffer): CheckSettingsImageFluent;
+    base64(imageBase64: string): CheckSettingsImageFluent;
+    path(imagePath: string): CheckSettingsImageFluent;
+    url(imageUrl: URL | string): CheckSettingsImageFluent;
+};
+export declare const TargetImage: TargetImage;
+export type TargetAutomation<TSpec extends Core.SpecType = Core.SpecType> = {
+    /** @internal */
+    spec: Core.SpecDriver<TSpec>;
+    window(): CheckSettingsAutomationFluent<TSpec>;
+    region(region: RegionReference<TSpec> | LegacyRegion): CheckSettingsAutomationFluent<TSpec>;
+    frame(context: ContextReference<TSpec>): CheckSettingsAutomationFluent<TSpec>;
+    frame(frame: FrameReference<TSpec>, scrollRootElement?: ElementReference<TSpec>): CheckSettingsAutomationFluent<TSpec>;
+    shadow(selector: SelectorReference<TSpec>): CheckSettingsAutomationFluent<TSpec>;
+    webview(webview?: string | boolean): CheckSettingsAutomationFluent<TSpec>;
+};
+export declare const TargetAutomation: TargetAutomation<Core.SpecType>;
+export type Target<TSpec extends Core.SpecType = Core.SpecType> = TargetImage & TargetAutomation<TSpec>;
+export declare const Target: Target<Core.SpecType>;
+export {};