@applitools/eyes-browser 1.0.0

package/types/input/Configuration.d.ts

@@ -0,0 +1,383 @@
+import type * as Core from '@applitools/core';
+import { EyesSelector } from './EyesSelector';
+import { SessionType, SessionTypeEnum } from '../enums/SessionType';
+import { StitchMode, StitchModeEnum } from '../enums/StitchMode';
+import { MatchLevel, MatchLevelEnum } from '../enums/MatchLevel';
+import { BrowserType } from '../enums/BrowserType';
+import { DeviceName } from '../enums/DeviceName';
+import { AndroidDeviceName } from '../enums/AndroidDeviceName';
+import { AndroidVersion } from '../enums/AndroidVersion';
+import { IosDeviceName } from '../enums/IosDeviceName';
+import { IosVersion } from '../enums/IosVersion';
+import { ScreenOrientation } from '../enums/ScreenOrientation';
+import { AccessibilitySettings } from './AccessibilitySettings';
+import { DesktopBrowserInfo, ChromeEmulationInfo, IOSDeviceInfo, AndroidDeviceInfo, ChromeEmulationInfoLegacy } from './RenderInfo';
+import { CutProvider } from './CutProvider';
+import { DebugScreenshotProvider } from './DebugScreenshotProvider';
+import { RectangleSize, RectangleSizeData } from './RectangleSize';
+import { ImageRotation, ImageRotationData } from './ImageRotation';
+import { ProxySettings, ProxySettingsData } from './ProxySettings';
+import { AUTProxySettings } from './AUTProxySettings';
+import { BatchInfo, BatchInfoData } from './BatchInfo';
+import { PropertyData, PropertyDataData } from './PropertyData';
+import { ImageMatchSettings } from './ImageMatchSettings';
+type RenderInfo = DesktopBrowserInfo | ChromeEmulationInfo | IOSDeviceInfo | AndroidDeviceInfo | ChromeEmulationInfoLegacy;
+export type Configuration<TSpec extends Core.SpecType = Core.SpecType> = {
+    /** @undocumented */
+    debugScreenshots?: DebugScreenshotProvider;
+    agentId?: string;
+    apiKey?: string;
+    serverUrl?: string;
+    proxy?: ProxySettings;
+    autProxy?: AUTProxySettings;
+    isDisabled?: boolean;
+    /** @undocumented */
+    connectionTimeout?: number;
+    /** @undocumented */
+    removeSession?: boolean;
+    appName?: string;
+    testName?: string;
+    displayName?: string;
+    viewportSize?: RectangleSize;
+    sessionType?: SessionType;
+    properties?: PropertyData[];
+    batch?: BatchInfo;
+    defaultMatchSettings?: ImageMatchSettings;
+    hostApp?: string;
+    hostOS?: string;
+    hostAppInfo?: string;
+    hostOSInfo?: string;
+    deviceInfo?: string;
+    baselineEnvName?: string;
+    environmentName?: string;
+    branchName?: string;
+    parentBranchName?: string;
+    baselineBranchName?: string;
+    compareWithParentBranch?: boolean;
+    ignoreBaseline?: boolean;
+    ignoreGitMergeBase?: boolean;
+    saveFailedTests?: boolean;
+    saveNewTests?: boolean;
+    saveDiffs?: boolean;
+    /** @undocumented */
+    dontCloseBatches?: boolean;
+    sendDom?: boolean;
+    matchTimeout?: number;
+    forceFullPageScreenshot?: boolean;
+    waitBeforeScreenshots?: number;
+    stitchMode?: StitchMode;
+    hideScrollbars?: boolean;
+    hideCaret?: boolean;
+    stitchOverlap?: number;
+    scrollRootElement?: TSpec['element'] | EyesSelector<TSpec['selector']>;
+    cut?: CutProvider;
+    rotation?: ImageRotation;
+    scaleRatio?: number;
+    /** @undocumented */
+    concurrentSessions?: number;
+    browsersInfo?: (DesktopBrowserInfo | ChromeEmulationInfo | IOSDeviceInfo | AndroidDeviceInfo)[];
+    visualGridOptions?: Record<string, any>;
+    layoutBreakpoints?: boolean | number[] | {
+        breakpoints: number[] | boolean;
+        reload?: boolean;
+    };
+    disableBrowserFetching?: boolean;
+    waitBeforeCapture?: number;
+};
+export declare class ConfigurationData<TSpec extends Core.SpecType = Core.SpecType> implements Required<Configuration<TSpec>> {
+    protected static readonly _spec: Core.SpecDriver<Core.SpecType>;
+    private _spec;
+    private _config;
+    private _isElementReference;
+    private _isSelectorReference;
+    constructor(config?: Configuration<TSpec>);
+    /** @internal */
+    constructor(config?: Configuration<TSpec>, spec?: Core.SpecDriver<TSpec>);
+    /** @undocumented */
+    get debugScreenshots(): DebugScreenshotProvider;
+    /** @undocumented */
+    set debugScreenshots(debugScreenshots: DebugScreenshotProvider);
+    /** @undocumented */
+    getSaveDebugScreenshots(): boolean;
+    /** @undocumented */
+    setSaveDebugScreenshots(save: boolean): this;
+    /** @undocumented */
+    getDebugScreenshotsPath(): string;
+    /** @undocumented */
+    setDebugScreenshotsPath(path: string): this;
+    /** @undocumented */
+    getDebugScreenshotsPrefix(): string;
+    /** @undocumented */
+    setDebugScreenshotsPrefix(prefix: string): this;
+    get appName(): string;
+    set appName(appName: string);
+    getAppName(): string;
+    setAppName(appName: string): this;
+    get testName(): string;
+    set testName(testName: string);
+    getTestName(): string;
+    setTestName(testName: string): this;
+    get displayName(): string;
+    set displayName(displayName: string);
+    getDisplayName(): string;
+    setDisplayName(displayName: string): this;
+    get isDisabled(): boolean;
+    set isDisabled(isDisabled: boolean);
+    getIsDisabled(): boolean;
+    setIsDisabled(isDisabled: boolean): this;
+    get matchTimeout(): number;
+    set matchTimeout(matchTimeout: number);
+    getMatchTimeout(): number;
+    setMatchTimeout(matchTimeout: number): this;
+    get sessionType(): SessionType;
+    set sessionType(sessionType: SessionType);
+    getSessionType(): SessionTypeEnum;
+    setSessionType(sessionType: SessionType): this;
+    get viewportSize(): RectangleSize;
+    set viewportSize(viewportSize: RectangleSize);
+    getViewportSize(): RectangleSizeData;
+    setViewportSize(viewportSize: RectangleSize): this;
+    get agentId(): string;
+    set agentId(agentId: string);
+    getAgentId(): string;
+    setAgentId(agentId: string): this;
+    get apiKey(): string;
+    set apiKey(apiKey: string);
+    getApiKey(): string;
+    setApiKey(apiKey: string): this;
+    get serverUrl(): string;
+    set serverUrl(serverUrl: string);
+    getServerUrl(): string;
+    setServerUrl(serverUrl: string): this;
+    get proxy(): ProxySettings;
+    set proxy(proxy: ProxySettings);
+    getProxy(): ProxySettingsData;
+    setProxy(proxy: ProxySettings): this;
+    setProxy(url: string, username?: string, password?: string, deprecatedIsHttpOnly?: boolean): this;
+    setProxy(isEnabled: false): this;
+    get autProxy(): AUTProxySettings;
+    set autProxy(autProxy: AUTProxySettings);
+    getAutProxy(): AUTProxySettings;
+    setAutProxy(autProxy: AUTProxySettings): this;
+    /** @undocumented */
+    get connectionTimeout(): number;
+    /** @undocumented */
+    set connectionTimeout(connectionTimeout: number);
+    /** @undocumented */
+    getConnectionTimeout(): number;
+    /** @undocumented */
+    setConnectionTimeout(connectionTimeout: number): this;
+    /** @undocumented */
+    get removeSession(): boolean;
+    /** @undocumented */
+    set removeSession(removeSession: boolean);
+    /** @undocumented */
+    getRemoveSession(): boolean;
+    /** @undocumented */
+    setRemoveSession(removeSession: boolean): this;
+    get batch(): BatchInfo;
+    set batch(batch: BatchInfo);
+    getBatch(): BatchInfoData;
+    setBatch(batch: BatchInfo): this;
+    get properties(): PropertyData[];
+    set properties(properties: PropertyData[]);
+    getProperties(): PropertyDataData[];
+    setProperties(properties: PropertyData[]): this;
+    addProperty(name: string, value: string): this;
+    addProperty(prop: PropertyData): this;
+    clearProperties(): this;
+    get baselineEnvName(): string;
+    set baselineEnvName(baselineEnvName: string);
+    getBaselineEnvName(): string;
+    setBaselineEnvName(baselineEnvName: string): this;
+    get environmentName(): string;
+    set environmentName(environmentName: string);
+    getEnvironmentName(): string;
+    setEnvironmentName(environmentName: string): this;
+    get branchName(): string;
+    set branchName(branchName: string);
+    getBranchName(): string;
+    setBranchName(branchName: string): this;
+    get parentBranchName(): string;
+    set parentBranchName(parentBranchName: string);
+    getParentBranchName(): string;
+    setParentBranchName(parentBranchName: string): this;
+    get baselineBranchName(): string;
+    set baselineBranchName(baselineBranchName: string);
+    getBaselineBranchName(): string;
+    setBaselineBranchName(baselineBranchName: string): this;
+    get compareWithParentBranch(): boolean;
+    set compareWithParentBranch(compareWithParentBranch: boolean);
+    getCompareWithParentBranch(): boolean;
+    setCompareWithParentBranch(compareWithParentBranch: boolean): this;
+    get ignoreGitMergeBase(): boolean;
+    set ignoreGitMergeBase(ignoreGitMergeBase: boolean);
+    getIgnoreGitMergeBase(): boolean;
+    setIgnoreGitMergeBase(ignoreGitMergeBase: boolean): this;
+    get ignoreBaseline(): boolean;
+    set ignoreBaseline(ignoreBaseline: boolean);
+    getIgnoreBaseline(): boolean;
+    setIgnoreBaseline(ignoreBaseline: boolean): this;
+    get saveFailedTests(): boolean;
+    set saveFailedTests(saveFailedTests: boolean);
+    getSaveFailedTests(): boolean;
+    setSaveFailedTests(saveFailedTests: boolean): this;
+    get saveNewTests(): boolean;
+    set saveNewTests(saveNewTests: boolean);
+    getSaveNewTests(): boolean;
+    setSaveNewTests(saveNewTests: boolean): this;
+    get saveDiffs(): boolean;
+    set saveDiffs(saveDiffs: boolean);
+    getSaveDiffs(): boolean;
+    setSaveDiffs(saveDiffs: boolean): this;
+    get sendDom(): boolean;
+    set sendDom(sendDom: boolean);
+    getSendDom(): boolean;
+    setSendDom(sendDom: boolean): this;
+    get hostApp(): string;
+    set hostApp(hostApp: string);
+    getHostApp(): string;
+    setHostApp(hostApp: string): this;
+    get hostOS(): string;
+    set hostOS(hostOS: string);
+    getHostOS(): string;
+    setHostOS(hostOS: string): this;
+    get hostAppInfo(): string;
+    set hostAppInfo(hostAppInfo: string);
+    getHostAppInfo(): string;
+    setHostAppInfo(hostAppInfo: string): this;
+    get hostOSInfo(): string;
+    set hostOSInfo(hostOSInfo: string);
+    getHostOSInfo(): string;
+    setHostOSInfo(hostOSInfo: string): this;
+    get deviceInfo(): string;
+    set deviceInfo(deviceInfo: string);
+    getDeviceInfo(): string;
+    setDeviceInfo(deviceInfo: string): this;
+    get defaultMatchSettings(): ImageMatchSettings;
+    set defaultMatchSettings(defaultMatchSettings: ImageMatchSettings);
+    getDefaultMatchSettings(): ImageMatchSettings;
+    setDefaultMatchSettings(defaultMatchSettings: ImageMatchSettings): this;
+    getMatchLevel(): MatchLevelEnum;
+    setMatchLevel(matchLevel: MatchLevel): this;
+    getAccessibilityValidation(): AccessibilitySettings;
+    setAccessibilityValidation(accessibilityValidation: AccessibilitySettings): this;
+    getUseDom(): boolean;
+    setUseDom(useDom: boolean): this;
+    getEnablePatterns(): boolean;
+    setEnablePatterns(enablePatterns: boolean): this;
+    getIgnoreDisplacements(): boolean;
+    setIgnoreDisplacements(ignoreDisplacements: boolean): this;
+    getIgnoreCaret(): boolean;
+    setIgnoreCaret(ignoreCaret: boolean): this;
+    get forceFullPageScreenshot(): boolean;
+    set forceFullPageScreenshot(forceFullPageScreenshot: boolean);
+    getForceFullPageScreenshot(): boolean;
+    setForceFullPageScreenshot(forceFullPageScreenshot: boolean): this;
+    get waitBeforeScreenshots(): number;
+    set waitBeforeScreenshots(waitBeforeScreenshots: number);
+    getWaitBeforeScreenshots(): number;
+    setWaitBeforeScreenshots(waitBeforeScreenshots: number): this;
+    get waitBeforeCapture(): number;
+    set waitBeforeCapture(waitBeforeCapture: number);
+    getWaitBeforeCapture(): number;
+    setWaitBeforeCapture(waitBeforeCapture: number): this;
+    get stitchMode(): StitchMode;
+    set stitchMode(stitchMode: StitchMode);
+    getStitchMode(): StitchModeEnum;
+    setStitchMode(stitchMode: StitchMode): this;
+    get hideScrollbars(): boolean;
+    set hideScrollbars(hideScrollbars: boolean);
+    getHideScrollbars(): boolean;
+    setHideScrollbars(hideScrollbars: boolean): this;
+    get hideCaret(): boolean;
+    set hideCaret(hideCaret: boolean);
+    getHideCaret(): boolean;
+    setHideCaret(hideCaret: boolean): this;
+    get stitchOverlap(): number;
+    set stitchOverlap(stitchOverlap: number);
+    getStitchOverlap(): number;
+    setStitchOverlap(stitchOverlap: number): this;
+    get scrollRootElement(): TSpec['element'] | EyesSelector<TSpec['selector']>;
+    set scrollRootElement(scrollRootElement: TSpec['element'] | EyesSelector<TSpec['selector']>);
+    getScrollRootElement(): TSpec['element'] | EyesSelector<TSpec['selector']>;
+    setScrollRootElement(scrollRootElement: TSpec['element'] | EyesSelector<TSpec['selector']>): this;
+    get cut(): CutProvider;
+    set cut(cut: CutProvider);
+    getCut(): CutProvider;
+    setCut(cut: CutProvider): this;
+    get rotation(): ImageRotation;
+    set rotation(rotation: ImageRotation);
+    getRotation(): ImageRotationData;
+    setRotation(rotation: ImageRotation | ImageRotationData): this;
+    get scaleRatio(): number;
+    set scaleRatio(scaleRatio: number);
+    getScaleRatio(): number;
+    setScaleRatio(scaleRatio: number): this;
+    /** @undocumented */
+    get concurrentSessions(): number;
+    /** @undocumented */
+    set concurrentSessions(concurrentSessions: number);
+    /** @undocumented */
+    getConcurrentSessions(): number;
+    /** @undocumented */
+    setConcurrentSessions(concurrentSessions: number): this;
+    get browsersInfo(): (DesktopBrowserInfo | ChromeEmulationInfo | IOSDeviceInfo | AndroidDeviceInfo)[];
+    set browsersInfo(browsersInfo: (DesktopBrowserInfo | ChromeEmulationInfo | IOSDeviceInfo | AndroidDeviceInfo)[]);
+    getBrowsersInfo(): RenderInfo[];
+    setBrowsersInfo(browsersInfo: RenderInfo[]): this;
+    addBrowsers(...browsersInfo: RenderInfo[]): this;
+    addBrowser(browserInfo: RenderInfo): this;
+    addBrowser(width: number, height: number, name?: BrowserType): this;
+    addDeviceEmulation(deviceName: DeviceName, screenOrientation?: ScreenOrientation): this;
+    addMobileDevice(deviceName: AndroidDeviceName, screenOrientation: ScreenOrientation, version?: AndroidVersion): this;
+    addMobileDevice(deviceName: IosDeviceName, screenOrientation: ScreenOrientation, version?: IosVersion): this;
+    get visualGridOptions(): {
+        [key: string]: any;
+    };
+    set visualGridOptions(visualGridOptions: {
+        [key: string]: any;
+    });
+    getVisualGridOptions(): {
+        [key: string]: any;
+    };
+    setVisualGridOptions(visualGridOptions: {
+        [key: string]: any;
+    }): this;
+    setVisualGridOption(key: string, value: any): this;
+    get layoutBreakpoints(): boolean | number[] | {
+        breakpoints: number[] | boolean;
+        reload?: boolean;
+    };
+    set layoutBreakpoints(layoutBreakpoints: boolean | number[] | {
+        breakpoints: number[] | boolean;
+        reload?: boolean;
+    });
+    getLayoutBreakpoints(): boolean | number[] | {
+        breakpoints: number[] | boolean;
+        reload?: boolean;
+    };
+    setLayoutBreakpoints(layoutBreakpoints: boolean | number[] | {
+        breakpoints: number[] | boolean;
+        reload?: boolean;
+    }): this;
+    get disableBrowserFetching(): boolean;
+    set disableBrowserFetching(disableBrowserFetching: boolean);
+    getDisableBrowserFetching(): boolean;
+    setDisableBrowserFetching(disableBrowserFetching: boolean): this;
+    /** @undocumented */
+    get dontCloseBatches(): boolean;
+    /** @undocumented */
+    set dontCloseBatches(dontCloseBatches: boolean);
+    /** @undocumented */
+    getDontCloseBatches(): boolean;
+    /** @undocumented */
+    setDontCloseBatches(dontCloseBatches: boolean): this;
+    /** @internal */
+    toObject(): Configuration<TSpec>;
+    /** @internal */
+    toJSON(): Core.Config<TSpec, 'classic'> & Core.Config<TSpec, 'ufg'>;
+    /** @internal */
+    toString(): string;
+}
+export {};

package/types/input/CutProvider.d.ts

@@ -0,0 +1,44 @@
+type CutProviderRect = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+type CutProviderRegion = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type CutProvider = CutProviderRect | CutProviderRegion;
+export declare class CutProviderData implements Required<CutProviderRegion & CutProviderRect> {
+    private _region?;
+    private _rect?;
+    constructor(rectOrRegion: CutProvider);
+    constructor(top: number, bottom: number, left: number, right: number);
+    get top(): number;
+    get right(): number;
+    get bottom(): number;
+    get left(): number;
+    get width(): number;
+    get height(): number;
+    get x(): number;
+    get y(): number;
+    scale(scaleRatio: number): CutProviderData;
+    /** @internal */
+    toObject(): CutProvider;
+    /** @internal */
+    toJSON(): CutProvider;
+    /** @internal */
+    toString(): string;
+}
+export declare class FixedCutProviderData extends CutProviderData {
+}
+/** @undocumented */
+export declare class UnscaledFixedCutProviderData extends CutProviderData {
+    scale(): UnscaledFixedCutProviderData;
+}
+export declare class NullCutProviderData extends CutProviderData {
+    constructor();
+}
+export {};

package/types/input/DebugScreenshotProvider.d.ts

@@ -0,0 +1,5 @@
+export type DebugScreenshotProvider = {
+    save: boolean;
+    path?: string;
+    prefix?: string;
+};

package/types/input/DensityMetrics.d.ts

@@ -0,0 +1,5 @@
+export type DensityMetrics = {
+    scaleRatio?: number;
+    xdpi?: number;
+    ydpi?: number;
+};

package/types/input/ExactMatchSettings.d.ts

@@ -0,0 +1,34 @@
+/** @undocumented */
+export type ExactMatchSettings = {
+    minDiffIntensity: number;
+    minDiffWidth: number;
+    minDiffHeight: number;
+    matchThreshold: number;
+};
+/** @undocumented */
+export declare class ExactMatchSettingsData implements Required<ExactMatchSettings> {
+    private _settings;
+    constructor(settings: ExactMatchSettings);
+    get minDiffIntensity(): number;
+    set minDiffIntensity(minDiffIntensity: number);
+    getMinDiffIntensity(): number;
+    setMinDiffIntensity(value: number): void;
+    get minDiffWidth(): number;
+    set minDiffWidth(minDiffWidth: number);
+    getMinDiffWidth(): number;
+    setMinDiffWidth(value: number): void;
+    get minDiffHeight(): number;
+    set minDiffHeight(minDiffHeight: number);
+    getMinDiffHeight(): number;
+    setMinDiffHeight(value: number): void;
+    get matchThreshold(): number;
+    set matchThreshold(matchThreshold: number);
+    getMatchThreshold(): number;
+    setMatchThreshold(value: number): void;
+    /** @internal */
+    toObject(): ExactMatchSettings;
+    /** @internal */
+    toJSON(): ExactMatchSettings;
+    /** @internal */
+    toString(): string;
+}

package/types/input/EyesSelector.d.ts

@@ -0,0 +1,6 @@
+export type EyesSelector<TSelector = never> = TSelector | string | {
+    selector: TSelector | string;
+    type?: string;
+    shadow?: EyesSelector<TSelector>;
+    frame?: EyesSelector<TSelector>;
+};

package/types/input/FloatingMatchSettings.d.ts

@@ -0,0 +1,50 @@
+import { Region, RegionData } from './Region';
+/** @undocumented */
+export type FloatingMatchSettings = {
+    region: Region;
+    maxUpOffset?: number;
+    maxDownOffset?: number;
+    maxLeftOffset?: number;
+    maxRightOffset?: number;
+};
+/** @undocumented */
+export declare class FloatingMatchSettingsData implements Required<FloatingMatchSettings> {
+    private _settings;
+    constructor(settings: FloatingMatchSettings);
+    constructor(region: Region);
+    constructor(x: number, y: number, width: number, height: number, maxUpOffset?: number, maxDownOffset?: number, maxLeftOffset?: number, maxRightOffset?: number);
+    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 maxUpOffset(): number;
+    set maxUpOffset(maxUpOffset: number);
+    getMaxUpOffset(): number;
+    setMaxUpOffset(maxUpOffset: number): void;
+    get maxDownOffset(): number;
+    set maxDownOffset(maxDownOffset: number);
+    getMaxDownOffset(): number;
+    setMaxDownOffset(maxDownOffset: number): void;
+    get maxLeftOffset(): number;
+    set maxLeftOffset(maxLeftOffset: number);
+    getMaxLeftOffset(): number;
+    setMaxLeftOffset(maxLeftOffset: number): void;
+    get maxRightOffset(): number;
+    set maxRightOffset(maxRightOffset: number);
+    getMaxRightOffset(): number;
+    setMaxRightOffset(maxRightOffset: number): void;
+    /** @internal */
+    toObject(): FloatingMatchSettings;
+    /** @internal */
+    toJSON(): FloatingMatchSettings;
+    /** @internal */
+    toString(): string;
+}

package/types/input/Image.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { RectangleSize } from './RectangleSize';
+import { Location } from './Location';
+export type Image = {
+    image: Buffer | URL | string;
+    name?: string;
+    dom?: string;
+    locationInViewport?: Location;
+    locationInView?: Location;
+    fullViewSize?: RectangleSize;
+};

package/types/input/ImageMatchSettings.d.ts

@@ -0,0 +1,95 @@
+import { MatchLevel, MatchLevelEnum } from '../enums/MatchLevel';
+import { ExactMatchSettings, ExactMatchSettingsData } from './ExactMatchSettings';
+import { FloatingMatchSettings, FloatingMatchSettingsData } from './FloatingMatchSettings';
+import { AccessibilityMatchSettings, AccessibilityMatchSettingsData } from './AccessibilityMatchSettings';
+import { Region, RegionData } from './Region';
+import { AccessibilitySettings } from './AccessibilitySettings';
+/** @undocumented */
+export type ImageMatchSettings = {
+    exact?: ExactMatchSettings;
+    matchLevel?: MatchLevel;
+    ignoreCaret?: boolean;
+    useDom?: boolean;
+    enablePatterns?: boolean;
+    ignoreDisplacements?: boolean;
+    ignoreRegions?: Region[];
+    layoutRegions?: Region[];
+    strictRegions?: Region[];
+    contentRegions?: Region[];
+    floatingRegions?: (Region | FloatingMatchSettings)[];
+    accessibilityRegions?: (Region | AccessibilityMatchSettings)[];
+    accessibilitySettings?: AccessibilitySettings;
+};
+/** @undocumented */
+export declare class ImageMatchSettingsData implements Required<ImageMatchSettings> {
+    private _settings;
+    constructor(settings?: ImageMatchSettings);
+    get exact(): ExactMatchSettings;
+    set exact(exact: ExactMatchSettings);
+    getExact(): ExactMatchSettingsData;
+    setExact(exact: ExactMatchSettings): void;
+    get matchLevel(): MatchLevel;
+    set matchLevel(matchLevel: MatchLevel);
+    getMatchLevel(): MatchLevelEnum;
+    setMatchLevel(matchLevel: MatchLevel): void;
+    get ignoreCaret(): boolean;
+    set ignoreCaret(ignoreCaret: boolean);
+    getIgnoreCaret(): boolean;
+    setIgnoreCaret(ignoreCaret: boolean): void;
+    get useDom(): boolean;
+    set useDom(useDom: boolean);
+    getUseDom(): boolean;
+    setUseDom(useDom: boolean): void;
+    get enablePatterns(): boolean;
+    set enablePatterns(enablePatterns: boolean);
+    getEnablePatterns(): boolean;
+    setEnablePatterns(enablePatterns: boolean): void;
+    get ignoreDisplacements(): boolean;
+    set ignoreDisplacements(ignoreDisplacements: boolean);
+    getIgnoreDisplacements(): boolean;
+    setIgnoreDisplacements(ignoreDisplacements: boolean): void;
+    get ignoreRegions(): Region[];
+    set ignoreRegions(ignoreRegions: Region[]);
+    getIgnoreRegions(): RegionData[];
+    setIgnoreRegions(ignoreRegions: Region[]): void;
+    get layoutRegions(): Region[];
+    set layoutRegions(layoutRegions: Region[]);
+    get layout(): Region[];
+    set layout(layoutRegions: Region[]);
+    getLayoutRegions(): RegionData[];
+    setLayoutRegions(layoutRegions: Region[]): void;
+    get strictRegions(): Region[];
+    set strictRegions(strictRegions: Region[]);
+    get strict(): Region[];
+    set strict(strictRegions: Region[]);
+    getStrictRegions(): RegionData[];
+    setStrictRegions(strictRegions: Region[]): void;
+    get contentRegions(): Region[];
+    set contentRegions(contentRegions: Region[]);
+    get content(): Region[];
+    set content(contentRegions: Region[]);
+    getContentRegions(): RegionData[];
+    setContentRegions(contentRegions: Region[]): void;
+    get floatingRegions(): (Region | FloatingMatchSettings)[];
+    set floatingRegions(floatingRegions: (Region | FloatingMatchSettings)[]);
+    get floating(): (Region | FloatingMatchSettings)[];
+    set floating(floatingRegions: (Region | FloatingMatchSettings)[]);
+    getFloatingRegions(): FloatingMatchSettingsData[];
+    setFloatingRegions(floatingRegions: FloatingMatchSettings[]): void;
+    get accessibilityRegions(): (Region | AccessibilityMatchSettings)[];
+    set accessibilityRegions(accessibilityRegions: (Region | AccessibilityMatchSettings)[]);
+    get accessibility(): (Region | AccessibilityMatchSettings)[];
+    set accessibility(accessibilityRegions: (Region | AccessibilityMatchSettings)[]);
+    getAccessibilityRegions(): AccessibilityMatchSettingsData[];
+    setAccessibilityRegions(accessibilityRegions: AccessibilityMatchSettings[]): void;
+    get accessibilitySettings(): AccessibilitySettings;
+    set accessibilitySettings(accessibilitySettings: AccessibilitySettings);
+    getAccessibilitySettings(): AccessibilitySettings;
+    setAccessibilitySettings(accessibilitySettings: AccessibilitySettings): void;
+    /** @internal */
+    toObject(): ImageMatchSettings;
+    /** @internal */
+    toJSON(): ImageMatchSettings;
+    /** @internal */
+    toString(): string;
+}

package/types/input/ImageRotation.d.ts

@@ -0,0 +1,15 @@
+export type ImageRotation = -270 | -180 | -90 | 0 | 90 | 180 | 270;
+export declare class ImageRotationData {
+    private _rotation;
+    constructor(rotation: ImageRotation);
+    get rotation(): ImageRotation;
+    set rotation(rotation: ImageRotation);
+    getRotation(): ImageRotation;
+    setRotation(rotation: ImageRotation): void;
+    /** @internal */
+    [Symbol.toPrimitive](): ImageRotation;
+    /** @internal */
+    toJSON(): number;
+    /** @internal */
+    toString(): string;
+}

package/types/input/LazyLoadOptions.d.ts

@@ -0,0 +1,5 @@
+export type LazyLoadOptions = {
+    scrollLength?: number;
+    waitingTime?: number;
+    maxAmountToScroll?: number;
+};

package/types/input/Location.d.ts

@@ -0,0 +1,23 @@
+export type Location = {
+    x: number;
+    y: number;
+};
+export declare class LocationData implements Required<Location> {
+    private _location;
+    constructor(location: Location);
+    constructor(x: number, y: number);
+    get x(): number;
+    set x(x: number);
+    getX(): number;
+    setX(x: number): void;
+    get y(): number;
+    set y(y: number);
+    getY(): number;
+    setY(y: number): void;
+    /** @internal */
+    toObject(): Location;
+    /** @internal */
+    toJSON(): Location;
+    /** @internal */
+    toString(): string;
+}