@applitools/core 2.3.14 → 2.4.0

package/types/classic/types.d.ts

@@ -3,24 +3,25 @@ import type * as AutomationCore from '../automation/types';
 import { type SpecType } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 export * from '../automation/types';
-export interface Core<TSpec extends SpecType, TTarget = AutomationCore.Target<TSpec>, TEyes extends Eyes<TSpec, TTarget> = Eyes<TSpec, TTarget>> extends AutomationCore.Core<TSpec, TTarget, TEyes> {
+export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec> {
     readonly type: 'classic';
     openEyes(options: {
         target?: AutomationCore.DriverTarget<TSpec>;
         settings: OpenSettings;
-        eyes?: BaseCore.Eyes[];
+        base?: BaseCore.Eyes[];
         logger?: Logger;
-    }): Promise<TEyes>;
+    }): Promise<Eyes<TSpec>>;
 }
-export interface Eyes<TSpec extends SpecType, TTarget = AutomationCore.Target<TSpec>> extends AutomationCore.Eyes<TSpec, TTarget> {
+export interface Eyes<TSpec extends SpecType> extends AutomationCore.Eyes<TSpec> {
     readonly type: 'classic';
+    readonly core: Core<TSpec>;
     check(options?: {
-        target?: TTarget;
+        target?: AutomationCore.Target<TSpec>;
         settings?: CheckSettings<TSpec>;
         logger?: Logger;
     }): Promise<AutomationCore.CheckResult[]>;
     checkAndClose(options?: {
-        target?: TTarget;
+        target?: AutomationCore.Target<TSpec>;
         settings?: CheckSettings<TSpec> & AutomationCore.CloseSettings;
         logger?: Logger;
     }): Promise<AutomationCore.TestResult[]>;

package/types/close-batch.d.ts

@@ -1,9 +1,8 @@
 import type { MaybeArray } from '@applitools/utils';
-import type { CloseBatchSettings } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
+import type { Core, CloseBatchSettings } from './types';
 import { type Logger } from '@applitools/logger';
 type Options = {
-    core: BaseCore;
+    core: Core<any>;
     logger: Logger;
 };
 export declare function makeCloseBatch({ core, logger: defaultLogger }: Options): ({ settings, logger, }: {

package/types/core.d.ts

@@ -5,10 +5,10 @@ import { type Logger } from '@applitools/logger';
 type Options<TSpec extends SpecType> = {
     spec?: SpecDriver<TSpec>;
     concurrency?: number;
-    core?: BaseCore;
+    base?: BaseCore;
     agentId?: string;
     cwd?: string;
     logger?: Logger;
 };
-export declare function makeCore<TSpec extends SpecType>({ spec, concurrency, core: defaultCore, agentId, cwd, logger, }?: Options<TSpec>): Core<TSpec, 'classic' | 'ufg'>;
+export declare function makeCore<TSpec extends SpecType>({ spec, concurrency, base: defaultBase, agentId, cwd, logger: defaultLogger, }?: Options<TSpec>): Core<TSpec, 'classic' | 'ufg'>;
 export {};

package/types/delete-test.d.ts

@@ -1,9 +1,8 @@
 import type { MaybeArray } from '@applitools/utils';
-import type { DeleteTestSettings } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
+import type { Core, DeleteTestSettings } from './types';
 import { type Logger } from '@applitools/logger';
 type Options = {
-    core: BaseCore;
+    core: Core<any>;
     logger: Logger;
 };
 export declare function makeDeleteTest({ core, logger: defaultLogger }: Options): ({ settings, logger, }: {

package/types/extract-text.d.ts

@@ -1,11 +1,10 @@
 import type { MaybeArray } from '@applitools/utils';
-import type { Target, Config, ExtractTextSettings } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
+import type { Target, Core, ExtractTextSettings, Config } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     spec?: SpecDriver<TSpec>;
-    core: BaseCore;
+    core: Core<TSpec>;
     logger: Logger;
 };
 export declare function makeExtractText<TSpec extends SpecType>({ spec, core, logger: defaultLogger }: Options<TSpec>): ({ target, settings, config, logger, }: {

package/types/{make-ec-client.d.ts → get-ec-client.d.ts}

@@ -1,11 +1,9 @@
-import type { Core as BaseCore } from '@applitools/core-base';
 import { type ECClient, type ECClientSettings } from '@applitools/ec-client';
 import { type Logger } from '@applitools/logger';
 type Options = {
-    core: BaseCore;
     logger: Logger;
 };
-export declare function makeMakeECClient({ logger: defaultLogger }: Options): (({ settings, logger, }?: {
+export declare function makeGetECClient({ logger: defaultLogger }: Options): (({ settings, logger, }?: {
     settings?: Partial<ECClientSettings> | undefined;
     logger?: Logger | undefined;
 }) => Promise<ECClient>) & {

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

@@ -1,9 +1,8 @@
-import type { Eyes, GetResultsSettings, TestResultSummary } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
+import type { Core, Eyes, GetResultsSettings, TestResultSummary } from './types';
 import { type SpecType } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
-    core: BaseCore<unknown>;
+    core: Core<TSpec>;
     storage: Eyes<TSpec, TType>[];
     logger: Logger;
 };

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

@@ -1,6 +1,6 @@
 import type { DriverTarget, TypedCore, TypedEyes, OpenSettings } from './types';
 import { type SpecType } from '@applitools/driver';
-import { type Renderer } from '@applitools/ufg-client';
+import { type RendererSettings } from '@applitools/ufg-client';
 import { type Logger } from '@applitools/logger';
 type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     type: TType;
@@ -13,10 +13,7 @@ type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
 };
 export declare function makeGetTypedEyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'>({ type: defaultType, settings: defaultSettings, target, cores, logger: defaultLogger, }: Options<TSpec, TDefaultType>): <TType extends "classic" | "ufg" = TDefaultType>({ type, settings, logger, }?: {
     type?: TType | undefined;
-    settings?: {
-        type: 'web' | 'native';
-        renderers: Renderer[];
-    } | undefined;
+    settings?: RendererSettings[] | undefined;
     logger?: Logger | undefined;
-}) => Promise<TypedEyes<TSpec, TType, import("./types").Target<TSpec, TType>>>;
+}) => Promise<TypedEyes<TSpec, TType>>;
 export {};

package/types/locate-text.d.ts

@@ -1,10 +1,9 @@
-import type { Target, Config, LocateTextSettings, LocateTextResult } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
+import type { Core, Target, LocateTextSettings, Config, LocateTextResult } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     spec?: SpecDriver<TSpec>;
-    core: BaseCore;
+    core: Core<TSpec>;
     logger: Logger;
 };
 export declare function makeLocateText<TSpec extends SpecType>({ spec, core, logger: defaultLogger }: Options<TSpec>): <TPattern extends string>({ target, settings, config, logger, }: {

package/types/locate.d.ts

@@ -1,11 +1,10 @@
 import type { Region } from '@applitools/utils';
-import type { Target, Config, LocateSettings } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
+import type { Target, Core, LocateSettings, Config } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     spec?: SpecDriver<TSpec>;
-    core: BaseCore;
+    core: Core<TSpec>;
     logger: Logger;
 };
 export declare function makeLocate<TSpec extends SpecType>({ spec, core, logger: defaultLogger }: Options<TSpec>): <TLocator extends string>({ target, settings, config, logger, }: {

package/types/make-manager.d.ts

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

package/types/open-eyes.d.ts

@@ -1,12 +1,11 @@
-import type { TypedCore, Batch, Eyes, Config, OpenSettings, DriverTarget } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
+import type { DriverTarget, Core, TypedCore, Batch, Eyes, Config, OpenSettings } from './types';
 import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = {
     type?: TType;
     concurrency?: number;
     batch?: Batch;
-    core: BaseCore;
+    core: Core<TSpec, TType>;
     cores?: {
         [TKey in 'classic' | 'ufg']: TypedCore<TSpec, TKey>;
     };
@@ -19,5 +18,5 @@ export declare function makeOpenEyes<TSpec extends SpecType, TDefaultType extend
     config?: (Config<TSpec, TDefaultType> & Config<TSpec, TType>) | undefined;
     target?: DriverTarget<TSpec> | undefined;
     logger?: Logger | undefined;
-}) => Promise<Eyes<TSpec, TType, import("./types").Target<TSpec, TType>>>;
+}) => Promise<Eyes<TSpec, TType>>;
 export {};

package/types/types.d.ts

@@ -1,19 +1,19 @@
 import type { MaybeArray } from '@applitools/utils';
-import type { ECClient } from '@applitools/ec-client';
 import type * as AutomationCore from './automation/types';
 import type * as ClassicCore from './classic/types';
 import type * as UFGCore from './ufg/types';
 import { type SpecType } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 import { type Renderer } from '@applitools/ufg-client';
+import { type ECClient, type ECClientSettings } from '@applitools/ec-client';
 export { ECClient };
 export * from './automation/types';
 export type TypedCore<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.Core<TSpec> : ClassicCore.Core<TSpec>;
-export type TypedEyes<TSpec extends SpecType, TType extends 'classic' | 'ufg', TTarget = Target<TSpec, TType>> = TType extends 'ufg' ? UFGCore.Eyes<TSpec, TTarget> : ClassicCore.Eyes<TSpec, TTarget>;
+export type TypedEyes<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.Eyes<TSpec> : ClassicCore.Eyes<TSpec>;
 export type Target<TSpec extends SpecType, TType extends 'classic' | 'ufg'> = TType extends 'ufg' ? UFGCore.Target<TSpec> : ClassicCore.Target<TSpec>;
-export interface Core<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'> extends AutomationCore.Core<TSpec> {
-    makeECClient(options?: {
-        settings?: any;
+export interface Core<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg' = 'classic' | 'ufg'> extends AutomationCore.Core<TSpec> {
+    getECClient(options?: {
+        settings?: Partial<ECClientSettings>;
         logger?: Logger;
     }): Promise<ECClient>;
     makeManager<TType extends 'classic' | 'ufg' = TDefaultType>(options?: {
@@ -48,7 +48,7 @@ export interface Core<TSpec extends SpecType, TDefaultType extends 'classic' | '
         logger?: Logger;
     }): Promise<string[]>;
 }
-export interface EyesManager<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg'> {
+export interface EyesManager<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg' = 'classic' | 'ufg'> {
     openEyes<TType extends 'classic' | 'ufg' = TDefaultType>(options: {
         type?: TType;
         target?: AutomationCore.DriverTarget<TSpec>;
@@ -61,7 +61,8 @@ export interface EyesManager<TSpec extends SpecType, TDefaultType extends 'class
         logger?: Logger;
     }) => Promise<TestResultSummary<'classic' | 'ufg'>>;
 }
-export interface Eyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg', TTarget = Target<TSpec, TDefaultType>> extends AutomationCore.Eyes<TSpec> {
+export interface Eyes<TSpec extends SpecType, TDefaultType extends 'classic' | 'ufg' = 'classic' | 'ufg'> extends AutomationCore.Eyes<TSpec> {
+    readonly core: Core<TSpec, TDefaultType>;
     getTypedEyes<TType extends 'classic' | 'ufg' = TDefaultType>(options?: {
         type?: TType;
         settings?: any;
@@ -69,14 +70,14 @@ export interface Eyes<TSpec extends SpecType, TDefaultType extends 'classic' | '
     }): Promise<TypedEyes<TSpec, TType>>;
     check<TType extends 'classic' | 'ufg' = TDefaultType>(options?: {
         type?: TType;
-        target?: TTarget;
+        target?: Target<TSpec, TType>;
         settings?: Partial<CheckSettings<TSpec, TDefaultType> & CheckSettings<TSpec, TType>>;
         config?: Config<TSpec, TDefaultType> & Config<TSpec, TType>;
         logger?: Logger;
     }): Promise<CheckResult<TType>[]>;
     checkAndClose<TType extends 'classic' | 'ufg' = TDefaultType>(options?: {
         type?: TType;
-        target?: TTarget;
+        target?: Target<TSpec, TType>;
         settings?: Partial<CheckSettings<TSpec, TDefaultType> & CloseSettings<TDefaultType> & CheckSettings<TSpec, TType> & CloseSettings<TType>>;
         config?: Config<TSpec, TDefaultType> & Config<TSpec, TType>;
         logger?: Logger;

package/types/ufg/abort.d.ts

@@ -1,13 +1,13 @@
 import type { DriverTarget, AbortSettings } from './types';
+import { type Eyes as BaseEyes } from '@applitools/core-base';
 import { type Logger } from '@applitools/logger';
 import { type AbortController } from 'abort-controller';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 import { Renderer } from '@applitools/ufg-client';
-import { Eyes as baseEyes } from '@applitools/core-base';
 type Options<TSpec extends SpecType> = {
     storage: Map<string, Promise<{
         renderer: Renderer;
-        eyes: baseEyes;
+        eyes: BaseEyes;
     }>[]>;
     controller: AbortController;
     target?: DriverTarget<TSpec>;

package/types/ufg/close.d.ts

@@ -1,12 +1,12 @@
 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';
-import { Eyes as baseEyes } from '@applitools/core-base';
 type Options<TSpec extends SpecType> = {
     storage: Map<string, Promise<{
         renderer: Renderer;
-        eyes: baseEyes;
+        eyes: BaseEyes;
     }>[]>;
     target?: DriverTarget<TSpec>;
     spec?: SpecDriver<TSpec>;

package/types/ufg/core.d.ts

@@ -11,10 +11,10 @@ type Options<TSpec extends SpecType> = {
         ufg?: UFGClient;
         nml?: NMLClient;
     };
-    core?: BaseCore;
+    base?: BaseCore;
     agentId?: string;
     cwd?: string;
     logger?: Logger;
 };
-export declare function makeCore<TSpec extends SpecType>({ concurrency, spec, clients, core, agentId, cwd, logger, }: Options<TSpec>): Core<TSpec>;
+export declare function makeCore<TSpec extends SpecType>({ concurrency, spec, clients, base, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
 export {};

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

@@ -1,24 +1,20 @@
 import type { Eyes, OpenSettings } from './types';
-import type { Core as BaseCore, Eyes as EyesBase } from '@applitools/core-base';
+import type { Eyes as BaseEyes } from '@applitools/core-base';
 import { type SpecType } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
-import { type Renderer } from '@applitools/ufg-client';
-type Options = {
-    eyes: Eyes<SpecType>;
+import { type RendererSettings } from '@applitools/ufg-client';
+type Options<TSpec extends SpecType> = {
     settings: OpenSettings;
-    core: BaseCore;
-    baseEyes?: EyesBase[];
+    eyes: Eyes<TSpec>;
+    base?: BaseEyes[];
     logger: Logger;
 };
-export declare function makeGetBaseEyes({ eyes, settings: defaultSettings, core, baseEyes, logger: defaultLogger }: Options): (({ settings, logger, }?: {
-    settings?: {
-        type: 'web' | 'native';
-        renderer: Renderer;
-    } | undefined;
+export declare function makeGetBaseEyes<TSpec extends SpecType>({ settings: defaultSettings, eyes, base, logger: defaultLogger, }: Options<TSpec>): (({ settings, logger, }?: {
+    settings?: RendererSettings | 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;
+}) => Promise<BaseEyes[]>) & {
+    getCachedValues(): Promise<BaseEyes[]>[];
+    setCachedValue(key: any, value: Promise<BaseEyes[]>): void;
     clearCache(): void;
 };
 export {};

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

@@ -2,12 +2,12 @@ import { type SpecType, type Driver } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 import { type NMLClient, type NMLRequestsConfig } from '@applitools/nml-client';
 type Options = {
-    config: Omit<NMLRequestsConfig, 'brokerUrl'>;
     client?: NMLClient;
     logger: Logger;
 };
-export declare function makeGetNMLClient({ config, client, logger: defaultLogger }: Options): (({ driver, logger }: {
+export declare function makeGetNMLClient({ client, logger: defaultLogger }: Options): (({ driver, config, logger, }: {
     driver: Driver<SpecType>;
+    config: Omit<NMLRequestsConfig, 'brokerUrl'>;
     logger?: Logger | undefined;
 }) => Promise<NMLClient | null>) & {
     getCachedValues(): Promise<NMLClient | null>[];

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

@@ -1,11 +1,11 @@
 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';
-import { Eyes as baseEyes } from '@applitools/core-base';
 type Options = {
     storage: Map<string, Promise<{
         renderer: Renderer;
-        eyes: baseEyes;
+        eyes: BaseEyes;
     }>[]>;
     logger: Logger;
 };

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

@@ -1,12 +1,12 @@
 import { type Logger } from '@applitools/logger';
 import { type UFGClient, type UFGRequestsConfig } from '@applitools/ufg-client';
 type Options = {
-    config: UFGRequestsConfig;
-    concurrency: number;
     client?: UFGClient;
     logger: Logger;
 };
-export declare function makeGetUFGClient({ config, concurrency, client, logger: defaultLogger }: Options): (({ logger }?: {
+export declare function makeGetUFGClient({ client, logger: defaultLogger }: Options): (({ config, concurrency, logger, }: {
+    config: UFGRequestsConfig;
+    concurrency?: number | undefined;
     logger?: Logger | undefined;
 }) => Promise<UFGClient>) & {
     getCachedValues(): Promise<UFGClient>[];

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

@@ -1,22 +1,16 @@
-import type { DriverTarget, Eyes, OpenSettings } from './types';
-import type { Core as BaseCore, Eyes as BaseEyes } from '@applitools/core-base';
+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 UFGClient } from '@applitools/ufg-client';
-import { type NMLClient } from '@applitools/nml-client';
 import { type SpecType, type SpecDriver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
-    core: BaseCore;
-    clients?: {
-        ufg?: UFGClient;
-        nml?: NMLClient;
-    };
+    core: Core<TSpec>;
     spec?: SpecDriver<TSpec>;
     logger: Logger;
 };
-export declare function makeOpenEyes<TSpec extends SpecType>({ core, clients, spec, logger: defaultLogger }: Options<TSpec>): ({ target, settings, eyes, logger, }: {
+export declare function makeOpenEyes<TSpec extends SpecType>({ core, spec, logger: defaultLogger }: Options<TSpec>): ({ target, settings, base, logger, }: {
     target?: DriverTarget<TSpec> | undefined;
     settings: OpenSettings;
-    eyes?: BaseEyes<import("@applitools/core-base").ImageTarget>[] | undefined;
+    base?: BaseEyes[] | undefined;
     logger?: Logger | undefined;
 }) => Promise<Eyes<TSpec>>;
 export {};

package/types/ufg/types.d.ts

@@ -4,29 +4,33 @@ import type * as AutomationCore from '../automation/types';
 import { type SpecType, type Driver } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 import { type Proxy } from '@applitools/req';
-import { type UFGClient, type Renderer, type DomSnapshot, type AndroidSnapshot, type IOSSnapshot } from '@applitools/ufg-client';
-import { type NMLClient } from '@applitools/nml-client';
+import { type UFGClient, type UFGRequestsConfig, type Renderer, type DomSnapshot, type AndroidSnapshot, type IOSSnapshot } from '@applitools/ufg-client';
+import { type NMLClient, type NMLRequestsConfig } from '@applitools/nml-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, TTarget = AutomationCore.Target<TSpec>, TEyes extends Eyes<TSpec, TTarget | SnapshotTarget> = Eyes<TSpec, TTarget | SnapshotTarget>> extends AutomationCore.Core<TSpec, TTarget, TEyes> {
-    readonly type: 'ufg';
-    openEyes(options: {
-        target?: AutomationCore.DriverTarget<TSpec>;
-        settings: OpenSettings;
-        eyes?: BaseCore.Eyes[];
-        logger?: Logger;
-    }): Promise<TEyes>;
-}
-export interface Eyes<TSpec extends SpecType, TTarget = Target<TSpec>> extends AutomationCore.Eyes<TSpec, TTarget> {
+export interface Core<TSpec extends SpecType> extends AutomationCore.Core<TSpec> {
     readonly type: 'ufg';
     getUFGClient(options?: {
+        config: UFGRequestsConfig;
+        concurrency?: number;
         logger?: Logger;
     }): Promise<UFGClient>;
     getNMLClient(options: {
+        config: Omit<NMLRequestsConfig, 'brokerUrl'>;
         driver: Driver<TSpec>;
         logger?: Logger;
     }): Promise<NMLClient | null>;
+    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?: {
             type: 'web' | 'native';
@@ -35,12 +39,12 @@ export interface Eyes<TSpec extends SpecType, TTarget = Target<TSpec>> extends A
         logger?: Logger;
     }): Promise<BaseCore.Eyes[]>;
     check(options?: {
-        target?: TTarget;
+        target?: Target<TSpec>;
         settings?: CheckSettings<TSpec>;
         logger?: Logger;
     }): Promise<CheckResult[]>;
     checkAndClose(options?: {
-        target?: TTarget;
+        target?: Target<TSpec>;
         settings?: CheckSettings<TSpec> & AutomationCore.CloseSettings;
         logger?: Logger;
     }): Promise<TestResult[]>;
@@ -49,9 +53,6 @@ export interface Eyes<TSpec extends SpecType, TTarget = Target<TSpec>> extends A
         logger?: Logger;
     }): Promise<TestResult[]>;
 }
-export type OpenSettings = AutomationCore.OpenSettings & {
-    renderConcurrency?: number;
-};
 export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
     renderers?: Renderer[];
     hooks?: {

package/types/universal/core.d.ts

@@ -7,13 +7,15 @@ export declare function makeCore<TSpec extends SpecType, TType extends 'classic'
     agentId: string;
     spec: 'webdriver' | SpecDriver<TSpec>;
 }): Core<TSpec, TType>;
-export declare function makeManager<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ socket, manager, }: {
+export declare function makeManager<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ socket, core, managerRef, }: {
     socket: ClientSocket<TSpec, TType>;
-    manager: Ref<EyesManager<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, eyes, }: {
+export declare function makeEyes<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ socket, core, eyesRef, }: {
     socket: ClientSocket<TSpec, TType>;
-    eyes: Ref<Eyes<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;