@applitools/core 1.4.6 → 1.4.7

package/types/close.d.ts

@@ -5,8 +5,8 @@ type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | '
     logger: Logger;
 };
 export declare function makeClose<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'>({ eyes, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TType>): ({ settings, config, logger, }?: {
-    settings?: CloseSettings<TType>;
-    config?: Config<TElement, TSelector, TType>;
-    logger?: Logger;
+    settings?: CloseSettings<TType> | undefined;
+    config?: Config<TElement, TSelector, TType> | undefined;
+    logger?: Logger | undefined;
 }) => Promise<TestResult<TType>[]>;
 export {};

package/types/delete-test.d.ts

@@ -8,6 +8,6 @@ type Options = {
 };
 export declare function makeDeleteTest({ core, logger: defaultLogger }: Options): ({ settings, logger, }: {
     settings: MaybeArray<DeleteTestSettings>;
-    logger?: Logger;
+    logger?: Logger | undefined;
 }) => Promise<void>;
 export {};

package/types/errors/abort-error.d.ts

@@ -1,3 +1,2 @@
 export declare class AbortError extends Error {
-    info: Record<string, any>;
 }

package/types/extract-text.d.ts

@@ -7,9 +7,9 @@ type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | '
     logger: Logger;
 };
 export declare function makeExtractText<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg' = 'classic'>({ eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TType>): ({ target, settings, config, logger, }: {
-    target?: Target<TDriver, TContext, TElement, TSelector, 'classic'>;
+    target?: import("./classic/types").ClassicTarget<TDriver, TContext, TElement, TSelector> | undefined;
     settings: MaybeArray<ExtractTextSettings<TElement, TSelector, 'classic'>>;
-    config?: Config<TElement, TSelector, 'classic'>;
-    logger?: Logger;
+    config?: Config<TElement, TSelector, "classic"> | undefined;
+    logger?: Logger | undefined;
 }) => Promise<string[]>;
 export {};

package/types/get-typed-eyes.d.ts

@@ -11,11 +11,11 @@ type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | '
     logger?: Logger;
 };
 export declare function makeGetTypedEyes<TDriver, TContext, TElement, TSelector, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, settings: defaultSettings, target, cores, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, settings, logger, }?: {
-    type?: TType;
+    type?: TType | undefined;
     settings?: {
         type: 'web' | 'native';
         renderers: Renderer[];
-    };
-    logger?: Logger;
+    } | undefined;
+    logger?: Logger | undefined;
 }) => Promise<TypedEyes<TDriver, TContext, TElement, TSelector, TType, import("./types").Target<TDriver, TContext, TElement, TSelector, TType>>>;
 export {};

package/types/locate-text.d.ts

@@ -6,9 +6,9 @@ type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | '
     logger: Logger;
 };
 export declare function makeLocateText<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg' = 'classic'>({ eyes, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TType>): <TPattern extends string>({ target, settings, config, logger, }: {
-    target?: Target<TDriver, TContext, TElement, TSelector, 'classic'>;
+    target?: import("./classic/types").ClassicTarget<TDriver, TContext, TElement, TSelector> | undefined;
     settings: import("./automation/types").LocateTextSettings<TPattern, TElement, TSelector>;
-    config?: Config<TElement, TSelector, 'classic'>;
-    logger?: Logger;
+    config?: Config<TElement, TSelector, "classic"> | undefined;
+    logger?: Logger | undefined;
 }) => Promise<LocateTextResult<TPattern>>;
 export {};

package/types/locate.d.ts

@@ -4,14 +4,14 @@ import type { Core as BaseCore } from '@applitools/core-base';
 import { type Logger } from '@applitools/logger';
 import { type SpecDriver } from '@applitools/driver';
 type Options<TDriver, TContext, TElement, TSelector> = {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     core: BaseCore;
     logger: Logger;
 };
 export declare function makeLocate<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'>({ spec, core, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TLocator extends string>({ target, settings, config, logger, }: {
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector> | ImageTarget;
+    target: DriverTarget<TDriver, TContext, TElement, TSelector> | ImageTarget;
     settings: LocateSettings<TLocator, TElement, TSelector>;
-    config?: Config<TElement, TSelector, TType>;
-    logger?: Logger;
+    config?: Config<TElement, TSelector, TType> | undefined;
+    logger?: Logger | undefined;
 }) => Promise<Record<TLocator, Region[]>>;
 export {};

package/types/make-ec-client.d.ts

@@ -5,9 +5,9 @@ type Options = {
     core: BaseCore;
     logger: Logger;
 };
-export declare function makeMakeECClient({ core, logger: defaultLogger }: Options): (({ settings, logger, }?: {
-    settings?: ECClientSettings;
-    logger?: Logger;
+export declare function makeMakeECClient({ logger: defaultLogger }: Options): (({ settings, logger, }?: {
+    settings?: Partial<ECClientSettings> | undefined;
+    logger?: Logger | undefined;
 }) => Promise<ECClient>) & {
     getCachedValues(): Promise<ECClient>[];
     setCachedValue(key: any, value: Promise<ECClient>): void;

package/types/make-manager.d.ts

@@ -3,20 +3,20 @@ import type { Core as BaseCore } from '@applitools/core-base';
 import { type Logger } from '@applitools/logger';
 import { type SpecDriver } from '@applitools/driver';
 type Options<TDriver, TContext, TElement, TSelector> = {
-    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     core?: BaseCore;
     concurrency?: number;
     agentId?: string;
     cwd?: string;
-    logger?: Logger;
+    logger: Logger;
 };
 export declare function makeMakeManager<TDriver, TContext, TElement, TSelector>({ spec, core, concurrency: defaultConcurrency, agentId: defaultAgentId, cwd, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): <TType extends "classic" | "ufg" = "classic">({ type, concurrency, legacyConcurrency, batch, agentId, logger, }?: {
-    type?: TType;
-    concurrency?: number;
+    type?: TType | undefined;
+    concurrency?: number | undefined;
     /** @deprecated */
-    legacyConcurrency?: number;
-    batch?: Batch;
-    agentId?: string;
-    logger?: Logger;
+    legacyConcurrency?: number | undefined;
+    batch?: Batch | undefined;
+    agentId?: string | undefined;
+    logger?: Logger | undefined;
 }) => Promise<EyesManager<TDriver, TContext, TElement, TSelector, TType>>;
 export {};

package/types/open-eyes.d.ts

@@ -11,13 +11,13 @@ type Options<TDriver, TContext, TElement, TSelector, TType extends 'classic' | '
         [TKey in 'classic' | 'ufg']: TypedCore<TDriver, TContext, TElement, TSelector, TKey>;
     };
     spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    logger?: Logger;
+    logger: Logger;
 };
 export declare function makeOpenEyes<TDriver, TContext, TElement, TSelector, TDefaultType extends 'classic' | 'ufg' = 'classic'>({ type: defaultType, concurrency, batch, core, cores, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, settings, config, target, logger, }: {
-    type?: TType;
-    settings?: Partial<OpenSettings<TDefaultType> & OpenSettings<TType>>;
-    config?: Config<TElement, TSelector, TDefaultType> & Config<TElement, TSelector, TType>;
-    target?: TDriver;
-    logger?: Logger;
+    type?: TType | undefined;
+    settings?: Partial<OpenSettings<TDefaultType> & OpenSettings<TType>> | undefined;
+    config?: (Config<TElement, TSelector, TDefaultType> & Config<TElement, TSelector, TType>) | undefined;
+    target?: TDriver | undefined;
+    logger?: Logger | undefined;
 }) => Promise<Eyes<TDriver, TContext, TElement, TSelector, TType, import("./types").Target<TDriver, TContext, TElement, TSelector, TType>>>;
 export {};

package/types/troubleshoot/check-network.d.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /// <reference types="node" />
 export declare function checkNetwork({ stream, eyes, ufg }?: {
-    stream?: NodeJS.WriteStream;
+    stream?: NodeJS.WriteStream | undefined;
     eyes?: {
         testFetch(): Promise<void>;
         testCurl(): Promise<void>;
@@ -9,7 +9,7 @@ export declare function checkNetwork({ stream, eyes, ufg }?: {
         testHttps: () => Promise<void>;
         url: URL;
         cmd: string;
-    };
+    } | undefined;
     ufg?: {
         testFetch(): Promise<void>;
         testCurl(): Promise<void>;
@@ -17,5 +17,5 @@ export declare function checkNetwork({ stream, eyes, ufg }?: {
         testHttps(): Promise<void>;
         url: URL;
         getCmd: () => Promise<string>;
-    };
+    } | undefined;
 }): Promise<void>;

package/types/troubleshoot/utils.d.ts

@@ -1,4 +1,2 @@
 export declare const config: any;
 export declare function getProxyCurlArg(): string;
-export declare function presult(promise: any): any;
-export declare function ptimeoutWithError(promiseOrPromiseFunc: any, timeout: any, err: any): Promise<any>;

package/types/types.d.ts

@@ -5,6 +5,7 @@ import type * as ClassicCore from './classic/types';
 import type * as UFGCore from './ufg/types';
 import { type Logger } from '@applitools/logger';
 import { type Renderer } from '@applitools/ufg-client';
+export { ECClient };
 export * from '@applitools/core-base/types';
 export * from './automation/types';
 export type TypedCore<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.Core<TDriver, TContext, TElement, TSelector> : ClassicCore.Core<TDriver, TContext, TElement, TSelector>;
@@ -35,9 +36,10 @@ export interface Core<TDriver, TContext, TElement, TSelector> extends Automation
         logger?: Logger;
     }): Promise<AutomationCore.LocateResult<TLocator>>;
 }
-export interface EyesManager<TDriver, TContext, TElement, TSelector, TType extends 'classic' | 'ufg'> {
-    openEyes(options: {
-        target?: TDriver;
+export interface EyesManager<TDriver, TContext, TElement, TSelector, TDefaultType extends 'classic' | 'ufg'> {
+    openEyes<TType extends 'classic' | 'ufg' = TDefaultType>(options: {
+        type?: TType;
+        target?: AutomationCore.DriverTarget<TDriver, TContext, TElement, TSelector>;
         settings?: Partial<OpenSettings<TType>>;
         config?: Config<TElement, TSelector, TType>;
         logger?: Logger;
@@ -47,7 +49,7 @@ export interface EyesManager<TDriver, TContext, TElement, TSelector, TType exten
             throwErr?: boolean;
         };
         logger?: Logger;
-    }) => Promise<TestResultSummary<TType>>;
+    }) => Promise<TestResultSummary<'classic' | 'ufg'>>;
 }
 export interface ClassicEyes<TDriver, TContext, TElement, TSelector, TTarget = Target<TDriver, TContext, TElement, TSelector, 'classic'>> extends ClassicCore.Eyes<TDriver, TContext, TElement, TSelector, TTarget> {
     getTypedEyes<TType extends 'classic' | 'ufg' = 'classic'>(options?: {

package/types/ufg/abort.d.ts

@@ -1,9 +1,8 @@
-import type { AbortSettings, TestResult } from './types';
+import type { DriverTarget, AbortSettings, TestResult } from './types';
 import type { Eyes as BaseEyes } from '@applitools/core-base';
 import { type Logger } from '@applitools/logger';
 import { type Renderer } from '@applitools/ufg-client';
 import { type AbortController } from 'abort-controller';
-import type { DriverTarget } from './types';
 import { type SpecDriver } from '@applitools/driver';
 type Options<TDriver, TContext, TElement, TSelector> = {
     storage: {
@@ -19,7 +18,7 @@ type Options<TDriver, TContext, TElement, TSelector> = {
     logger: Logger;
 };
 export declare function makeAbort<TDriver, TContext, TElement, TSelector>({ storage, target, spec, controller, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ settings, logger, }?: {
-    settings?: AbortSettings;
-    logger?: Logger;
+    settings?: AbortSettings | undefined;
+    logger?: Logger | undefined;
 }) => Promise<TestResult[]>;
 export {};

package/types/ufg/check-and-close.d.ts

@@ -1,21 +1,33 @@
+import type { Region } from '@applitools/utils';
 import type { DriverTarget, UFGTarget, Eyes, CheckSettings, TestResult, CloseSettings } from './types';
-import { type DomSnapshot, type AndroidSnapshot, type IOSSnapshot } from '@applitools/ufg-client';
 import { type AbortSignal } from 'abort-controller';
 import { type Logger } from '@applitools/logger';
 import { type UFGClient } from '@applitools/ufg-client';
-import { type SpecDriver } from '@applitools/driver';
+import { type SpecDriver, type Selector } from '@applitools/driver';
 type Options<TDriver, TContext, TElement, TSelector> = {
     eyes: Eyes<TDriver, TContext, TElement, TSelector>;
     client: UFGClient;
     target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
     spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     signal?: AbortSignal;
-    logger?: Logger;
+    logger: Logger;
 };
-export declare function makeCheckAndClose<TDriver, TContext, TElement, TSelector>({ spec, eyes, client, signal, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, snapshots, }: {
-    target?: UFGTarget<TDriver, TContext, TElement, TSelector>;
-    settings?: CheckSettings<TElement, TSelector> & CloseSettings;
-    logger?: Logger;
-    snapshots?: DomSnapshot[] | AndroidSnapshot[] | IOSSnapshot[];
+export declare function makeCheckAndClose<TDriver, TContext, TElement, TSelector>({ spec, eyes, client, signal, target: defaultTarget, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }: {
+    target?: UFGTarget<TDriver, TContext, TElement, TSelector> | undefined;
+    settings?: (import("@applitools/core-base").CheckSettings<Region | (TElement | Selector<TSelector>)> & import("./types").ScreenshotSettings<TElement, TSelector> & {
+        renderers?: import("@applitools/ufg-client").Renderer[] | undefined;
+        hooks?: {
+            beforeCaptureScreenshot: string;
+        } | undefined;
+        disableBrowserFetching?: boolean | undefined;
+        layoutBreakpoints?: boolean | number[] | undefined;
+        ufgOptions?: Record<string, any> | undefined;
+        nmgOptions?: Record<string, any> | undefined;
+        autProxy?: (import("@applitools/req").Proxy & {
+            mode?: "Allow" | "Block" | undefined;
+            domains?: string[] | undefined;
+        }) | undefined;
+    } & CloseSettings) | undefined;
+    logger?: Logger | undefined;
 }) => Promise<TestResult[]>;
 export {};

package/types/ufg/check.d.ts

@@ -9,11 +9,11 @@ type Options<TDriver, TContext, TElement, TSelector> = {
     target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
     spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
     signal?: AbortSignal;
-    logger?: Logger;
+    logger: Logger;
 };
 export declare function makeCheck<TDriver, TContext, TElement, TSelector>({ eyes, client, target: defaultTarget, spec, signal, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, logger, }: {
-    settings?: CheckSettings<TElement, TSelector>;
-    target?: UFGTarget<TDriver, TContext, TElement, TSelector>;
-    logger?: Logger;
+    settings?: CheckSettings<TElement, TSelector> | undefined;
+    target?: UFGTarget<TDriver, TContext, TElement, TSelector> | undefined;
+    logger?: Logger | undefined;
 }) => Promise<CheckResult[]>;
 export {};

package/types/ufg/close.d.ts

@@ -17,7 +17,7 @@ type Options<TDriver, TContext, TElement, TSelector> = {
     logger: Logger;
 };
 export declare function makeClose<TDriver, TContext, TElement, TSelector>({ storage, target, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ settings, logger, }?: {
-    settings?: CloseSettings;
-    logger?: Logger;
+    settings?: CloseSettings | undefined;
+    logger?: Logger | undefined;
 }) => Promise<TestResult[]>;
 export {};

package/types/ufg/get-base-eyes.d.ts

@@ -3,18 +3,18 @@ import type { Core as CoreBase, Eyes as EyesBase } from '@applitools/core-base';
 import { type Logger } from '@applitools/logger';
 import { type UFGClient, type Renderer } from '@applitools/ufg-client';
 type Options = {
-    settings?: OpenSettings;
+    settings: OpenSettings;
     eyes?: EyesBase[];
-    core?: CoreBase;
-    client?: UFGClient;
-    logger?: Logger;
+    core: CoreBase;
+    client: UFGClient;
+    logger: Logger;
 };
 export declare function makeGetBaseEyes({ settings: defaultSettings, core, client, eyes, logger: defaultLogger }: Options): (({ settings, logger, }?: {
     settings?: {
         type: 'web' | 'native';
         renderer: Renderer;
-    };
-    logger?: Logger;
+    } | undefined;
+    logger?: Logger | undefined;
 }) => Promise<EyesBase[]>) & {
     getCachedValues(): Promise<EyesBase<import("@applitools/core-base").ImageTarget>[]>[];
     setCachedValue(key: any, value: Promise<EyesBase<import("@applitools/core-base").ImageTarget>[]>): void;

package/types/ufg/open-eyes.d.ts

@@ -7,12 +7,12 @@ type Options<TDriver, TContext, TElement, TSelector> = {
     core: BaseCore;
     client?: UFGClient;
     spec?: SpecDriver<TDriver, TContext, TElement, TSelector>;
-    logger?: Logger;
+    logger: Logger;
 };
 export declare function makeOpenEyes<TDriver, TContext, TElement, TSelector>({ core, client, spec, logger: defaultLogger, }: Options<TDriver, TContext, TElement, TSelector>): ({ target, settings, eyes, logger, }: {
-    target?: DriverTarget<TDriver, TContext, TElement, TSelector>;
+    target?: DriverTarget<TDriver, TContext, TElement, TSelector> | undefined;
     settings: OpenSettings;
-    eyes?: BaseEyes[];
-    logger?: Logger;
+    eyes?: BaseEyes<import("@applitools/core-base").ImageTarget>[] | undefined;
+    logger?: Logger | undefined;
 }) => Promise<Eyes<TDriver, TContext, TElement, TSelector>>;
 export {};

package/types/ufg/types.d.ts

@@ -35,8 +35,8 @@ export interface Eyes<TDriver, TContext, TElement, TSelector, TTarget = UFGTarge
         settings?: CheckSettings<TElement, TSelector> & AutomationCore.CloseSettings;
         logger?: Logger;
     }): Promise<TestResult[]>;
-    locateText?: never;
-    extractText?: never;
+    locateText: never;
+    extractText: never;
     close(options?: {
         settings?: AutomationCore.CloseSettings;
         logger?: Logger;

package/types/ufg/utils/extract-broker-url.d.ts

@@ -0,0 +1,6 @@
+import { type Driver } from '@applitools/driver';
+import { type Logger } from '@applitools/logger';
+export declare function extractBrokerUrl({ driver, logger, }: {
+    driver: Driver<unknown, unknown, unknown, unknown>;
+    logger: Logger;
+}): Promise<string | null>;

package/types/ufg/utils/generate-safe-selectors.d.ts

@@ -3,10 +3,14 @@ export declare function generateSafeSelectors<TElement, TSelector>({ context, el
     context: Context<unknown, unknown, TElement, TSelector>;
     elementReferences: (TElement | Selector<TSelector>)[];
 }): Promise<{
-    selectors: {
-        safeSelector: Selector;
-        originalSelector: Selector;
+    selectors: ({
+        safeSelector: null;
+        originalSelector: null;
         elementReference: TElement | Selector<TSelector>;
-    }[];
-    cleanupGeneratedSelectors(): Promise<void>;
+    } | {
+        safeSelector: Selector<never>;
+        originalSelector: Selector<never> | null;
+        elementReference: TElement | Selector<TSelector>;
+    })[];
+    cleanupGeneratedSelectors: () => Promise<void>;
 }>;

package/types/ufg/utils/take-dom-snapshot.d.ts

@@ -1,6 +1,26 @@
 import { type Logger } from '@applitools/logger';
 import { type Context } from '@applitools/driver';
 import { type DomSnapshot } from '@applitools/ufg-client';
+type RawDomSnapshot = {
+    url: string;
+    selector: string;
+    cdt: {
+        attributes: {
+            name: string;
+            value: string;
+        }[];
+    }[];
+    crossFrames: {
+        selector: string;
+        index: number;
+    }[];
+    frames: RawDomSnapshot[];
+    resourceUrls: string[];
+    blobs: {
+        url: string;
+        value: string;
+    }[];
+};
 export type DomSnapshotSettings = {
     disableBrowserFetching?: boolean;
     skipResources?: string[];
@@ -15,10 +35,15 @@ export declare function takeDomSnapshot<TContext extends Context<unknown, unknow
     logger: Logger;
 }): Promise<DomSnapshot>;
 export declare function deserializeDomSnapshot({ snapshot }: {
-    snapshot: any;
-}): any;
-export declare function extractCrossFrames({ snapshot, parent, logger }: {
-    snapshot: any;
+    snapshot: RawDomSnapshot;
+}): DomSnapshot;
+export declare function extractCrossFrames({ snapshot, parent, logger, }: {
+    snapshot: RawDomSnapshot;
     parent?: any;
-    logger: any;
-}): any[];
+    logger: Logger;
+}): {
+    cdtNode: RawDomSnapshot['cdt'][number];
+    reference: any;
+    parentSnapshot: RawDomSnapshot;
+}[];
+export {};

package/types/ufg/utils/take-snapshots.d.ts

@@ -17,5 +17,5 @@ export declare function takeSnapshots<TDriver extends Driver<unknown, unknown, u
         getChromeEmulationDevices(): Promise<Record<ChromeEmulationDevice, Record<ScreenOrientation, Size>>>;
         getIOSDevices(): Promise<Record<IOSDevice, Record<ScreenOrientation, Size>>>;
     };
-    logger?: Logger;
+    logger: Logger;
 }): Promise<DomSnapshot[] | AndroidSnapshot[] | IOSSnapshot[]>;

package/types/ufg/utils/take-vhses.d.ts

@@ -8,7 +8,7 @@ export type VHSesSettings = ServerSettings & {
 };
 export declare function takeVHSes<TDriver extends Driver<unknown, unknown, unknown, unknown>>({ driver, settings, hooks, logger, }: {
     driver: TDriver;
-    settings?: VHSesSettings;
+    settings: VHSesSettings;
     hooks?: {
         beforeSnapshots?(): void | Promise<void>;
         beforeEachSnapshot?(): void | Promise<void>;

package/types/utils/format-results.d.ts

@@ -13,4 +13,4 @@ export declare function toFlattenedTAPString(results: TestResult[], { markNewAsP
 export declare function toXmlOutput(results: TestResult[], { totalTime }?: {
     totalTime?: number;
 }): string;
-export declare function toJsonOutput(results: any, space: any): string;
+export declare function toJsonOutput(results: TestResult[], space?: number | string): string;

package/dist/utils/extract-broker-url.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractBrokerUrl = void 0;
-async function extractBrokerUrl(driver) {
-    try {
-        const selector = driver.isIOS
-            ? '//XCUIElementTypeOther[@name="Applitools_View"]'
-            : driver.isAndroid
-                ? '//android.widget.TextView[@content-desc="Applitools_View"]'
-                : null;
-        if (!selector)
-            return null;
-        const element = await driver.element({
-            type: 'xpath',
-            selector,
-        });
-        const result = JSON.parse(await element.getText());
-        return result.nextPath;
-    }
-    catch (error) {
-        return null;
-    }
-}
-exports.extractBrokerUrl = extractBrokerUrl;

package/types/utils/extract-broker-url.d.ts

@@ -1,2 +0,0 @@
-import { type Driver } from '@applitools/driver';
-export declare function extractBrokerUrl(driver: Driver<unknown, unknown, unknown, unknown>): Promise<string>;

package/types/utils/to-base-check-settings.d.ts

@@ -1,18 +0,0 @@
-import type { Region } from '@applitools/utils';
-import type { CheckSettings as BaseCheckSettings } from '@applitools/core-base';
-import type { CheckSettings as UFGCheckSettings } from '../ufg/types';
-import type { CheckSettings as ClassicCheckSettings } from '../ufg/types';
-import { type Selector } from '@applitools/driver';
-export declare function toBaseCheckSettings<TElement, TSelector>({ settings, }: {
-    settings: ClassicCheckSettings<TElement, TSelector> | UFGCheckSettings<TElement, TSelector>;
-}): {
-    elementReferencesToCalculate: (TElement | Selector<TSelector>)[];
-    elementReferenceToTarget: TElement | Selector<TSelector>;
-    getBaseCheckSettings: ({ calculatedRegions, preserveTransformation, }: {
-        calculatedRegions: {
-            selector: Selector;
-            regions: Region[];
-        }[];
-        preserveTransformation?: boolean;
-    }) => BaseCheckSettings;
-};