@applitools/eyes 1.33.3 → 1.33.4

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/LatestCommitInfo.d.ts

@@ -0,0 +1,4 @@
+export type LatestCommitInfo = {
+    timestamp: string;
+    sha: 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;
+}

package/types/input/LogHandler.d.ts

@@ -0,0 +1,45 @@
+import * as logger from '@applitools/logger';
+export type LogHandler = CustomLogHandler | FileLogHandler | ConsoleLogHandler;
+export type CustomLogHandler = logger.CustomHandler;
+export type FileLogHandler = logger.FileHandler;
+export type ConsoleLogHandler = logger.ConsoleHandler;
+export declare abstract class LogHandlerData implements CustomLogHandler {
+    private _verbose;
+    constructor(verbose?: boolean);
+    get verbose(): boolean;
+    set verbose(verbose: boolean);
+    getIsVerbose(): boolean;
+    setIsVerbose(verbose: boolean): void;
+    log(message: string): void;
+    abstract onMessage(message: string): void;
+    abstract open(): void;
+    abstract close(): void;
+    /** @internal */
+    toJSON(): LogHandler;
+}
+export declare class FileLogHandlerData extends LogHandlerData implements FileLogHandler {
+    readonly type = "file";
+    readonly filename: string;
+    readonly append: boolean;
+    constructor(verbose?: boolean, filename?: string, append?: boolean);
+    onMessage(): void;
+    open(): void;
+    close(): void;
+    /** @internal */
+    toJSON(): LogHandler;
+}
+export declare class ConsoleLogHandlerData extends LogHandlerData implements ConsoleLogHandler {
+    readonly type = "console";
+    onMessage(): void;
+    open(): void;
+    close(): void;
+    /** @internal */
+    toJSON(): LogHandler;
+}
+export declare class NullLogHandlerData extends LogHandlerData {
+    onMessage(): void;
+    open(): void;
+    close(): void;
+    /** @internal */
+    toJSON(): LogHandler;
+}

package/types/input/OCRRegion.d.ts

@@ -0,0 +1,9 @@
+import type { SpecType } from '@applitools/core';
+import { EyesSelector } from './EyesSelector';
+import { Region } from './Region';
+export type OCRRegion<TSpec extends SpecType = SpecType> = {
+    target: Region | TSpec['element'] | EyesSelector<TSpec['selector']>;
+    hint?: string;
+    minMatch?: number;
+    language?: string;
+};

package/types/input/OCRSettings.d.ts

@@ -0,0 +1,6 @@
+export type OCRSettings<TPattern extends string = string> = {
+    patterns: TPattern[];
+    ignoreCase?: boolean;
+    firstOnly?: boolean;
+    language?: string;
+};

package/types/input/PropertyData.d.ts

@@ -0,0 +1,23 @@
+export type PropertyData = {
+    name: string;
+    value: string;
+};
+export declare class PropertyDataData implements Required<PropertyData> {
+    private _property;
+    constructor(property: PropertyData);
+    constructor(name: string, value: string);
+    get name(): string;
+    set name(name: string);
+    getName(): string;
+    setName(name: string): void;
+    get value(): string;
+    set value(value: string);
+    getValue(): string;
+    setValue(value: string): void;
+    /** @internal */
+    toObject(): PropertyData;
+    /** @internal */
+    toJSON(): PropertyData;
+    /** @internal */
+    toString(): string;
+}

package/types/input/ProxySettings.d.ts

@@ -0,0 +1,25 @@
+export type ProxySettings = {
+    url: string;
+    username?: string;
+    password?: string;
+};
+export declare class ProxySettingsData implements Required<ProxySettings> {
+    private _proxy;
+    constructor(proxy: ProxySettings);
+    constructor(url: string, username?: string, password?: string, deprecatedIsHttpOnly?: boolean);
+    get url(): string;
+    getUri(): string;
+    getUrl(): string;
+    get username(): string;
+    getUsername(): string;
+    get password(): string;
+    getPassword(): string;
+    get isHttpOnly(): boolean;
+    getIsHttpOnly(): boolean;
+    /** @internal */
+    toObject(): ProxySettings;
+    /** @internal */
+    toJSON(): ProxySettings;
+    /** @internal */
+    toString(): string;
+}

package/types/input/RectangleSize.d.ts

@@ -0,0 +1,23 @@
+export type RectangleSize = {
+    width: number;
+    height: number;
+};
+export declare class RectangleSizeData implements Required<RectangleSize> {
+    private _size;
+    constructor(size: RectangleSize);
+    constructor(width: number, height: number);
+    get width(): number;
+    set width(width: number);
+    getWidth(): number;
+    setWidth(width: number): void;
+    get height(): number;
+    set height(height: number);
+    getHeight(): number;
+    setHeight(height: number): void;
+    /** @internal */
+    toObject(): RectangleSize;
+    /** @internal */
+    toJSON(): RectangleSize;
+    /** @internal */
+    toString(): string;
+}

package/types/input/Region.d.ts

@@ -0,0 +1,46 @@
+import { Location } from './Location';
+import { RectangleSize } from './RectangleSize';
+/** @deprecated */
+export type LegacyRegion = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export type Region = Location & RectangleSize;
+export declare class RegionData implements Required<Region> {
+    private _region;
+    constructor(region: Region);
+    constructor(location: Location, size: RectangleSize);
+    constructor(x: number, y: number, width: number, height: number);
+    get x(): number;
+    set x(x: number);
+    get left(): number;
+    set left(left: number);
+    getX(): number;
+    setX(x: number): void;
+    getLeft(): number;
+    setLeft(left: number): void;
+    get y(): number;
+    set y(y: number);
+    get top(): number;
+    set top(top: number);
+    getY(): number;
+    setY(y: number): void;
+    getTop(): number;
+    setTop(top: number): void;
+    get width(): number;
+    set width(width: number);
+    getWidth(): number;
+    setWidth(width: number): void;
+    get height(): number;
+    set height(height: number);
+    getHeight(): number;
+    setHeight(height: number): void;
+    /** @internal */
+    toObject(): Region;
+    /** @internal */
+    toJSON(): Region;
+    /** @internal */
+    toString(): string;
+}

package/types/input/RenderInfo.d.ts

@@ -0,0 +1,47 @@
+import { BrowserType } from '../enums/BrowserType';
+import { DeviceName } from '../enums/DeviceName';
+import { IosDeviceName } from '../enums/IosDeviceName';
+import { IosVersion } from '../enums/IosVersion';
+import { ScreenOrientation } from '../enums/ScreenOrientation';
+import { IosMultiDeviceTarget } from '../enums/IosMultiDeviceTarget';
+type RenderInfoBase = {
+    /** @internal */
+    hostOS?: string;
+    /** @internal */
+    hostOSInfo?: string;
+    /** @internal */
+    hostApp?: string;
+    /** @internal */
+    hostAppInfo?: string;
+};
+export type DesktopBrowserInfo = {
+    name?: BrowserType;
+    width: number;
+    height: number;
+};
+export type ChromeEmulationInfo = {
+    chromeEmulationInfo: {
+        deviceName: DeviceName;
+        screenOrientation?: ScreenOrientation;
+    };
+};
+/** @deprecated */
+export type ChromeEmulationInfoLegacy = {
+    deviceName: DeviceName;
+    screenOrientation?: ScreenOrientation;
+};
+export type IOSDeviceInfo = {
+    iosDeviceInfo: {
+        deviceName: IosDeviceName;
+        iosVersion?: IosVersion;
+        screenOrientation?: ScreenOrientation;
+    };
+};
+export type IOSMultiDeviceInfo = {
+    iosDeviceInfo: {
+        deviceName: IosMultiDeviceTarget;
+    };
+};
+export type RenderInfoLegacy = RenderInfoBase & (DesktopBrowserInfo | ChromeEmulationInfo | IOSDeviceInfo | ChromeEmulationInfoLegacy);
+export type RenderInfo = RenderInfoBase & (DesktopBrowserInfo | ChromeEmulationInfo | IOSDeviceInfo | IOSMultiDeviceInfo);
+export {};

package/types/input/RunnerOptions.d.ts

@@ -0,0 +1,21 @@
+export type RunnerOptions = {
+    testConcurrency?: number;
+    fetchConcurrency?: number;
+    /** @internal */
+    legacyConcurrency?: number;
+    removeDuplicateTests?: boolean;
+    maskLog?: boolean;
+};
+/** @deprecated */
+export declare class RunnerOptionsFluent {
+    private _options;
+    testConcurrency(concurrency: number): this;
+    /** @internal */
+    toObject(): RunnerOptions;
+    /** @internal */
+    toJSON(): RunnerOptions;
+    /** @internal */
+    toString(): string;
+}
+/** @deprecated */
+export declare function RunnerOptionsFluentInit(): RunnerOptionsFluent;

package/types/input/VisualLocatorSettings.d.ts

@@ -0,0 +1,4 @@
+export type VisualLocatorSettings<TLocator extends string = string> = {
+    locatorNames: TLocator[];
+    firstOnly: boolean;
+};

package/types/output/ApiUrls.d.ts

@@ -0,0 +1,41 @@
+export type ApiUrls = {
+    readonly baselineImage: string;
+    readonly currentImage: string;
+    readonly checkpointImage: string;
+    readonly checkpointImageThumbnail: string;
+    readonly diffImage: string;
+    readonly sideBySideImage: string;
+};
+export declare class ApiUrlsData implements Required<ApiUrls> {
+    private _urls;
+    /** @internal */
+    constructor(urls: ApiUrls);
+    get baselineImage(): string;
+    getBaselineImage(): string;
+    /** @deprecated */
+    setBaselineImage(setBaselineImage: string): void;
+    get currentImage(): string;
+    getCurrentImage(): string;
+    /** @deprecated */
+    setCurrentImage(currentImage: string): void;
+    get checkpointImage(): string;
+    getCheckpointImage(): string;
+    /** @deprecated */
+    setCheckpointImage(checkpointImage: string): void;
+    get checkpointImageThumbnail(): string;
+    getCheckpointImageThumbnail(): string;
+    /** @deprecated */
+    setCheckpointImageThumbnail(checkpointImageThumbnail: string): void;
+    get diffImage(): string;
+    getDiffImage(): string;
+    /** @deprecated */
+    setDiffImage(diffImage: string): void;
+    get sideBySideImage(): string;
+    getSideBySideImage(): string;
+    /** @internal */
+    toObject(): ApiUrls;
+    /** @internal */
+    toJSON(): ApiUrls;
+    /** @internal */
+    toString(): string;
+}

package/types/output/AppUrls.d.ts

@@ -0,0 +1,23 @@
+export type AppUrls = {
+    readonly step: string;
+    readonly stepEditor: string;
+};
+export declare class AppUrlsData implements Required<AppUrls> {
+    private _urls;
+    /** @internal */
+    constructor(urls: AppUrls);
+    get step(): string;
+    getStep(): string;
+    /** @deprecated */
+    setStep(step: string): void;
+    get stepEditor(): string;
+    getStepEditor(): string;
+    /** @deprecated */
+    setStepEditor(stepEditor: string): void;
+    /** @internal */
+    toObject(): AppUrls;
+    /** @internal */
+    toJSON(): AppUrls;
+    /** @internal */
+    toString(): string;
+}

package/types/output/MatchResult.d.ts

@@ -0,0 +1,23 @@
+export type MatchResult = {
+    readonly asExpected?: boolean;
+    readonly windowId?: number;
+};
+export declare class MatchResultData implements Required<MatchResult> {
+    private _result;
+    /** @internal */
+    constructor(result: MatchResult);
+    get asExpected(): boolean;
+    getAsExpected(): boolean;
+    /** @deprecated */
+    setAsExpected(asExpected: boolean): void;
+    get windowId(): number;
+    getWindowId(): number;
+    /** @deprecated */
+    setWindowId(windowId: number): void;
+    /** @internal */
+    toObject(): MatchResult;
+    /** @internal */
+    toJSON(): MatchResult;
+    /** @internal */
+    toString(): string;
+}

package/types/output/SessionUrls.d.ts

@@ -0,0 +1,23 @@
+export type SessionUrls = {
+    readonly batch: string;
+    readonly session: string;
+};
+export declare class SessionUrlsData implements Required<SessionUrls> {
+    private _urls;
+    /** @internal */
+    constructor(urls: SessionUrls);
+    get batch(): string;
+    getBatch(): string;
+    /** @deprecated */
+    setBatch(batch: string): void;
+    get session(): string;
+    getSession(): string;
+    /** @deprecated */
+    setSession(session: string): void;
+    /** @internal */
+    toObject(): SessionUrls;
+    /** @internal */
+    toJSON(): SessionUrls;
+    /** @internal */
+    toString(): string;
+}

package/types/output/StepInfo.d.ts

@@ -0,0 +1,50 @@
+import { AppUrls, AppUrlsData } from './AppUrls';
+import { ApiUrls, ApiUrlsData } from './ApiUrls';
+export type StepInfo = {
+    readonly name: string;
+    readonly isDifferent: boolean;
+    readonly hasBaselineImage: boolean;
+    readonly hasCurrentImage: boolean;
+    readonly appUrls: AppUrls;
+    readonly apiUrls: ApiUrls;
+    readonly renderId: string[];
+};
+export declare class StepInfoData implements Required<StepInfo> {
+    private _info;
+    /** @internal */
+    constructor(info: StepInfo);
+    get name(): string;
+    getName(): string;
+    /** @deprecated */
+    setName(value: string): void;
+    get isDifferent(): boolean;
+    getIsDifferent(): boolean;
+    /** @deprecated */
+    setIsDifferent(value: boolean): void;
+    get hasBaselineImage(): boolean;
+    getHasBaselineImage(): boolean;
+    /** @deprecated */
+    setHasBaselineImage(value: boolean): void;
+    get hasCurrentImage(): boolean;
+    getHasCurrentImage(): boolean;
+    /** @deprecated */
+    setHasCurrentImage(hasCurrentImage: boolean): void;
+    get appUrls(): AppUrls;
+    getAppUrls(): AppUrlsData;
+    /** @deprecated */
+    setAppUrls(appUrls: AppUrls): void;
+    get apiUrls(): ApiUrls;
+    getApiUrls(): ApiUrlsData;
+    /** @deprecated */
+    setApiUrls(apiUrls: ApiUrls): void;
+    get renderId(): string[];
+    getRenderId(): string[];
+    /** @deprecated */
+    setRenderId(renderId: string[]): void;
+    /** @internal */
+    toObject(): StepInfo;
+    /** @internal */
+    toJSON(): StepInfo;
+    /** @internal */
+    toString(): string;
+}

package/types/output/TestAccessibilityStatus.d.ts

@@ -0,0 +1,8 @@
+import { AccessibilityStatus } from '../enums/AccessibilityStatus';
+import { AccessibilityLevel } from '../enums/AccessibilityLevel';
+import { AccessibilityGuidelinesVersion } from '../enums/AccessibilityGuidelinesVersion';
+export type TestAccessibilityStatus = {
+    readonly status: AccessibilityStatus;
+    readonly level: AccessibilityLevel;
+    readonly version: AccessibilityGuidelinesVersion;
+};

package/types/output/TestResultContainer.d.ts

@@ -0,0 +1,31 @@
+import type * as Core from '@applitools/core';
+import { TestResults, TestResultsData } from './TestResults';
+import { ChromeEmulationInfo, ChromeEmulationInfoLegacy, DesktopBrowserInfo, IOSDeviceInfo } from '../input/RenderInfo';
+type RenderInfo = DesktopBrowserInfo | ChromeEmulationInfo | IOSDeviceInfo | ChromeEmulationInfoLegacy;
+export type TestResultContainer = {
+    readonly exception?: Error;
+    readonly testResults?: TestResults;
+    readonly browserInfo?: RenderInfo;
+};
+export declare class TestResultContainerData implements Required<TestResultContainer> {
+    private _container;
+    private _core?;
+    /** @internal */
+    constructor(options: {
+        container: Core.TestResultContainer<'classic' | 'ufg'>;
+        core?: Core.Core<Core.SpecType, 'classic' | 'ufg'>;
+    });
+    get testResults(): TestResults;
+    getTestResults(): TestResultsData;
+    get exception(): Error;
+    getException(): Error;
+    get browserInfo(): RenderInfo;
+    getBrowserInfo(): RenderInfo;
+    /** @internal */
+    toObject(): TestResultContainer;
+    /** @internal */
+    toJSON(): Core.TestResultContainer<'classic' | 'ufg'>;
+    /** @internal */
+    toString(): string;
+}
+export {};