@applitools/eyes-browser 1.0.0

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,37 @@
+import { BrowserType } from '../enums/BrowserType';
+import { DeviceName } from '../enums/DeviceName';
+import { IosDeviceName } from '../enums/IosDeviceName';
+import { IosVersion } from '../enums/IosVersion';
+import { AndroidDeviceName } from '../enums/AndroidDeviceName';
+import { AndroidVersion } from '../enums/AndroidVersion';
+import { ScreenOrientation } from '../enums/ScreenOrientation';
+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 AndroidDeviceInfo = {
+    androidDeviceInfo: {
+        deviceName: AndroidDeviceName;
+        version?: AndroidVersion;
+        screenOrientation?: ScreenOrientation;
+    };
+};

package/types/input/RunnerOptions.d.ts

@@ -0,0 +1,20 @@
+export type RunnerOptions = {
+    testConcurrency?: number;
+    fetchConcurrency?: number;
+    /** @internal */
+    legacyConcurrency?: number;
+    removeDuplicateTests?: 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,38 @@
+export type ApiUrls = {
+    readonly baselineImage: string;
+    readonly currentImage: string;
+    readonly checkpointImage: string;
+    readonly checkpointImageThumbnail: string;
+    readonly diffImage: 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;
+    /** @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 { AndroidDeviceInfo, ChromeEmulationInfo, ChromeEmulationInfoLegacy, DesktopBrowserInfo, IOSDeviceInfo } from '../input/RenderInfo';
+type RenderInfo = DesktopBrowserInfo | ChromeEmulationInfo | IOSDeviceInfo | AndroidDeviceInfo | 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 {};

package/types/output/TestResults.d.ts

@@ -0,0 +1,186 @@
+import type * as Core from '@applitools/core';
+import { TestResultsStatus, TestResultsStatusEnum } from '../enums/TestResultsStatus';
+import { ProxySettings } from '../input/ProxySettings';
+import { RectangleSize, RectangleSizeData } from '../input/RectangleSize';
+import { TestAccessibilityStatus } from './TestAccessibilityStatus';
+import { SessionUrls, SessionUrlsData } from './SessionUrls';
+import { StepInfo, StepInfoData } from './StepInfo';
+export type TestResults = {
+    readonly id?: string;
+    readonly name?: string;
+    readonly secretToken?: string;
+    readonly status?: TestResultsStatus;
+    readonly appName?: string;
+    readonly batchId?: string;
+    readonly batchName?: string;
+    readonly branchName?: string;
+    readonly hostOS?: string;
+    readonly hostApp?: string;
+    readonly hostDisplaySize?: RectangleSize;
+    readonly accessibilityStatus?: TestAccessibilityStatus;
+    readonly startedAt?: string;
+    readonly duration?: number;
+    readonly isNew?: boolean;
+    readonly isDifferent?: boolean;
+    readonly isAborted?: boolean;
+    readonly appUrls?: SessionUrls;
+    readonly apiUrls?: SessionUrls;
+    readonly stepsInfo?: StepInfo[];
+    readonly steps?: number;
+    readonly matches?: number;
+    readonly mismatches?: number;
+    readonly missing?: number;
+    readonly exactMatches?: number;
+    readonly strictMatches?: number;
+    readonly contentMatches?: number;
+    readonly layoutMatches?: number;
+    readonly noneMatches?: number;
+    readonly url?: string;
+    readonly server?: {
+        eyesServerUrl: string;
+        apiKey: string;
+        proxy?: ProxySettings;
+    };
+    readonly keepIfDuplicate?: boolean;
+};
+export declare class TestResultsData implements Required<TestResults> {
+    private _core?;
+    private _result;
+    /** @internal */
+    constructor(options: {
+        result?: Partial<Core.TestResult<'classic' | 'ufg'>>;
+        core?: Core.Core<Core.SpecType, 'classic' | 'ufg'>;
+    });
+    get id(): string;
+    getId(): string;
+    /** @deprecated */
+    setId(_id: string): void;
+    get name(): string;
+    getName(): string;
+    /** @deprecated */
+    setName(_name: string): void;
+    get secretToken(): string;
+    getSecretToken(): string;
+    /** @deprecated */
+    setSecretToken(_secretToken: string): void;
+    get status(): TestResultsStatus;
+    getStatus(): TestResultsStatusEnum;
+    /** @deprecated */
+    setStatus(_status: TestResultsStatusEnum): void;
+    get appName(): string;
+    getAppName(): string;
+    /** @deprecated */
+    setAppName(_appName: string): void;
+    get batchName(): string;
+    getBatchName(): string;
+    /** @deprecated */
+    setBatchName(_batchName: string): void;
+    get batchId(): string;
+    getBatchId(): string;
+    /** @deprecated */
+    setBatchId(_batchId: string): void;
+    get branchName(): string;
+    getBranchName(): string;
+    /** @deprecated */
+    setBranchName(_branchName: string): void;
+    get hostOS(): string;
+    getHostOS(): string;
+    /** @deprecated */
+    setHostOS(_hostOS: string): void;
+    get hostApp(): string;
+    getHostApp(): string;
+    /** @deprecated */
+    setHostApp(_hostApp: string): void;
+    get hostDisplaySize(): RectangleSize;
+    getHostDisplaySize(): RectangleSizeData;
+    /** @deprecated */
+    setHostDisplaySize(_hostDisplaySize: RectangleSize): void;
+    get accessibilityStatus(): TestAccessibilityStatus;
+    getAccessibilityStatus(): TestAccessibilityStatus;
+    /** @deprecated */
+    setAccessibilityStatus(_accessibilityStatus: TestAccessibilityStatus): void;
+    get startedAt(): string;
+    getStartedAt(): Date;
+    /** @deprecated */
+    setStartedAt(_startedAt: Date | string): void;
+    get duration(): number;
+    getDuration(): number;
+    /** @deprecated */
+    setDuration(_duration: number): void;
+    get isNew(): boolean;
+    getIsNew(): boolean;
+    /** @deprecated */
+    setIsNew(_isNew: boolean): void;
+    get isDifferent(): boolean;
+    getIsDifferent(): boolean;
+    /** @deprecated */
+    setIsDifferent(_isDifferent: boolean): void;
+    get isAborted(): boolean;
+    getIsAborted(): boolean;
+    /** @deprecated */
+    setIsAborted(_isAborted: boolean): void;
+    get appUrls(): SessionUrls;
+    getAppUrls(): SessionUrlsData;
+    /** @deprecated */
+    setAppUrls(_appUrls: SessionUrls): void;
+    get apiUrls(): SessionUrls;
+    getApiUrls(): SessionUrlsData;
+    /** @deprecated */
+    setApiUrls(_apiUrls: SessionUrls): void;
+    get stepsInfo(): StepInfo[];
+    getStepsInfo(): StepInfoData[];
+    /** @deprecated */
+    setStepsInfo(_stepInfo: StepInfo[]): void;
+    get steps(): number;
+    getSteps(): number;
+    /** @deprecated */
+    setSteps(_steps: number): void;
+    get matches(): number;
+    getMatches(): number;
+    /** @deprecated */
+    setMatches(_matches: number): void;
+    get mismatches(): number;
+    getMismatches(): number;
+    /** @deprecated */
+    setMismatches(_mismatches: number): void;
+    get missing(): number;
+    getMissing(): number;
+    /** @deprecated */
+    setMissing(_missing: number): void;
+    get exactMatches(): number;
+    getExactMatches(): number;
+    /** @deprecated */
+    setExactMatches(_exactMatches: number): void;
+    get strictMatches(): number;
+    getStrictMatches(): number;
+    /** @deprecated */
+    setStrictMatches(_strictMatches: number): void;
+    get contentMatches(): number;
+    getContentMatches(): number;
+    /** @deprecated */
+    setContentMatches(_contentMatches: number): void;
+    get layoutMatches(): number;
+    getLayoutMatches(): number;
+    /** @deprecated */
+    setLayoutMatches(_layoutMatches: number): void;
+    get noneMatches(): number;
+    getNoneMatches(): number;
+    /** @deprecated */
+    setNoneMatches(_noneMatches: number): void;
+    get url(): string;
+    getUrl(): string;
+    /** @deprecated */
+    setUrl(_url: string): void;
+    get server(): Core.EyesServerSettings;
+    get keepIfDuplicate(): boolean;
+    isPassed(): boolean;
+    delete(): Promise<void>;
+    /** @deprecated */
+    deleteSession(): Promise<void>;
+    /** @internal */
+    toObject(): TestResults;
+    /** @internal */
+    toJSON(): Core.TestResult<'classic' | 'ufg'>;
+    /** @internal */
+    toString(): string;
+}

package/types/output/TestResultsSummary.d.ts

@@ -0,0 +1,18 @@
+import type * as Core from '@applitools/core';
+import { TestResultContainer, TestResultContainerData } from './TestResultContainer';
+export type TestResultsSummary = Iterable<TestResultContainer>;
+export declare class TestResultsSummaryData implements Iterable<TestResultContainerData> {
+    private _summary?;
+    private _core?;
+    /** @internal */
+    constructor(options?: {
+        summary?: Core.TestResultSummary<'classic' | 'ufg'>;
+        core?: Core.Core<Core.SpecType, 'classic' | 'ufg'>;
+    });
+    getAllResults(): TestResultContainerData[];
+    [Symbol.iterator](): Iterator<TestResultContainerData>;
+    /** @internal */
+    toJSON(): Core.TestResultContainer<'classic' | 'ufg'>[];
+    /** @internal */
+    toString(): string;
+}

package/types/output/TextRegion.d.ts

@@ -0,0 +1,7 @@
+export type TextRegion = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+};