@applitools/core 3.6.6 → 3.8.0

package/types/ufg/close.d.ts

@@ -1,19 +0,0 @@
-import type { DriverTarget, CloseSettings } from './types';
-import { type Eyes as BaseEyes } from '@applitools/core-base';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-import { Renderer } from '@applitools/ufg-client';
-type Options<TSpec extends SpecType> = {
-    storage: Map<string, Promise<{
-        renderer: Renderer;
-        eyes: BaseEyes;
-    }>[]>;
-    target?: DriverTarget<TSpec>;
-    spec?: SpecDriver<TSpec>;
-    logger: Logger;
-};
-export declare function makeClose<TSpec extends SpecType>({ storage, target, spec, logger: mainLogger }: Options<TSpec>): ({ settings, logger, }?: {
-    settings?: CloseSettings | undefined;
-    logger?: Logger | undefined;
-}) => Promise<void>;
-export {};

package/types/ufg/core.d.ts

@@ -1,21 +0,0 @@
-import type { Core } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
-import { type UFGClient } from '@applitools/ufg-client';
-import { type NMLClient } from '@applitools/nml-client';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-import { type Logger } from '@applitools/logger';
-type Options<TSpec extends SpecType> = {
-    spec?: SpecDriver<TSpec>;
-    clients?: {
-        ufg?: UFGClient;
-        nml?: NMLClient;
-    };
-    base?: BaseCore;
-    agentId?: string;
-    concurrency?: number;
-    fetchConcurrency?: number;
-    cwd?: string;
-    logger?: Logger;
-};
-export declare function makeCore<TSpec extends SpecType>({ concurrency, spec, clients, base, fetchConcurrency, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
-export {};

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

@@ -1,19 +0,0 @@
-import type { Eyes, GetBaseEyesSettings, OpenSettings } from './types';
-import type { Eyes as BaseEyes } from '@applitools/core-base';
-import { type SpecType } from '@applitools/driver';
-import { type Logger } from '@applitools/logger';
-type Options<TSpec extends SpecType> = {
-    settings: OpenSettings;
-    eyes: Eyes<TSpec>;
-    base?: BaseEyes[];
-    logger: Logger;
-};
-export declare function makeGetBaseEyes<TSpec extends SpecType>({ settings: defaultSettings, eyes, base, logger: mainLogger, }: Options<TSpec>): (({ settings, logger, }?: {
-    settings?: GetBaseEyesSettings | undefined;
-    logger?: Logger | undefined;
-}) => Promise<BaseEyes[]>) & {
-    getCachedValues(): Promise<BaseEyes[]>[];
-    setCachedValue(key: any, value: Promise<BaseEyes[]>): void;
-    clearCache(): void;
-};
-export {};

package/types/ufg/get-results.d.ts

@@ -1,16 +0,0 @@
-import type { GetResultsSettings, TestResult } from './types';
-import { type Eyes as BaseEyes } from '@applitools/core-base';
-import { type Logger } from '@applitools/logger';
-import { Renderer } from '@applitools/ufg-client';
-type Options = {
-    storage: Map<string, Promise<{
-        renderer: Renderer;
-        eyes: BaseEyes;
-    }>[]>;
-    logger: Logger;
-};
-export declare function makeGetResults({ storage, logger: mainLogger }: Options): ({ settings, logger, }?: {
-    settings?: GetResultsSettings | undefined;
-    logger?: Logger | undefined;
-}) => Promise<TestResult[]>;
-export {};

package/types/ufg/get-ufg-client.d.ts

@@ -1,16 +0,0 @@
-import { type Logger } from '@applitools/logger';
-import { type UFGClient, type UFGClientSettings } from '@applitools/ufg-client';
-type Options = {
-    client?: UFGClient;
-    fetchConcurrency?: number;
-    logger: Logger;
-};
-export declare function makeGetUFGClient({ client, fetchConcurrency, logger: mainLogger }: Options): (({ settings, logger }: {
-    settings: UFGClientSettings;
-    logger?: Logger | undefined;
-}) => Promise<UFGClient>) & {
-    getCachedValues(): Promise<UFGClient>[];
-    setCachedValue(key: any, value: Promise<UFGClient>): void;
-    clearCache(): void;
-};
-export {};

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

@@ -1,16 +0,0 @@
-import type { DriverTarget, Core, Eyes, OpenSettings } from './types';
-import type { Eyes as BaseEyes } from '@applitools/core-base';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type SpecDriver } from '@applitools/driver';
-type Options<TSpec extends SpecType> = {
-    core: Core<TSpec>;
-    spec?: SpecDriver<TSpec>;
-    logger: Logger;
-};
-export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: mainLogger }: Options<TSpec>): ({ target, settings, base, logger, }: {
-    target?: DriverTarget<TSpec> | undefined;
-    settings: OpenSettings;
-    base?: BaseEyes[] | undefined;
-    logger?: Logger | undefined;
-}) => Promise<Eyes<TSpec>>;
-export {};

package/types/ufg/types.d.ts

@@ -1,72 +0,0 @@
-import type { MaybeArray } from '@applitools/utils';
-import type * as BaseCore from '@applitools/core-base/types';
-import type * as AutomationCore from '../automation/types';
-import { type SpecType } from '@applitools/driver';
-import { type Logger } from '@applitools/logger';
-import { type Proxy } from '@applitools/req';
-import { type UFGClient, type UFGClientSettings, type RenderEnvironmentSettings, type Renderer, type DomSnapshot, type AndroidSnapshot, type IOSSnapshot } from '@applitools/ufg-client';
-export * from '../automation/types';
-export type SnapshotTarget = MaybeArray<DomSnapshot> | MaybeArray<AndroidSnapshot> | MaybeArray<IOSSnapshot>;
-export type Target<TSpec extends SpecType> = SnapshotTarget | AutomationCore.Target<TSpec>;
-export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec> {
-    readonly type: 'ufg';
-    getUFGClient(options?: {
-        settings: UFGClientSettings;
-        logger?: Logger;
-    }): Promise<UFGClient>;
-    openEyes(options: {
-        target?: AutomationCore.DriverTarget<TSpec>;
-        settings: AutomationCore.OpenSettings;
-        base?: BaseCore.Eyes[];
-        logger?: Logger;
-    }): Promise<Eyes<TSpec>>;
-}
-export interface Eyes<TSpec extends SpecType> extends AutomationCore.Eyes<TSpec> {
-    readonly type: 'ufg';
-    readonly core: Core<TSpec>;
-    getBaseEyes(options?: {
-        settings?: GetBaseEyesSettings;
-        logger?: Logger;
-    }): Promise<BaseCore.Eyes[]>;
-    check(options?: {
-        target?: Target<TSpec>;
-        settings?: CheckSettings<TSpec>;
-        logger?: Logger;
-    }): Promise<CheckResult[]>;
-    checkAndClose(options?: {
-        target?: Target<TSpec>;
-        settings?: CheckSettings<TSpec> & AutomationCore.CloseSettings;
-        logger?: Logger;
-    }): Promise<void>;
-    getResults(options?: {
-        settings?: AutomationCore.GetResultsSettings;
-        logger?: Logger;
-    }): Promise<TestResult[]>;
-}
-export type GetBaseEyesSettings = RenderEnvironmentSettings & {
-    properties?: BaseCore.CustomProperty[];
-};
-export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
-    renderers?: (Renderer & {
-        properties?: BaseCore.CustomProperty[];
-    })[];
-    hooks?: {
-        beforeCaptureScreenshot: string;
-    };
-    disableBrowserFetching?: boolean;
-    layoutBreakpoints?: {
-        breakpoints: number[] | boolean;
-        reload?: boolean;
-    };
-    ufgOptions?: Record<string, any>;
-    autProxy?: Proxy & {
-        mode?: 'Allow' | 'Block';
-        domains?: string[];
-    };
-};
-export type CheckResult = AutomationCore.CheckResult & {
-    readonly renderer: Renderer;
-};
-export type TestResult = AutomationCore.TestResult & {
-    readonly renderer: Renderer;
-};

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

@@ -1,16 +0,0 @@
-import { type SpecType, type Context, type ElementReference, type CommonSelector } from '@applitools/driver';
-export declare function generateSafeSelectors<TSpec extends SpecType>({ context, elementReferences, }: {
-    context: Context<TSpec>;
-    elementReferences: ElementReference<TSpec>[];
-}): Promise<{
-    selectors: ({
-        safeSelector: null;
-        originalSelector: null;
-        elementReference: ElementReference<TSpec>;
-    } | {
-        safeSelector: CommonSelector;
-        originalSelector: CommonSelector | null;
-        elementReference: ElementReference<TSpec>;
-    })[];
-    cleanupGeneratedSelectors: () => Promise<void>;
-}>;

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

@@ -1,47 +0,0 @@
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type Context } from '@applitools/driver';
-import { type DomSnapshot } from '@applitools/ufg-client';
-export 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;
-    }[];
-    srcAttr: string | null;
-    scriptVersion: string;
-};
-export type DomSnapshotSettings = {
-    disableBrowserFetching?: boolean;
-    skipResources?: string[];
-    chunkByteLength?: number;
-    executionTimeout?: number;
-    pollTimeout?: number;
-    showLogs?: boolean;
-};
-export declare function takeDomSnapshot<TSpec extends SpecType>({ context, settings, logger, }: {
-    context: Context<TSpec>;
-    settings?: DomSnapshotSettings;
-    logger: Logger;
-}): Promise<DomSnapshot>;
-export declare function extractCrossFrames({ snapshot, parent, logger, }: {
-    snapshot: RawDomSnapshot;
-    parent?: any;
-    logger: Logger;
-}): {
-    cdtNode: RawDomSnapshot['cdt'][number];
-    reference: any;
-    parentSnapshot: RawDomSnapshot;
-}[];

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

@@ -1,27 +0,0 @@
-import type { Size } from '@applitools/utils';
-import { type Logger } from '@applitools/logger';
-import { type SpecType, type Driver } from '@applitools/driver';
-import { type DomSnapshot, type Renderer, type ChromeEmulationDevice, type IOSDevice, type ScreenOrientation } from '@applitools/ufg-client';
-import { type DomSnapshotSettings } from './take-dom-snapshot';
-export * from './take-dom-snapshot';
-export type DomSnapshotsSettings = DomSnapshotSettings & {
-    renderers: Renderer[];
-    waitBeforeCapture?: number | (() => void);
-    layoutBreakpoints?: {
-        breakpoints: number[] | boolean;
-        reload?: boolean;
-    };
-};
-export declare function takeDomSnapshots<TSpec extends SpecType>({ driver, settings, hooks, provides, logger, }: {
-    driver: Driver<TSpec>;
-    settings: DomSnapshotsSettings;
-    hooks?: {
-        beforeSnapshots?(): void | Promise<void>;
-        beforeEachSnapshot?(): void | Promise<void>;
-    };
-    provides?: {
-        getChromeEmulationDevices(): Promise<Record<ChromeEmulationDevice, Record<ScreenOrientation, Size>>>;
-        getIOSDevices(): Promise<Record<IOSDevice, Record<ScreenOrientation, Size>>>;
-    };
-    logger: Logger;
-}): Promise<DomSnapshot[]>;

package/types/ufg/utils/uniquify-renderers.d.ts

@@ -1,2 +0,0 @@
-import { type Renderer } from '@applitools/ufg-client';
-export declare function uniquifyRenderers<TRenderer extends Renderer>(renderers: TRenderer[]): TRenderer[];

package/types/universal/core-server-process.d.ts

@@ -1,9 +0,0 @@
-/// <reference types="node" />
-import { type Options } from './core-server';
-import { type ForkOptions } from 'child_process';
-export declare function makeCoreServerProcess(options: Options & {
-    forkOptions?: ForkOptions;
-}): Promise<{
-    port: number;
-    close: () => void;
-}>;

package/types/universal/core-server.d.ts

@@ -1,13 +0,0 @@
-import { type ServerOptions } from './ws-server';
-export type Options = ServerOptions & {
-    debug?: boolean;
-    shutdownMode?: 'lazy' | 'stdin';
-    idleTimeout?: number;
-    printStdout?: boolean;
-    isProcess?: boolean;
-};
-export declare function makeCoreServer({ debug, shutdownMode, idleTimeout, // 15min
-printStdout, isProcess, ...handlerOptions }?: Options): Promise<{
-    port: number;
-    close?: () => void;
-}>;

package/types/universal/core.d.ts

@@ -1,23 +0,0 @@
-import type { Core, EyesManager, Eyes } from '../types';
-import type { ClientSocket, Ref } from './types';
-import type { SpecType, SpecDriver } from '@applitools/driver';
-import { type Socket } from '@applitools/socket';
-import { WebSocket } from 'ws';
-export declare function makeCore<TSpec extends SpecType, TType extends 'classic' | 'ufg'>(options: {
-    agentId: string;
-    spec: 'webdriver' | SpecDriver<TSpec>;
-}): Core<TSpec, TType>;
-export declare function makeManager<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ socket, core, managerRef, }: {
-    socket: ClientSocket<TSpec, TType>;
-    core: Core<TSpec, TType>;
-    managerRef: Ref<EyesManager<TSpec, TType>>;
-}): EyesManager<TSpec, TType>;
-export declare function makeEyes<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ socket, core, eyesRef, }: {
-    socket: ClientSocket<TSpec, TType>;
-    core: Core<TSpec, TType>;
-    eyesRef: Ref<Eyes<TSpec, TType>>;
-}): Eyes<TSpec, TType>;
-export declare function makeClientSocket<TSpec extends SpecType>({ agentId, spec, }: {
-    agentId: string;
-    spec: 'webdriver' | SpecDriver<TSpec>;
-}): Promise<ClientSocket<TSpec, 'classic' | 'ufg'> & Socket<WebSocket>>;

package/types/universal/history.d.ts

@@ -1,2 +0,0 @@
-import { type Socket } from '@applitools/socket';
-export declare function withHistory<TSocket extends Socket>(socket: TSocket): () => Record<string, any>;

package/types/universal/refer.d.ts

@@ -1,8 +0,0 @@
-import type { Ref } from './types';
-export interface Refer {
-    isRef<TValue = any>(ref: any): ref is Ref<TValue>;
-    ref<TValue>(value: TValue, parentRef?: Ref<unknown>): Ref<TValue>;
-    deref<TValue>(ref: Ref<TValue>): TValue;
-    destroy(ref: Ref<any>): void;
-}
-export declare function makeRefer(): Refer;

package/types/universal/spec-driver.d.ts

@@ -1,11 +0,0 @@
-import type { Ref, ServerSocket, UniversalSpecDriver } from './types';
-import type { SpecType as BaseSpecType, SpecDriver, CommonSelector } from '@applitools/driver';
-export type Driver = Ref;
-export type Context = Ref;
-export type Element = Ref;
-export type Selector = string | CommonSelector | Ref;
-export type SpecType = BaseSpecType<Driver, Context, Element, Selector>;
-export declare function makeSpec({ socket, spec, }: {
-    socket: ServerSocket<SpecType, any>;
-    spec: (keyof UniversalSpecDriver<SpecType>)[];
-}): SpecDriver<SpecType>;

package/types/universal/types.d.ts

@@ -1,188 +0,0 @@
-import type { Size, Region } from '@applitools/utils';
-import type { Emitter, Listener, Client, Server } from '@applitools/socket';
-import type { SpecType, DriverInfo, Cookie, WaitOptions } from '@applitools/driver';
-import type * as MainCore from '../types';
-/**
- * Wraps the type with a ref if it vas to be refed
- */
-type Refify<TValue> = TValue extends string | number | boolean | null | undefined ? TValue : TValue extends Array<infer TItem> ? Refify<TItem>[] : Extract<TValue[keyof TValue], (...args: any) => any> extends never ? TValue : Ref<TValue>;
-/**
- * Creates universalized object out of an ordinary interface:
- * - Filters out properties that are not of async function type
- * - Adds domain to the method names (`Domain.methodName`)
- * - Keep only first (`options`) argument of the methods
- * - Introduces additional option to the methods with a ref of the current instance
- * - Refifies return values of the methods
- */
-type Universalize<TTarget extends Record<string, any>, TDomain extends string, TRefKey extends string = never> = {
-    [TKey in keyof TTarget as NonNullable<TTarget[TKey]> extends (...args: any[]) => Promise<any> ? `${TDomain}.${TKey & string}` : never]: NonNullable<TTarget[TKey]> extends (options: infer TOptions) => Promise<infer TResult> ? (options: TOptions & {
-        [TKey in TRefKey]: Ref<TTarget>;
-    }) => Promise<Refify<TResult>> : never;
-};
-export type Ref<TValue = never> = {
-    'applitools-ref-id': string;
-    type?: string;
-};
-export type ClientSocket<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = unknown & Emitter<Universalize<UniversalCore<TSpec, TType>, 'Core'>> & Client<Universalize<MainCore.Core<TSpec, TType>, 'Core'>> & Client<Universalize<MainCore.EyesManager<TSpec, TType>, 'EyesManager', 'manager'>> & Client<Universalize<MainCore.Eyes<TSpec, TType>, 'Eyes', 'eyes'>> & Client<Universalize<UniversalDebug<TSpec>, 'Debug'>> & Server<Universalize<UniversalSpecDriver<TSpec>, 'Driver'>>;
-export type ServerSocket<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = unknown & Listener<Universalize<UniversalCore<TSpec, TType>, 'Core'>> & Emitter<Universalize<UniversalLogger, 'Logger'>> & Server<Universalize<MainCore.Core<TSpec, TType>, 'Core'>> & Server<Universalize<MainCore.EyesManager<TSpec, TType>, 'EyesManager', 'manager'>> & Server<Universalize<MainCore.Eyes<TSpec, TType>, 'Eyes', 'eyes'>> & Server<Universalize<UniversalDebug<TSpec>, 'Debug'>> & Client<Universalize<UniversalSpecDriver<TSpec>, 'Driver'>>;
-export interface UniversalCore<TSpec extends SpecType, TType extends 'classic' | 'ufg'> {
-    makeCore(options: {
-        agentId: string;
-        cwd: string;
-        spec: 'webdriver' | (keyof UniversalSpecDriver<TSpec>)[];
-    }): Promise<MainCore.Core<TSpec, TType>>;
-}
-export interface UniversalLogger {
-    log(options: {
-        level: string;
-        message: string;
-    }): Promise<void>;
-}
-export interface UniversalDebug<TSpec extends SpecType> {
-    getHistory(): Promise<any>;
-    checkSpecDriver(options: {
-        driver: TSpec['driver'];
-        commands: (keyof UniversalSpecDriver<TSpec>)[];
-    }): Promise<any>;
-}
-/**
- * Ideally would be transform SpecDriver type to the type with single object argument
- * but typescript doesn't have a possibility to convert named tuples to object types at the moment
- */
-export interface UniversalSpecDriver<T extends SpecType> {
-    isEqualElements(options: {
-        context: T['context'];
-        element1: T['element'];
-        element2: T['element'];
-    }): Promise<boolean>;
-    mainContext(options: {
-        context: T['context'];
-    }): Promise<T['context']>;
-    parentContext(options: {
-        context: T['context'];
-    }): Promise<T['context']>;
-    childContext(options: {
-        context: T['context'];
-        element: T['element'];
-    }): Promise<T['context']>;
-    executeScript(options: {
-        context: T['context'];
-        script: string;
-        arg?: any;
-    }): Promise<any>;
-    findElement(options: {
-        context: T['context'];
-        selector: T['selector'];
-        parent?: T['element'];
-    }): Promise<T['element'] | null>;
-    findElements(options: {
-        context: T['context'];
-        selector: T['selector'];
-        parent?: T['element'];
-    }): Promise<T['element'][]>;
-    waitForSelector(options: {
-        context: T['context'];
-        selector: T['selector'];
-        parent?: T['element'];
-        options?: WaitOptions;
-    }): Promise<T['element'] | null>;
-    setElementText(options: {
-        context: T['context'];
-        element: T['element'];
-        text: string;
-    }): Promise<void>;
-    getElementText(options: {
-        context: T['context'];
-        element: T['element'];
-    }): Promise<string>;
-    setWindowSize(options: {
-        driver: T['driver'];
-        size: Size;
-    }): Promise<void>;
-    getWindowSize(options: {
-        driver: T['driver'];
-    }): Promise<Size>;
-    setViewportSize(options: {
-        driver: T['driver'];
-        size: Size;
-    }): Promise<void>;
-    getViewportSize(options: {
-        driver: T['driver'];
-    }): Promise<Size>;
-    getCookies(options: {
-        driver: T['driver'] | T['context'];
-        context?: boolean;
-    }): Promise<Cookie[]>;
-    getDriverInfo(options: {
-        driver: T['driver'];
-    }): Promise<DriverInfo>;
-    getCapabilities(options: {
-        driver: T['driver'];
-    }): Promise<Record<string, any>>;
-    getTitle(options: {
-        driver: T['driver'];
-    }): Promise<string>;
-    getUrl(options: {
-        driver: T['driver'];
-    }): Promise<string>;
-    takeScreenshot(options: {
-        driver: T['driver'];
-    }): Promise<string>;
-    click(options: {
-        context: T['context'];
-        element: T['element'] | T['selector'];
-    }): Promise<void>;
-    visit(options: {
-        driver: T['driver'];
-        url: string;
-    }): Promise<void>;
-    getOrientation(options: {
-        driver: T['driver'];
-    }): Promise<'portrait' | 'landscape' | 'portrait-secondary' | 'landscape-secondary'>;
-    setOrientation(options: {
-        driver: T['driver'];
-        orientation: 'portrait' | 'landscape' | 'portrait-secondary' | 'landscape-secondary';
-    }): Promise<void>;
-    getSystemBars(options: {
-        driver: T['driver'];
-    }): Promise<{
-        statusBar: {
-            visible: boolean;
-            x: number;
-            y: number;
-            height: number;
-            width: number;
-        };
-        navigationBar: {
-            visible: boolean;
-            x: number;
-            y: number;
-            height: number;
-            width: number;
-        };
-    }>;
-    getElementRegion(options: {
-        driver: T['driver'];
-        element: T['element'];
-    }): Promise<Region>;
-    getElementAttribute(options: {
-        driver: T['driver'];
-        element: T['element'];
-        attr: string;
-    }): Promise<string>;
-    performAction(options: {
-        driver: T['driver'];
-        steps: any[];
-    }): Promise<void>;
-    getCurrentWorld(options: {
-        driver: T['driver'];
-    }): Promise<string>;
-    getWorlds(options: {
-        driver: T['driver'];
-    }): Promise<string[]>;
-    switchWorld(options: {
-        driver: T['driver'];
-        name: string;
-    }): Promise<void>;
-}
-export {};

package/types/universal/ws-server.d.ts

@@ -1,14 +0,0 @@
-/// <reference types="node" />
-import { Server as WsServer } from 'ws';
-export type ServerOptions = {
-    port?: number;
-    singleton?: boolean;
-    portResolutionMode?: 'next' | 'random' | 'lazy';
-    debug?: boolean;
-    key?: string | Buffer;
-    cert?: string | Buffer;
-};
-export declare function makeServer(options?: ServerOptions): Promise<{
-    server?: WsServer;
-    port: number;
-}>;

package/types/utils/extract-ci-provider.d.ts

@@ -1 +0,0 @@
-export declare function extractCIProvider(): string | null;

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

@@ -1,16 +0,0 @@
-import type { TestResult } from '@applitools/core-base';
-export declare function toFormatterString(results: TestResult[], { includeSubTests, markNewAsPassed }?: {
-    includeSubTests?: boolean;
-    markNewAsPassed?: boolean;
-}): string;
-export declare function toHierarchicTAPString(results: TestResult[], { includeSubTests, markNewAsPassed }?: {
-    includeSubTests?: boolean;
-    markNewAsPassed?: boolean;
-}): string;
-export declare function toFlattenedTAPString(results: TestResult[], { markNewAsPassed }?: {
-    markNewAsPassed?: boolean;
-}): string;
-export declare function toXmlOutput(results: TestResult[], { totalTime }?: {
-    totalTime?: number;
-}): string;
-export declare function toJsonOutput(results: TestResult[], space?: number | string): string;

package/types/utils/separate-duplicate-results.d.ts

@@ -1,2 +0,0 @@
-import { TestResultContainer } from '../types';
-export declare function separateDuplicateResults(containers: TestResultContainer<'classic' | 'ufg'>[]): TestResultContainer<"classic" | "ufg">[][];