@applitools/eyes-browser 1.0.0

package/types/enums/DeviceName.d.ts

@@ -0,0 +1,73 @@
+export declare enum DeviceNameEnum {
+    Blackberry_PlayBook = "Blackberry PlayBook",
+    BlackBerry_Z30 = "BlackBerry Z30",
+    Galaxy_A5 = "Galaxy A5",
+    Galaxy_Note_10 = "Galaxy Note 10",
+    Galaxy_Note_10_Plus = "Galaxy Note 10 Plus",
+    Galaxy_Note_2 = "Galaxy Note 2",
+    Galaxy_Note_3 = "Galaxy Note 3",
+    Galaxy_Note_4 = "Galaxy Note 4",
+    Galaxy_Note_8 = "Galaxy Note 8",
+    Galaxy_Note_9 = "Galaxy Note 9",
+    Galaxy_S3 = "Galaxy S3",
+    Galaxy_S5 = "Galaxy S5",
+    Galaxy_S8 = "Galaxy S8",
+    Galaxy_S8_Plus = "Galaxy S8 Plus",
+    Galaxy_S9 = "Galaxy S9",
+    Galaxy_S9_Plus = "Galaxy S9 Plus",
+    Galaxy_S10 = "Galaxy S10",
+    Galaxy_S10_Plus = "Galaxy S10 Plus",
+    Galaxy_S20 = "Galaxy S20",
+    Galaxy_S21 = "Galaxy S21",
+    Galaxy_S21_Ultra = "Galaxy S21 Ultra",
+    Galaxy_S22 = "Galaxy S22",
+    Galaxy_S22_Ultra = "Galaxy S22 Ultra",
+    Galaxy_Tab_S7 = "Galaxy Tab S7",
+    iPad = "iPad",
+    iPad_6th_Gen = "iPad 6th Gen",
+    iPad_7th_Gen = "iPad 7th Gen",
+    iPad_Air_2 = "iPad Air 2",
+    iPad_Mini = "iPad Mini",
+    iPad_Pro = "iPad Pro",
+    iPhone_11 = "iPhone 11",
+    iPhone_11_Pro = "iPhone 11 Pro",
+    iPhone_11_Pro_Max = "iPhone 11 Pro Max",
+    iPhone_4 = "iPhone 4",
+    iPhone_5SE = "iPhone 5/SE",
+    iPhone_6_7_8 = "iPhone 6/7/8",
+    iPhone_6_7_8_Plus = "iPhone 6/7/8 Plus",
+    iPhone_X = "iPhone X",
+    iPhone_XR = "iPhone XR",
+    iPhone_XS = "iPhone XS",
+    iPhone_XS_Max = "iPhone XS Max",
+    Kindle_Fire_HDX = "Kindle Fire HDX",
+    Laptop_with_HiDPI_screen = "Laptop with HiDPI screen",
+    Laptop_with_MDPI_screen = "Laptop with MDPI screen",
+    Laptop_with_touch = "Laptop with touch",
+    LG_G6 = "LG G6",
+    LG_Optimus_L70 = "LG Optimus L70",
+    Microsoft_Lumia_550 = "Microsoft Lumia 550",
+    Microsoft_Lumia_950 = "Microsoft Lumia 950",
+    Nexus_10 = "Nexus 10",
+    Nexus_4 = "Nexus 4",
+    Nexus_5 = "Nexus 5",
+    Nexus_5X = "Nexus 5X",
+    Nexus_6 = "Nexus 6",
+    Nexus_6P = "Nexus 6P",
+    Nexus_7 = "Nexus 7",
+    Nokia_Lumia_520 = "Nokia Lumia 520",
+    Nokia_N9 = "Nokia N9",
+    OnePlus_7T = "OnePlus 7T",
+    OnePlus_7T_Pro = "OnePlus 7T Pro",
+    Pixel_2 = "Pixel 2",
+    Pixel_2_XL = "Pixel 2 XL",
+    Pixel_3 = "Pixel 3",
+    Pixel_3_XL = "Pixel 3 XL",
+    Pixel_4 = "Pixel 4",
+    Pixel_4_XL = "Pixel 4 XL",
+    Pixel_5 = "Pixel 5",
+    Sony_Xperia_10_II = "Sony Xperia 10 II",
+    Huawei_Mate_50_Pro = "Huawei Mate 50 Pro",
+    Huawei_Matepad_11 = "Huawei Matepad 11"
+}
+export type DeviceName = `${DeviceNameEnum}`;

package/types/enums/FailureReport.d.ts

@@ -0,0 +1,5 @@
+export declare enum FailureReportEnum {
+    IMMEDIATE = "IMMEDIATE",
+    ON_CLOSE = "ON_CLOSE"
+}
+export type FailureReport = `${FailureReportEnum}`;

package/types/enums/IosDeviceName.d.ts

@@ -0,0 +1,64 @@
+export declare enum IosDeviceNameEnum {
+    iPhone_6s = "iPhone 6s",
+    iPhone_6s_Plus = "iPhone 6s Plus",
+    iPhone_7 = "iPhone 7",
+    iPhone_7_Plus = "iPhone 7 Plus",
+    iPhone_8 = "iPhone 8",
+    iPhone_8_Plus = "iPhone 8 Plus",
+    iPhone_X = "iPhone X",
+    iPhone_XR = "iPhone XR",
+    iPhone_Xs = "iPhone Xs",
+    /** @deprecated use {@link iPhone_Xs} instead */
+    iPhone_XS = "iPhone Xs",
+    iPhone_Xs_Max = "iPhone Xs Max",
+    iPhone_11 = "iPhone 11",
+    iPhone_11_Pro = "iPhone 11 Pro",
+    iPhone_11_Pro_Max = "iPhone 11 Pro Max",
+    iPhone_12 = "iPhone 12",
+    iPhone_12_mini = "iPhone 12 mini",
+    iPhone_12_Pro = "iPhone 12 Pro",
+    iPhone_12_Pro_Max = "iPhone 12 Pro Max",
+    iPhone_13 = "iPhone 13",
+    iPhone_13_mini = "iPhone 13 mini",
+    iPhone_13_Pro = "iPhone 13 Pro",
+    iPhone_13_Pro_Max = "iPhone 13 Pro Max",
+    iPhone_14 = "iPhone 14",
+    iPhone_14_Plus = "iPhone 14 Plus",
+    iPhone_14_Pro = "iPhone 14 Pro",
+    iPhone_14_Pro_Max = "iPhone 14 Pro Max",
+    iPhone_SE = "iPhone SE (1st generation)",
+    iPhone_SE_1 = "iPhone SE (1st generation)",
+    iPhone_SE_2 = "iPhone SE (2nd generation)",
+    iPhone_SE_3 = "iPhone SE (3rd generation)",
+    iPad_5 = "iPad (5th generation)",
+    iPad_6 = "iPad (6th generation)",
+    iPad_7 = "iPad (7th generation)",
+    iPad_8 = "iPad (8th generation)",
+    iPad_9 = "iPad (9th generation)",
+    iPad_10 = "iPad (10th generation)",
+    iPad_Air_2 = "iPad Air 2",
+    iPad_Air_3 = "iPad Air (3rd generation)",
+    iPad_Air_4 = "iPad Air (4th generation)",
+    iPad_Air_5 = "iPad Air (5th generation)",
+    iPad_mini_4 = "iPad mini 4",
+    iPad_mini_5 = "iPad mini (5th generation)",
+    iPad_mini_6 = "iPad mini (6th generation)",
+    iPad_Pro_9_7_inch_1 = "iPad Pro (9.7-inch)",
+    iPad_Pro_10_5_inch_1 = "iPad Pro (10.5-inch)",
+    iPad_Pro_11_inch_1 = "iPad Pro (11-inch) (1st generation)",
+    iPad_Pro_12_9_inch_1 = "iPad Pro (12.9-inch) (1st generation)",
+    iPad_Pro_11_inch_2 = "iPad Pro (11-inch) (2nd generation)",
+    iPad_Pro_12_9_inch_2 = "iPad Pro (12.9-inch) (2nd generation)",
+    iPad_Pro_11_inch_3 = "iPad Pro (11-inch) (3rd generation)",
+    iPad_Pro_12_9_inch_3 = "iPad Pro (12.9-inch) (3rd generation)",
+    /** @deprecated use {@link iPad_Pro_12_9_inch_3} instead */
+    iPad_Pro_3 = "iPad Pro (12.9-inch) (3rd generation)",
+    iPad_Pro_11_inch_4 = "iPad Pro (11-inch) (4th generation)",
+    /** @deprecated use {@link iPad_Pro_11_inch_4} instead */
+    iPad_Pro_4 = "iPad Pro (11-inch) (4th generation)",
+    iPad_Pro_12_9_inch_4 = "iPad Pro (12.9-inch) (4th generation)",
+    iPad_Pro_12_9_inch_5 = "iPad Pro (12.9-inch) (5th generation)",
+    iPad_Pro_12_9_inch_6 = "iPad Pro (12.9-inch) (6th generation)",
+    iPod_touch_7 = "iPod touch (7th generation)"
+}
+export type IosDeviceName = `${IosDeviceNameEnum}`;

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,11 @@
+export declare enum MatchLevelEnum {
+    None = "None",
+    LegacyLayout = "Layout1",
+    Layout = "Layout",
+    Layout2 = "Layout2",
+    Content = "Content",
+    IgnoreColors = "IgnoreColors",
+    Strict = "Strict",
+    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,61 @@
+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 { AndroidDeviceName as AndroidDeviceNamePlain, AndroidDeviceNameEnum as AndroidDeviceName, } from './enums/AndroidDeviceName';
+export { AndroidVersion as AndroidVersionPlain, AndroidVersionEnum as AndroidVersion } from './enums/AndroidVersion';
+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 { 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, AndroidDeviceInfo } 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,239 @@
+/// <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';
+type RegionReference<TSpec extends Core.SpecType> = Region | 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 | 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;
+};
+export type CheckSettingsBase<TRegion = never> = {
+    name?: string;
+    region?: Region | TRegion;
+    matchLevel?: MatchLevel;
+    useDom?: boolean;
+    sendDom?: boolean;
+    enablePatterns?: boolean;
+    ignoreDisplacements?: boolean;
+    ignoreMismatch?: boolean;
+    ignoreCaret?: boolean;
+    ignoreRegions?: (CodedRegion<TRegion> | Region | TRegion)[];
+    layoutRegions?: (CodedRegion<TRegion> | Region | TRegion)[];
+    strictRegions?: (CodedRegion<TRegion> | Region | TRegion)[];
+    contentRegions?: (CodedRegion<TRegion> | Region | TRegion)[];
+    floatingRegions?: (CodedFloatingRegion<TRegion> | LegacyCodedFloatingRegion<TRegion> | Region | TRegion)[];
+    accessibilityRegions?: (CodedAccessibilityRegion<TRegion> | Region | TRegion)[];
+    pageId?: string;
+    variationGroupId?: string;
+    densityMetrics?: DensityMetrics;
+};
+export type CheckSettingsImage = CheckSettingsBase;
+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?: boolean | number[] | {
+        breakpoints: number[] | boolean;
+        reload?: boolean;
+    };
+    visualGridOptions?: {
+        [key: string]: any;
+    };
+    /** @deprecated */
+    nmgOptions?: {
+        [key: string]: any;
+    };
+    useSystemScreenshot?: boolean;
+    hooks?: {
+        beforeCaptureScreenshot: string;
+    };
+    timeout?: number;
+    waitBeforeCapture?: number;
+    lazyLoad?: boolean | LazyLoadOptions;
+};
+export declare class CheckSettingsBaseFluent<TRegion = never> {
+    protected _settings: CheckSettingsBase<TRegion>;
+    constructor(settings?: CheckSettingsBase<TRegion> | CheckSettingsBaseFluent<TRegion>);
+    region(region: Region | LegacyRegion | TRegion): this;
+    name(name: string): this;
+    withName(name: string): this;
+    ignoreRegion(region: CodedRegion<TRegion> | Region | LegacyRegion | TRegion): this;
+    ignoreRegions(...regions: (CodedRegion<TRegion> | Region | LegacyRegion | TRegion)[]): this;
+    /** @deprecated */
+    ignore(region: Region | LegacyRegion | TRegion): this;
+    /** @deprecated */
+    ignores(...regions: (Region | LegacyRegion | TRegion)[]): this;
+    layoutRegion(region: CodedRegion<TRegion> | Region | LegacyRegion | TRegion): this;
+    layoutRegions(...regions: (CodedRegion<TRegion> | Region | LegacyRegion | TRegion)[]): this;
+    strictRegion(region: CodedRegion<TRegion> | Region | LegacyRegion | TRegion): this;
+    strictRegions(...regions: (CodedRegion<TRegion> | Region | LegacyRegion | TRegion)[]): this;
+    contentRegion(region: CodedRegion<TRegion> | Region | LegacyRegion | TRegion): this;
+    contentRegions(...regions: (CodedRegion<TRegion> | Region | LegacyRegion | TRegion)[]): 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;
+    matchLevel(matchLevel: MatchLevel): this;
+    layout(): this;
+    exact(): this;
+    strict(): this;
+    ignoreColors(): this;
+    /** @deprecated */
+    content(): this;
+    enablePatterns(enablePatterns?: boolean): this;
+    ignoreDisplacements(ignoreDisplacements?: boolean): this;
+    ignoreCaret(ignoreCaret?: boolean): this;
+    useDom(useDom?: boolean): this;
+    sendDom(sendDom?: boolean): this;
+    pageId(pageId: string): this;
+    variationGroupId(variationGroupId: string): this;
+    /** @internal */
+    toObject(): CheckSettingsBase<TRegion>;
+    /** @internal */
+    toString(): string;
+}
+export declare class CheckSettingsImageFluent extends CheckSettingsBaseFluent {
+    protected _target: Image;
+    constructor(settings?: CheckSettingsImage | CheckSettingsImageFluent, target?: Image);
+    image(image: Buffer | URL | string): this;
+    buffer(imageBuffer: Buffer): this;
+    base64(imageBase64: Buffer): this;
+    path(imagePath: string): this;
+    url(imageUrl: URL | string): this;
+    name(name: string): this;
+    withDom(dom: string): this;
+    withLocation(locationInViewport: Location): 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>);
+    region(region: RegionReference<TSpec>): this;
+    shadow(selector: SelectorReference<TSpec>): this;
+    frame(context: ContextReference<TSpec>): this;
+    frame(frame: FrameReference<TSpec>, scrollRootElement?: ElementReference<TSpec>): this;
+    webview(webview?: string | boolean): this;
+    scrollRootElement(scrollRootElement: ElementReference<TSpec>): this;
+    fully(fully?: boolean): this;
+    /** @deprecated */
+    stitchContent(stitchContent?: boolean): this;
+    disableBrowserFetching(disableBrowserFetching: boolean): this;
+    layoutBreakpoints(breakpoints?: boolean | number[], settings?: {
+        reload?: boolean;
+    }): this;
+    hook(name: string, script: string): this;
+    beforeRenderScreenshotHook(script: string): this;
+    /** @deprecated */
+    webHook(script: string): 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): this;
+    waitBeforeCapture(waitBeforeCapture: number): this;
+    lazyLoad(options?: LazyLoadOptions | boolean): this;
+    densityMetrics(options: DensityMetrics): this;
+    /** @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 {};