@applitools/eyes 1.33.3 → 1.34.0

package/types/Eyes.d.ts

@@ -0,0 +1,255 @@
+/// <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 & {
+        maskLog?: boolean;
+    }): 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: Image, settings: VisualLocatorSettings<TLocator>): Promise<Record<TLocator, Region[]>>;
+    /** @deprecated */
+    locate<TLocator extends string>(settingsWithImage: VisualLocatorSettings<TLocator> & {
+        image: Image['image'];
+    }): Promise<Record<TLocator, Region[]>>;
+    locate<TLocator extends string>(settings: VisualLocatorSettings<TLocator>): Promise<Record<TLocator, Region[]>>;
+    extractTextRegions<TPattern extends string>(target: Image, settings: OCRSettings<TPattern>): Promise<Record<TPattern, TextRegion[]>>;
+    /** @deprecated */
+    extractTextRegions<TPattern extends string>(settingsWithImage: OCRSettings<TPattern> & {
+        image: Image['image'];
+    }): Promise<Record<TPattern, TextRegion[]>>;
+    extractTextRegions<TPattern extends string>(settings: OCRSettings<TPattern>): Promise<Record<TPattern, TextRegion[]>>;
+    extractText(target: Image, settings: OCRRegion<TSpec>[]): Promise<string[]>;
+    /** @deprecated */
+    extractText(settingsWithImage: (OCRRegion<never> & {
+        image: Image['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,41 @@
+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?;
+    readonly _maskLog: boolean;
+    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,20 @@
+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>;
+    maskLog?: boolean;
+    offlineLocationPath?: string;
+    makeCore?: typeof makeDefaultCore;
+}
+export declare function initSDK<TSpec extends SpecType = SpecType>(options?: SDK<TSpec>, maskLog?: boolean): {
+    core: Core<TSpec, 'classic' | 'ufg'>;
+    spec?: SpecDriver<TSpec>;
+};
+export declare const getCoreWithCache: typeof getCore & {
+    getCachedValues(): Core<SpecType, "classic" | "ufg">[];
+    setCachedValue(key: any, value: Core<SpecType, "classic" | "ufg">): void;
+    clearCache(): void;
+};
+declare function getCore<TSpec extends SpecType = SpecType>({ makeCore, ...options }?: SDK<TSpec>): Core<TSpec, 'classic' | 'ufg'>;
+export {};

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/cli/load-config.d.ts

@@ -0,0 +1 @@
+export declare function loadConfig(configPath: string): Promise<object>;

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/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}`;

package/types/enums/DeviceName.d.ts

@@ -0,0 +1,101 @@
+export declare enum DeviceNameEnum {
+    iPhone_4 = "iPhone 4",
+    iPhone_5SE = "iPhone 5/SE",
+    /** @deprecated use {@link iPhone_5SE } instead */
+    iPhone_5S_E = "iPhone 5/SE",
+    iPhone_SE_3rd_Gen = "iPhone SE 3rd Gen",
+    iPhone_6_7_8 = "iPhone 6/7/8",
+    iPhone_6_7_8_Plus = "iPhone 6/7/8 Plus",
+    iPhone_X = "iPhone X",
+    iPhone_13_Mini = "iPhone 13 Mini",
+    iPhone_14_Plus = "iPhone 14 Plus",
+    iPhone_14_Pro = "iPhone 14 Pro",
+    iPhone_15_Pro = "iPhone 15 Pro",
+    BlackBerry_Z30 = "BlackBerry Z30",
+    Nexus_4 = "Nexus 4",
+    Nexus_5 = "Nexus 5",
+    Nexus_5X = "Nexus 5X",
+    Nexus_6 = "Nexus 6",
+    Nexus_6P = "Nexus 6P",
+    Pixel_2 = "Pixel 2",
+    Pixel_2_XL = "Pixel 2 XL",
+    LG_Optimus_L70 = "LG Optimus L70",
+    Nokia_N9 = "Nokia N9",
+    Nokia_Lumia_520 = "Nokia Lumia 520",
+    Microsoft_Lumia_550 = "Microsoft Lumia 550",
+    Microsoft_Lumia_950 = "Microsoft Lumia 950",
+    Galaxy_S3 = "Galaxy S3",
+    Galaxy_S_III = "Galaxy S III",
+    Galaxy_S5 = "Galaxy S5",
+    Kindle_Fire_HDX = "Kindle Fire HDX",
+    iPad_Mini = "iPad Mini",
+    iPad = "iPad",
+    iPad_Pro = "iPad Pro",
+    iPad_8th_Gen = "iPad 8th Gen",
+    iPad_10th_Gen = "iPad 10th Gen",
+    iPad_Mini_4th_Gen = "iPad Mini 4th Gen",
+    iPad_Mini_6th_Gen = "iPad Mini 6th Gen",
+    Blackberry_PlayBook = "Blackberry PlayBook",
+    Nexus_10 = "Nexus 10",
+    Nexus_7 = "Nexus 7",
+    Galaxy_Note_3 = "Galaxy Note 3",
+    Galaxy_Note_II = "Galaxy Note II",
+    Galaxy_Note_2 = "Galaxy Note 2",
+    Galaxy_S20 = "Galaxy S20",
+    Galaxy_S22 = "Galaxy S22",
+    Galaxy_S21 = "Galaxy S21",
+    Galaxy_S21_Ultra = "Galaxy S21 Ultra",
+    Galaxy_S22_Ultra = "Galaxy S22 Ultra",
+    Laptop_with_touch = "Laptop with touch",
+    Laptop_with_HiDPI_screen = "Laptop with HiDPI screen",
+    Laptop_with_MDPI_screen = "Laptop with MDPI screen",
+    iPhone_XR = "iPhone XR",
+    iPhone_XS_Max = "iPhone XS Max",
+    iPhone_XS = "iPhone XS",
+    Samsung_Galaxy_A5 = "Samsung Galaxy A5",
+    Galaxy_A5 = "Galaxy A5",
+    Samsung_Galaxy_S8 = "Samsung Galaxy S8",
+    Galaxy_S8 = "Galaxy S8",
+    LG_G6 = "LG G6",
+    iPad_Air_2 = "iPad Air 2",
+    iPad_6th_Gen = "iPad 6th Gen",
+    iPhone_11 = "iPhone 11",
+    iPhone_11_Pro_Max = "iPhone 11 Pro Max",
+    iPhone_11_Pro = "iPhone 11 Pro",
+    Galaxy_S10 = "Galaxy S10",
+    Galaxy_S9_Plus = "Galaxy S9 Plus",
+    Galaxy_S9 = "Galaxy S9",
+    Galaxy_S10_Plus = "Galaxy S10 Plus",
+    Galaxy_S8_Plus = "Galaxy S8 Plus",
+    Galaxy_Note_10 = "Galaxy Note 10",
+    Galaxy_Note_10_Plus = "Galaxy Note 10 Plus",
+    Galaxy_Note_9 = "Galaxy Note 9",
+    Galaxy_Note_8 = "Galaxy Note 8",
+    Galaxy_Note_4 = "Galaxy Note 4",
+    Galaxy_Tab_A_SM_T510 = "Galaxy Tab A SM-T510",
+    Galaxy_Tab_A7_SM_T500 = "Galaxy Tab A7 SM-T500",
+    Galaxy_Tab_S8 = "Galaxy Tab S8",
+    Galaxy_Tab_A8 = "Galaxy Tab A8",
+    Galaxy_S23 = "Galaxy S23",
+    Galaxy_S23_Ultra = "Galaxy S23 Ultra",
+    Galaxy_A52s = "Galaxy A52s",
+    Pixel_3 = "Pixel 3",
+    Pixel_3_XL = "Pixel 3 XL",
+    Pixel_4 = "Pixel 4",
+    Pixel_4_XL = "Pixel 4 XL",
+    Pixel_5 = "Pixel 5",
+    iPad_7th_Gen = "iPad 7th Gen",
+    OnePlus_7T = "OnePlus 7T",
+    OnePlus_7T_Pro = "OnePlus 7T Pro",
+    Galaxy_Tab_S7 = "Galaxy Tab S7",
+    Sony_Xperia_10_II = "Sony Xperia 10 II",
+    Huawei_Mate_50_Pro = "Huawei Mate 50 Pro",
+    Huawei_Matepad_11 = "Huawei Matepad 11",
+    Huawei_P30 = "Huawei P30",
+    Xiaomi_Mi_A3 = "Xiaomi Mi A3",
+    Huawei_P40 = "Huawei P40",
+    Xiaomi_Redmi_Note_8 = "Xiaomi Redmi Note 8",
+    Xiaomi_Mi_Poco_X3_Pro = "Xiaomi Mi Poco X3 Pro",
+    Xiaomi_Poco_X3 = "Xiaomi Poco X3"
+}
+export type DeviceName = `${DeviceNameEnum}`;

package/types/enums/DynamicTextType.d.ts

@@ -0,0 +1,9 @@
+export declare enum DynamicTextTypeEnum {
+    TextField = "TextField",
+    Number = "Number",
+    Date = "Date",
+    Link = "Link",
+    Email = "Email",
+    Currency = "Currency"
+}
+export type DynamicTextType = `${DynamicTextTypeEnum}`;

package/types/enums/FailureReport.d.ts

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

package/types/enums/IosDeviceName.d.ts

@@ -0,0 +1,43 @@
+export declare enum IosDeviceNameEnum {
+    iPad_7 = "iPad (7th generation)",
+    iPad_9 = "iPad (9th generation)",
+    iPad_10 = "iPad (10th generation)",
+    iPad_mini_6 = "iPad mini (6th generation)",
+    iPad_Air_4 = "iPad Air (4th generation)",
+    /** @deprecated use {@link iPad_Pro_12_9_inch_3 } instead */
+    iPad_Pro_3 = "iPad Pro (12.9-inch) (3rd generation)",
+    iPad_Pro_12_9_inch_3 = "iPad Pro (12.9-inch) (3rd generation)",
+    /** @deprecated use {@link iPad_Pro_11_inch_4 } instead */
+    iPad_Pro_4 = "iPad Pro (11-inch) (4th generation)",
+    iPad_Pro_11_inch_4 = "iPad Pro (11-inch) (4th generation)",
+    iPhone_SE_2 = "iPhone SE (2nd generation)",
+    iPhone_SE_3 = "iPhone SE (3rd generation)",
+    iPhone_XR = "iPhone XR",
+    /** @deprecated use {@link iPhone_Xs } instead */
+    iPhone_XS = "iPhone Xs",
+    iPhone_Xs = "iPhone Xs",
+    iPhone_11 = "iPhone 11",
+    iPhone_11_Pro_Max = "iPhone 11 Pro Max",
+    iPhone_11_Pro = "iPhone 11 Pro",
+    iPhone_12 = "iPhone 12",
+    iPhone_12_mini = "iPhone 12 mini",
+    iPhone_12_Pro_Max = "iPhone 12 Pro Max",
+    iPhone_12_Pro = "iPhone 12 Pro",
+    iPhone_13 = "iPhone 13",
+    iPhone_13_mini = "iPhone 13 mini",
+    iPhone_13_Pro_Max = "iPhone 13 Pro Max",
+    iPhone_13_Pro = "iPhone 13 Pro",
+    iPhone_14 = "iPhone 14",
+    iPhone_14_Pro_Max = "iPhone 14 Pro Max",
+    iPhone_14_Pro = "iPhone 14 Pro",
+    iPhone_14_Plus = "iPhone 14 Plus",
+    iPhone_15 = "iPhone 15",
+    iPhone_15_Pro_Max = "iPhone 15 Pro Max",
+    iPhone_15_Pro = "iPhone 15 Pro",
+    iPhone_15_Plus = "iPhone 15 Plus",
+    iPhone_16 = "iPhone 16",
+    iPhone_16_Pro_Max = "iPhone 16 Pro Max",
+    iPhone_16_Pro = "iPhone 16 Pro",
+    iPhone_16_Plus = "iPhone 16 Plus"
+}
+export type IosDeviceName = `${IosDeviceNameEnum}`;