@applitools/eyes-browser 1.0.0

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@applitools/eyes-browser",
+  "version": "1.0.0",
+  "keywords": [
+    "applitools",
+    "browser",
+    "chrome extension",
+    "eyes",
+    "eyes-sdk",
+    "test automation",
+    "visual regression",
+    "automation",
+    "testing",
+    "tests"
+  ],
+  "homepage": "https://applitools.com",
+  "bugs": {
+    "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/applitools/eyes.sdk.javascript1.git",
+    "directory": "js/packages/eyes-browser"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": {
+    "name": "Applitools Team",
+    "email": "team@applitools.com"
+  },
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "browser": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./dist/*": "./dist/*.js",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "types": "./types/index.d.ts",
+  "files": [
+    "dist",
+    "types"
+  ],
+  "scripts": {
+    "lint": "run --top-level eslint '**/*.ts'",
+    "build": "node ./esbuild/browser.config.mjs",
+    "test": "run --top-level mocha './test/**/*.spec.ts'"
+  },
+  "dependencies": {
+    "@applitools/eyes": "1.13.0"
+  },
+  "devDependencies": {
+    "@types/node": "^12.20.55",
+    "@types/path-browserify": "^1.0.1",
+    "assert": "^2.1.0",
+    "browserify-zlib": "^0.2.0",
+    "buffer": "^6.0.3",
+    "core-js": "^3.33.3",
+    "crypto-browserify": "^3.12.0",
+    "https-browserify": "^1.0.0",
+    "os-browserify": "^0.3.0",
+    "path-browserify": "^1.0.1",
+    "process": "^0.11.10",
+    "stream-browserify": "^3.0.0",
+    "stream-http": "^3.2.0",
+    "util": "^0.12.5"
+  },
+  "engines": {
+    "node": ">=12.13.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/types/BatchClose.d.ts

@@ -0,0 +1,23 @@
+import { type SDK } from './SDK';
+import { ProxySettings } from './input/ProxySettings';
+type BatchCloseOptions = {
+    batchIds: string[];
+    serverUrl: string;
+    apiKey: string;
+    proxy?: ProxySettings;
+};
+export declare function closeBatch(sdk: SDK): (options: BatchCloseOptions) => Promise<void>;
+export declare class BatchClose {
+    protected static readonly _sdk: SDK;
+    protected get _sdk(): SDK;
+    private _core;
+    private _settings;
+    static close(settings: BatchCloseOptions): Promise<void>;
+    constructor(options?: BatchCloseOptions);
+    close(): Promise<void>;
+    setBatchIds(batchIds: string[]): this;
+    setUrl(serverUrl: string): this;
+    setApiKey(apiKey: string): this;
+    setProxy(proxy: ProxySettings): this;
+}
+export {};

package/types/Eyes.d.ts

@@ -0,0 +1,249 @@
+/// <reference types="node" />
+import type * as Core from '@applitools/core';
+import { type SDK } from './SDK';
+import { EyesSelector } from './input/EyesSelector';
+import { SessionType } from './enums/SessionType';
+import { StitchMode, StitchModeEnum } from './enums/StitchMode';
+import { MatchLevel, MatchLevelEnum } from './enums/MatchLevel';
+import { CheckSettingsAutomation, CheckSettingsAutomationFluent, CheckSettingsImage, CheckSettingsImageFluent } from './input/CheckSettings';
+import { Image } from './input/Image';
+import { OCRSettings } from './input/OCRSettings';
+import { VisualLocatorSettings } from './input/VisualLocatorSettings';
+import { ProxySettings, ProxySettingsData } from './input/ProxySettings';
+import { Configuration, ConfigurationData } from './input/Configuration';
+import { BatchInfo, BatchInfoData } from './input/BatchInfo';
+import { RectangleSize, RectangleSizeData } from './input/RectangleSize';
+import { Region } from './input/Region';
+import { OCRRegion } from './input/OCRRegion';
+import { ImageRotation, ImageRotationData } from './input/ImageRotation';
+import { CutProviderData } from './input/CutProvider';
+import { LogHandlerData, LogHandler } from './input/LogHandler';
+import { TextRegion } from './output/TextRegion';
+import { MatchResultData } from './output/MatchResult';
+import { TestResults, TestResultsData } from './output/TestResults';
+import { ValidationInfo } from './output/ValidationInfo';
+import { ValidationResult } from './output/ValidationResult';
+import { SessionEventHandler, SessionEventHandlers } from './SessionEventHandlers';
+import { EyesRunner } from './Runners';
+import { Logger } from './Logger';
+export declare class Eyes<TSpec extends Core.SpecType = Core.SpecType> {
+    protected static readonly _sdk: SDK<Core.SpecType>;
+    protected get _sdk(): SDK<TSpec>;
+    private _logger;
+    private _config;
+    private _state;
+    private _runner;
+    private _driver?;
+    private _core;
+    private _eyes?;
+    private _spec?;
+    private _events;
+    private _handlers;
+    static getExecutionCloudUrl(config?: Configuration): Promise<string>;
+    static setViewportSize(driver: unknown, size: RectangleSize): Promise<void>;
+    static setMobileCapabilities<TCapabilities extends Record<string, any>>(capabilities: TCapabilities, config?: Configuration): TCapabilities;
+    constructor(runner?: EyesRunner, config?: Configuration<TSpec>);
+    constructor(config?: Configuration<TSpec>);
+    get logger(): Logger;
+    getLogger(): Logger;
+    get runner(): EyesRunner;
+    getRunner(): EyesRunner;
+    get driver(): TSpec['driver'];
+    getDriver(): TSpec['driver'];
+    get configuration(): Configuration<TSpec>;
+    set configuration(config: Configuration<TSpec>);
+    getConfiguration(): ConfigurationData<TSpec>;
+    setConfiguration(config: Configuration<TSpec>): void;
+    get isOpen(): boolean;
+    getIsOpen(): boolean;
+    /** @undocumented */
+    on(handler: (event: string, data?: Record<string, any>) => any): () => void;
+    /** @undocumented */
+    on(event: 'setSizeWillStart', handler: (data: {
+        viewportSize: RectangleSize;
+    }) => any): () => void;
+    /** @undocumented */
+    on(event: 'setSizeEnded', handler: () => any): () => void;
+    /** @undocumented */
+    on(event: 'initStarted', handler: () => any): () => void;
+    /** @undocumented */
+    on(event: 'initEnded', handler: () => any): () => void;
+    /** @undocumented */
+    on(event: 'testStarted', handler: (data: {
+        sessionId: string;
+    }) => any): () => void;
+    /** @undocumented */
+    on(event: 'validationWillStart', handler: (data: {
+        sessionId: string;
+        validationInfo: ValidationInfo;
+    }) => any): () => void;
+    /** @undocumented */
+    on(event: 'validationEnded', handler: (data: {
+        sessionId: string;
+        validationId: number;
+        validationResult: ValidationResult;
+    }) => any): () => void;
+    /** @undocumented */
+    on(event: 'testEnded', handler: (data: {
+        sessionId: string;
+        testResults: TestResults;
+    }) => any): () => void;
+    /** @undocumented */
+    off(event: string): void;
+    /** @undocumented */
+    off(handler: (...args: any[]) => any): void;
+    getExecutionCloudUrl(): Promise<string>;
+    setMobileCapabilities<TCapabilities extends Record<string, any>>(capabilities: TCapabilities): TCapabilities;
+    open(driver: TSpec['driver'], config?: Configuration<TSpec>): Promise<TSpec['driver']>;
+    open(driver: TSpec['driver'], appName?: string, testName?: string, viewportSize?: RectangleSize, sessionType?: SessionType): Promise<TSpec['driver']>;
+    open(config?: Configuration<TSpec>): Promise<void>;
+    open(appName?: string, testName?: string, viewportSize?: RectangleSize, sessionType?: SessionType): Promise<void>;
+    check(name: string, checkSettings: CheckSettingsImageFluent | CheckSettingsAutomationFluent<TSpec>): Promise<MatchResultData>;
+    check(target: Image, checkSettings?: CheckSettingsImage): Promise<MatchResultData>;
+    check(checkSettings?: CheckSettingsAutomation<TSpec>): Promise<MatchResultData>;
+    /** @deprecated */
+    checkWindow(name?: string, timeout?: number, fully?: boolean): Promise<MatchResultData>;
+    /** @deprecated */
+    checkFrame(element: TSpec['element'] | EyesSelector<TSpec['selector']> | string | number, timeout?: number, name?: string): Promise<MatchResultData>;
+    /** @deprecated */
+    checkElement(element: TSpec['element'], timeout?: number, name?: string): Promise<MatchResultData>;
+    /** @deprecated */
+    checkElementBy(selector: EyesSelector<TSpec['selector']>, timeout?: number, name?: string): Promise<MatchResultData>;
+    /** @deprecated */
+    checkRegion(region: Region, name?: string, timeout?: number): Promise<MatchResultData>;
+    /** @deprecated */
+    checkRegion(image: Buffer | URL | string, region: Region, name?: string, ignoreMismatch?: boolean): Promise<MatchResultData>;
+    /** @deprecated */
+    checkRegionByElement(element: TSpec['element'], name?: string, timeout?: number): Promise<MatchResultData>;
+    /** @deprecated */
+    checkRegionBy(selector: EyesSelector<TSpec['selector']>, name?: string, timeout?: number, fully?: boolean): Promise<MatchResultData>;
+    /** @deprecated */
+    checkRegionInFrame(frame: TSpec['element'] | EyesSelector<TSpec['selector']> | string | number, selector: EyesSelector<TSpec['selector']>, timeout?: number, name?: string, fully?: boolean): Promise<MatchResultData>;
+    /** @deprecated */
+    checkImage(image: Buffer | URL | string, name?: string, ignoreMismatch?: boolean): Promise<MatchResultData>;
+    locate<TLocator extends string>(target: Core.ImageTarget, settings: VisualLocatorSettings<TLocator>): Promise<Record<TLocator, Region[]>>;
+    locate<TLocator extends string>(settings: VisualLocatorSettings<TLocator>): Promise<Record<TLocator, Region[]>>;
+    extractTextRegions<TPattern extends string>(target: Core.ImageTarget, settings: OCRSettings<TPattern>): Promise<Record<TPattern, TextRegion[]>>;
+    /** @deprecated */
+    extractTextRegions<TPattern extends string>(settingsWithImage: OCRSettings<TPattern> & {
+        image: Core.ImageTarget['image'];
+    }): Promise<Record<TPattern, TextRegion[]>>;
+    extractTextRegions<TPattern extends string>(settings: OCRSettings<TPattern>): Promise<Record<TPattern, TextRegion[]>>;
+    extractText(target: Core.ImageTarget, settings: OCRRegion<TSpec>[]): Promise<string[]>;
+    /** @deprecated */
+    extractText(settingsWithImage: (OCRRegion<never> & {
+        image: Core.ImageTarget['image'];
+    })[]): Promise<string[]>;
+    extractText(settings: OCRRegion<TSpec>[]): Promise<string[]>;
+    close(throwErr?: boolean): Promise<TestResultsData>;
+    closeAsync(): Promise<void>;
+    abort(): Promise<TestResultsData>;
+    abortAsync(): Promise<void>;
+    /** @deprecated */
+    abortIfNotClosed(): Promise<TestResults>;
+    getResults(throwErr?: boolean): Promise<TestResultsData[]>;
+    getViewportSize(): Promise<RectangleSizeData>;
+    setViewportSize(size: RectangleSize): Promise<void>;
+    getScrollRootElement(): TSpec['element'] | EyesSelector<TSpec['selector']>;
+    setScrollRootElement(scrollRootElement: TSpec['element'] | EyesSelector<TSpec['selector']>): void;
+    setLogHandler(handler: LogHandlerData | LogHandler): void;
+    getLogHandler(): LogHandlerData;
+    setCutProvider(cutProvider: CutProviderData): void;
+    setImageCut(cutProvider: CutProviderData): void;
+    getIsCutProviderExplicitlySet(): boolean;
+    getRotation(): ImageRotationData;
+    setRotation(rotation: ImageRotation | ImageRotationData): void;
+    getScaleRatio(): number;
+    setScaleRatio(scaleRatio: number): void;
+    getSaveDebugScreenshots(): boolean;
+    setSaveDebugScreenshots(save: boolean): void;
+    getDebugScreenshotsPath(): string;
+    setDebugScreenshotsPath(path: string): void;
+    getDebugScreenshotsPrefix(): string;
+    setDebugScreenshotsPrefix(prefix: string): void;
+    addProperty(name: string, value: string): ConfigurationData<TSpec>;
+    clearProperties(): ConfigurationData<TSpec>;
+    getBatch(): BatchInfoData;
+    setBatch(batch: BatchInfo): void;
+    setBatch(name: string, id?: string, startedAt?: Date | string): void;
+    getApiKey(): string;
+    setApiKey(apiKey: string): void;
+    getTestName(): string;
+    setTestName(testName: string): void;
+    getAppName(): string;
+    setAppName(appName: string): void;
+    getBaselineBranchName(): string;
+    setBaselineBranchName(baselineBranchName: string): void;
+    /** @deprecated */
+    getBaselineName(): string;
+    /** @deprecated */
+    setBaselineName(baselineName: string): void;
+    getBaselineEnvName(): string;
+    setBaselineEnvName(baselineEnvName: string): void;
+    getBranchName(): string;
+    setBranchName(branchName: string): void;
+    getHostApp(): string;
+    setHostApp(hostApp: string): void;
+    getHostOS(): string;
+    setHostOS(hostOS: string): void;
+    getHostAppInfo(): string;
+    setHostAppInfo(hostAppInfo: string): void;
+    getHostOSInfo(): string;
+    setHostOSInfo(hostOSInfo: string): void;
+    getDeviceInfo(): string;
+    setDeviceInfo(deviceInfo: string): void;
+    setIgnoreCaret(ignoreCaret: boolean): void;
+    getIgnoreCaret(): boolean;
+    getIsDisabled(): boolean;
+    setIsDisabled(isDisabled: boolean): void;
+    getMatchLevel(): MatchLevelEnum;
+    setMatchLevel(matchLevel: MatchLevel): void;
+    getMatchTimeout(): number;
+    setMatchTimeout(matchTimeout: number): void;
+    getParentBranchName(): string;
+    setParentBranchName(parentBranchName: string): void;
+    setProxy(proxy: ProxySettings): void;
+    setProxy(url: string, username?: string, password?: string, isHttpOnly?: boolean): void;
+    setProxy(isEnabled: false): void;
+    getProxy(): ProxySettingsData;
+    getSaveDiffs(): boolean;
+    setSaveDiffs(saveDiffs: boolean): void;
+    getSaveNewTests(): boolean;
+    setSaveNewTests(saveNewTests: boolean): void;
+    getServerUrl(): string;
+    setServerUrl(serverUrl: string): void;
+    getSendDom(): boolean;
+    setSendDom(sendDom: boolean): void;
+    getHideCaret(): boolean;
+    setHideCaret(hideCaret: boolean): void;
+    getHideScrollbars(): boolean;
+    setHideScrollbars(hideScrollbars: boolean): void;
+    getForceFullPageScreenshot(): boolean;
+    setForceFullPageScreenshot(forceFullPageScreenshot: boolean): void;
+    getWaitBeforeScreenshots(): number;
+    setWaitBeforeScreenshots(waitBeforeScreenshots: number): void;
+    getStitchMode(): StitchModeEnum;
+    setStitchMode(stitchMode: StitchMode): void;
+    getStitchOverlap(): number;
+    setStitchOverlap(stitchOverlap: number): void;
+    /**
+     * @undocumented
+     * @deprecated
+     */
+    getSessionEventHandlers(): SessionEventHandlers;
+    /**
+     * @undocumented
+     * @deprecated
+     */
+    addSessionEventHandler(handler: SessionEventHandler): void;
+    /**
+     * @undocumented
+     * @deprecated
+     */
+    removeSessionEventHandler(handler: SessionEventHandler): void;
+    /**
+     * @undocumented
+     * @deprecated
+     */
+    clearSessionEventHandlers(): void;
+}

package/types/Logger.d.ts

@@ -0,0 +1,30 @@
+import type * as logger from '@applitools/logger';
+import { LogHandler, LogHandlerData, FileLogHandlerData, ConsoleLogHandlerData } from './input/LogHandler';
+export declare class Logger {
+    private _logger?;
+    private _options;
+    private _makeLogger;
+    /** @internal */
+    readonly isLogger = true;
+    /** @internal */
+    constructor(logger?: logger.Logger);
+    constructor(options?: {
+        show?: boolean;
+        label?: string;
+        handler?: LogHandler;
+    });
+    constructor(show?: boolean);
+    /** @internal */
+    getLogger(): logger.Logger;
+    getLogHandler(): LogHandlerData | ConsoleLogHandlerData | FileLogHandlerData;
+    setLogHandler(handler: LogHandler): void;
+    verbose(...messages: any[]): void;
+    log(...messages: any[]): void;
+    warn(...messages: any[]): void;
+    error(...messages: any[]): void;
+    fatal(...messages: any[]): void;
+    open(): void;
+    close(): void;
+    /** @internal */
+    extend(label?: string): Logger;
+}

package/types/Runners.d.ts

@@ -0,0 +1,40 @@
+import type * as Core from '@applitools/core';
+import { type Logger } from '@applitools/logger';
+import { RunnerOptions, RunnerOptionsFluent } from './input/RunnerOptions';
+import { TestResultsSummaryData } from './output/TestResultsSummary';
+export declare abstract class EyesRunner {
+    private _core?;
+    private _manager?;
+    abstract readonly type: 'classic' | 'ufg';
+    /** @internal */
+    protected readonly _managerSettings: Core.ManagerSettings;
+    /** @internal */
+    protected readonly _getResultsSettings: Core.GetManagerResultsSettings<'classic' | 'ufg'>;
+    constructor(options?: RunnerOptions);
+    /** @internal */
+    attach<TSpec extends Core.SpecType = Core.SpecType>(core: Core.Core<TSpec, 'classic' | 'ufg'>): void;
+    /** @internal */
+    openEyes<TSpec extends Core.SpecType = Core.SpecType>(options: {
+        target: TSpec['driver'];
+        config?: Core.Config<TSpec, 'classic' | 'ufg'>;
+        logger?: Logger;
+        on?: (name: string, data?: Record<string, any>) => void;
+    }): Promise<Core.Eyes<TSpec, 'classic' | 'ufg'>>;
+    getAllTestResults(throwErr?: boolean): Promise<TestResultsSummaryData>;
+}
+export declare class VisualGridRunner extends EyesRunner {
+    readonly type: "ufg";
+    constructor(options?: RunnerOptions);
+    /** @deprecated */
+    constructor(options?: RunnerOptionsFluent);
+    /** @deprecated */
+    constructor(legacyConcurrency?: number);
+    get testConcurrency(): number | undefined;
+    /** @deprecated */
+    get legacyConcurrency(): number | undefined;
+    /** @deprecated */
+    getConcurrentSessions(): number | undefined;
+}
+export declare class ClassicRunner extends EyesRunner {
+    readonly type: "classic";
+}

package/types/SDK.d.ts

@@ -0,0 +1,11 @@
+import { makeCore as makeDefaultCore, type Core, type SpecType, type SpecDriver } from '@applitools/core';
+export interface SDK<TSpec extends SpecType = SpecType> {
+    spec?: SpecDriver<TSpec>;
+    agentId?: string;
+    environment?: Record<string, any>;
+    makeCore?: typeof makeDefaultCore;
+}
+export declare function initSDK<TSpec extends SpecType = SpecType>(options?: SDK<TSpec>): {
+    core: Core<TSpec, 'classic' | 'ufg'>;
+    spec?: SpecDriver<TSpec>;
+};

package/types/SessionEventHandlers.d.ts

@@ -0,0 +1,78 @@
+import type { Eyes } from './Eyes';
+import { RectangleSizeData } from './input/RectangleSize';
+import { TestResultsData } from './output/TestResults';
+import { ValidationInfoData } from './output/ValidationInfo';
+import { ValidationResultData } from './output/ValidationResult';
+/** @deprecated */
+export declare abstract class SessionEventHandler {
+    abstract initStarted(): any;
+    abstract initEnded(): any;
+    abstract setSizeWillStart(viewportSize: RectangleSizeData): any;
+    abstract setSizeEnded(): any;
+    abstract testStarted(sessionId: string): any;
+    abstract testEnded(sessionId: string, testResults: TestResultsData): any;
+    abstract validationWillStart(sessionId: string, validationInfo: ValidationInfoData): any;
+    abstract validationEnded(sessionId: string, validationId: number, validationResult: ValidationResultData): any;
+    private _detach?;
+    /** @internal */
+    attach(eyes: Eyes): void;
+    /** @internal */
+    detach(): void;
+}
+/** @deprecated */
+export declare class SessionEventHandlers extends SessionEventHandler {
+    private _handlers;
+    addEventHandler(handler: SessionEventHandler): void;
+    removeEventHandler(handler: SessionEventHandler): void;
+    clearEventHandlers(): void;
+    initStarted(): void;
+    initEnded(): void;
+    setSizeWillStart(viewportSize: RectangleSizeData): void;
+    setSizeEnded(): void;
+    testStarted(sessionId: string): void;
+    testEnded(sessionId: string, testResults: TestResultsData): void;
+    validationWillStart(sessionId: string, validationInfo: ValidationInfoData): void;
+    validationEnded(sessionId: string, validationId: number, validationResult: ValidationResultData): void;
+}
+/**
+ * @undocumented
+ * @deprecated
+ */
+export declare class RemoteSessionEventHandler extends SessionEventHandler {
+    private _serverUrl;
+    private _accessKey?;
+    private _timeout?;
+    constructor(options: {
+        serverUrl: string;
+        accessKey?: string;
+        timeout?: number;
+    });
+    constructor(serverUrl: string, accessKey?: string, timeout?: number);
+    get serverUrl(): string;
+    set serverUrl(serverUrl: string);
+    getServerUrl(): string;
+    setServerUrl(serverUrl: string): void;
+    get accessKey(): string | undefined;
+    set accessKey(accessKey: string | undefined);
+    getAccessKey(): string | undefined;
+    setAccessKey(accessKey: string): void;
+    get timeout(): number | undefined;
+    set timeout(timeout: number | undefined);
+    setTimeout(timeout: number): void;
+    getTimeout(): number | undefined;
+    initStarted(): void;
+    initEnded(): void;
+    setSizeWillStart(): void;
+    setSizeEnded(): void;
+    testStarted(): void;
+    testEnded(): void;
+    validationWillStart(): void;
+    validationEnded(): void;
+    /** @internal */
+    toJSON(): {
+        serverUrl: string;
+        accessKey?: string;
+    };
+    /** @internal */
+    toString(): string;
+}

package/types/enums/AccessibilityGuidelinesVersion.d.ts

@@ -0,0 +1,5 @@
+export declare enum AccessibilityGuidelinesVersionEnum {
+    WCAG_2_0 = "WCAG_2_0",
+    WCAG_2_1 = "WCAG_2_1"
+}
+export type AccessibilityGuidelinesVersion = `${AccessibilityGuidelinesVersionEnum}`;

package/types/enums/AccessibilityLevel.d.ts

@@ -0,0 +1,5 @@
+export declare enum AccessibilityLevelEnum {
+    AA = "AA",
+    AAA = "AAA"
+}
+export type AccessibilityLevel = `${AccessibilityLevelEnum}`;

package/types/enums/AccessibilityRegionType.d.ts

@@ -0,0 +1,8 @@
+export declare enum AccessibilityRegionTypeEnum {
+    IgnoreContrast = "IgnoreContrast",
+    RegularText = "RegularText",
+    LargeText = "LargeText",
+    BoldText = "BoldText",
+    GraphicalObject = "GraphicalObject"
+}
+export type AccessibilityRegionType = `${AccessibilityRegionTypeEnum}`;

package/types/enums/AccessibilityStatus.d.ts

@@ -0,0 +1,5 @@
+export declare enum AccessibilityStatusEnum {
+    Passed = "Passed",
+    Failed = "Failed"
+}
+export type AccessibilityStatus = `${AccessibilityStatusEnum}`;

package/types/enums/AndroidDeviceName.d.ts

@@ -0,0 +1,28 @@
+export declare enum AndroidDeviceNameEnum {
+    Pixel_3_XL = "Pixel 3 XL",
+    Pixel_4 = "Pixel 4",
+    Pixel_4_XL = "Pixel 4 XL",
+    Pixel_5 = "Pixel 5",
+    Pixel_6 = "Pixel 6",
+    Galaxy_S10 = "Galaxy S10",
+    Galaxy_S10_Plus = "Galaxy S10 Plus",
+    Galaxy_Note_10 = "Galaxy Note 10",
+    Galaxy_Note_10_Plus = "Galaxy Note 10 Plus",
+    Galaxy_S20 = "Galaxy S20",
+    Galaxy_S20_Plus = "Galaxy S20 Plus",
+    Galaxy_S21 = "Galaxy S21",
+    Galaxy_S21_Plus = "Galaxy S21 Plus",
+    Galaxy_S21_Ultra = "Galaxy S21 Ultra",
+    Galaxy_S22 = "Galaxy S22",
+    Galaxy_S22_Plus = "Galaxy S22 Plus",
+    Galaxy_Tab_S7 = "Galaxy Tab S7",
+    Galaxy_Tab_S8 = "Galaxy Tab S8",
+    Xiaomi_Redmi_Note_10_JE = "Xiaomi Redmi Note 10 JE",
+    Xiaomi_Redmi_Note_11 = "Xiaomi Redmi Note 11",
+    Xiaomi_Redmi_Note_11_Pro = "Xiaomi Redmi Note 11 Pro",
+    Sony_Xperia_1_II = "Sony Xperia 1 II",
+    Sony_Xperia_10_II = "Sony Xperia 10 II",
+    Sony_Xperia_Ace_II = "Sony Xperia Ace II",
+    Huawei_P30_Lite = "Huawei P30 Lite"
+}
+export type AndroidDeviceName = `${AndroidDeviceNameEnum}`;

package/types/enums/AndroidVersion.d.ts

@@ -0,0 +1,5 @@
+export declare enum AndroidVersionEnum {
+    LATEST = "latest",
+    ONE_VERSION_BACK = "latest-1"
+}
+export type AndroidVersion = `${AndroidVersionEnum}`;

package/types/enums/BrowserType.d.ts

@@ -0,0 +1,20 @@
+export declare enum BrowserTypeEnum {
+    CHROME = "chrome",
+    CHROME_ONE_VERSION_BACK = "chrome-one-version-back",
+    CHROME_TWO_VERSIONS_BACK = "chrome-two-versions-back",
+    FIREFOX = "firefox",
+    FIREFOX_ONE_VERSION_BACK = "firefox-one-version-back",
+    FIREFOX_TWO_VERSIONS_BACK = "firefox-two-versions-back",
+    IE_11 = "ie",
+    IE_10 = "ie10",
+    EDGE = "edge",
+    EDGE_CHROMIUM = "edgechromium",
+    EDGE_LEGACY = "edgelegacy",
+    EDGE_CHROMIUM_ONE_VERSION_BACK = "edgechromium-one-version-back",
+    EDGE_CHROMIUM_TWO_VERSIONS_BACK = "edgechromium-two-versions-back",
+    SAFARI = "safari",
+    SAFARI_EARLY_ACCESS = "safari-earlyaccess",
+    SAFARI_ONE_VERSION_BACK = "safari-one-version-back",
+    SAFARI_TWO_VERSIONS_BACK = "safari-two-versions-back"
+}
+export type BrowserType = `${BrowserTypeEnum}`;

package/types/enums/CorsIframeHandle.d.ts

@@ -0,0 +1,7 @@
+/** @undocumented */
+export declare enum CorsIframeHandleEnum {
+    BLANK = "BLANK",
+    KEEP = "KEEP",
+    SNAPSHOT = "SNAPSHOT"
+}
+export type CorsIframeHandle = `${CorsIframeHandleEnum}`;