@applitools/core 2.5.2 → 2.5.3-legacy

package/types/ufg/core.d.ts

@@ -1,9 +1,9 @@
 import type { Core } from './types';
-import type { Core as BaseCore } from '@applitools/core-base';
-import { type UFGClient } from '@applitools/ufg-client';
+import { type AsyncCache, 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';
+import { type Core as BaseCore } from '@applitools/core-base';
 type Options<TSpec extends SpecType> = {
     spec?: SpecDriver<TSpec>;
     clients?: {
@@ -11,10 +11,13 @@ type Options<TSpec extends SpecType> = {
         nml?: NMLClient;
     };
     base?: BaseCore;
-    agentId?: string;
+    asyncCache?: AsyncCache;
     concurrency?: number;
-    cwd?: string;
+    fetchConcurrency?: number;
+    agentId?: string;
     logger?: Logger;
+    offlineLocationPath?: string;
+    maskLog?: boolean;
 };
-export declare function makeCore<TSpec extends SpecType>({ concurrency, spec, clients, base, agentId, cwd, logger: defaultLogger, }: Options<TSpec>): Core<TSpec>;
+export declare function makeCore<TSpec extends SpecType>({ spec, clients, base: defaultBase, asyncCache, concurrency, offlineLocationPath, fetchConcurrency, agentId, logger: defaultLogger, maskLog, }: Options<TSpec>): Core<TSpec>;
 export {};

package/types/ufg/create-render-target-from-snapshot.d.ts

@@ -0,0 +1,8 @@
+import { UFGClient, RenderTarget } from '@applitools/ufg-client';
+import { Snapshot } from './types';
+import { Logger } from '@applitools/logger';
+export declare function createRenderTargetFromSnapshot({ ufgClient, snapshot, logger, }: {
+    ufgClient: UFGClient;
+    snapshot: Snapshot;
+    logger: Logger;
+}): Promise<RenderTarget>;

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

@@ -1,20 +1,15 @@
-import type { Eyes, OpenSettings } from './types';
+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';
-import { type RendererSettings } from '@applitools/ufg-client';
 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: defaultLogger, }: Options<TSpec>): (({ settings, logger, }?: {
-    settings?: RendererSettings | undefined;
+export declare function makeGetBaseEyes<TSpec extends SpecType>({ settings: defaultSettings, eyes, logger: mainLogger, }: Options<TSpec>): ({ settings, logger, }: {
+    settings: GetBaseEyesSettings<TSpec>;
     logger?: Logger | undefined;
-}) => Promise<BaseEyes[]>) & {
-    getCachedValues(): Promise<BaseEyes[]>[];
-    setCachedValue(key: any, value: Promise<BaseEyes[]>): void;
-    clearCache(): void;
-};
+}) => Promise<BaseEyes>;
 export {};

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

@@ -1,11 +1,14 @@
 import { type Logger } from '@applitools/logger';
-import { type UFGClient, type UFGRequestsConfig } from '@applitools/ufg-client';
+import { type AsyncCache, type UFGClient, type UFGClientSettings } from '@applitools/ufg-client';
 type Options = {
     client?: UFGClient;
+    fetchConcurrency?: number;
     logger: Logger;
+    asyncCache?: AsyncCache;
+    offlineLocationPath?: string;
 };
-export declare function makeGetUFGClient({ client, logger: defaultLogger }: Options): (({ config, logger }: {
-    config: UFGRequestsConfig;
+export declare function makeGetUFGClient({ client, fetchConcurrency, offlineLocationPath, logger: mainLogger, asyncCache, }: Options): (({ settings, logger }: {
+    settings: UFGClientSettings;
     logger?: Logger | undefined;
 }) => Promise<UFGClient>) & {
     getCachedValues(): Promise<UFGClient>[];

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

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

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

@@ -0,0 +1,17 @@
+import type { Core, SnapshotSettings, Account, Snapshot } from './types';
+import { type AbortSignal } from 'abort-controller';
+import { type Logger } from '@applitools/logger';
+import { type SpecType, type SpecDriver, type Driver } from '@applitools/driver';
+type Options<TSpec extends SpecType> = {
+    core: Core<TSpec>;
+    spec: SpecDriver<TSpec>;
+    signal?: AbortSignal;
+    logger: Logger;
+};
+export declare function makeTakeSnapshots<TSpec extends SpecType>({ core, spec, signal, logger: mainLogger }: Options<TSpec>): ({ driver, settings, account, logger, }: {
+    driver: Driver<TSpec>;
+    settings?: SnapshotSettings<TSpec> | undefined;
+    account: Account;
+    logger?: Logger | undefined;
+}) => Promise<Snapshot[]>;
+export {};

package/types/ufg/types.d.ts

@@ -1,80 +1,80 @@
 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, type Driver } from '@applitools/driver';
+import { type SpecType, type CommonSelector, type Driver } from '@applitools/driver';
 import { type Logger } from '@applitools/logger';
 import { type Proxy } from '@applitools/req';
-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';
+import { type UFGClient, type UFGClientSettings, type Selector as UFGSelector, type Environment as UFGEnvironment, type DomSnapshot as UFGDomSnapshot, type AndroidSnapshot as UFGAndroidSnapshot, type IOSSnapshot as UFGIOSSnapshot } from '@applitools/ufg-client';
 export * from '../automation/types';
-export type SnapshotTarget = MaybeArray<DomSnapshot> | MaybeArray<AndroidSnapshot> | MaybeArray<IOSSnapshot>;
+export type DomSnapshot = UFGDomSnapshot & {
+    generatedSelectors?: {
+        originalSelector: CommonSelector | null;
+        safeSelector: CommonSelector | {
+            error: string;
+        } | null;
+    }[];
+};
+export type AndroidSnapshot = UFGAndroidSnapshot;
+export type IOSSnapshot = UFGIOSSnapshot;
+export type SnapshotTarget = MaybeArray<Snapshot>;
 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?: {
-        config: UFGRequestsConfig;
-        concurrency?: number;
+        settings: UFGClientSettings;
         logger?: Logger;
     }): Promise<UFGClient>;
-    getNMLClient(options: {
-        config: Omit<NMLRequestsConfig, 'brokerUrl'>;
+    takeSnapshots?(options: {
         driver: Driver<TSpec>;
+        settings?: SnapshotSettings<TSpec>;
+        account: AutomationCore.Account;
         logger?: Logger;
-    }): Promise<NMLClient | null>;
+    }): Promise<Snapshot[]>;
     openEyes(options: {
         target?: AutomationCore.DriverTarget<TSpec>;
         settings: AutomationCore.OpenSettings;
-        base?: BaseCore.Eyes[];
+        storage?: AutomationCore.EyesStorage;
         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';
-            renderer: Renderer;
-        };
-        logger?: Logger;
-    }): Promise<BaseCore.Eyes[]>;
     check(options?: {
         target?: Target<TSpec>;
         settings?: CheckSettings<TSpec>;
         logger?: Logger;
-    }): Promise<CheckResult[]>;
+    }): Promise<void>;
     checkAndClose(options?: {
         target?: Target<TSpec>;
         settings?: CheckSettings<TSpec> & AutomationCore.CloseSettings;
         logger?: Logger;
-    }): Promise<TestResult[]>;
-    getResults(options?: {
-        settings?: AutomationCore.GetResultsSettings;
-        logger?: Logger;
-    }): Promise<TestResult[]>;
+    }): Promise<void>;
 }
-export type CheckSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
-    renderers?: Renderer[];
+export type SnapshotSettings<TSpec extends SpecType> = AutomationCore.CheckSettings<TSpec> & {
+    disableBrowserFetching?: boolean;
+    layoutBreakpoints?: {
+        breakpoints: number[] | boolean;
+        reload?: boolean;
+    };
     hooks?: {
         beforeCaptureScreenshot: string;
     };
-    disableBrowserFetching?: boolean;
-    layoutBreakpoints?: boolean | number[];
     ufgOptions?: Record<string, any>;
-    nmgOptions?: Record<string, any>;
+    prefixRenderId?: string;
     autProxy?: Proxy & {
         mode?: 'Allow' | 'Block';
         domains?: string[];
     };
+    headers?: Record<string, string>;
 };
-export type CheckResult = AutomationCore.CheckResult & {
-    readonly renderer: Renderer;
-    readonly promise: Promise<Omit<CheckResult, 'promise'> & {
-        eyes: BaseCore.Eyes;
-    }>;
-};
-export type TestResult = AutomationCore.TestResult & {
-    readonly renderer: Renderer;
-} & {
-    eyes: BaseCore.Eyes;
+export type CheckSettings<TSpec extends SpecType> = SnapshotSettings<TSpec>;
+export type SafeCheckSettings = CheckSettings<SpecType<never, never, UFGSelector, never, never>>;
+export type Snapshot = {
+    target: DomSnapshot | AndroidSnapshot | IOSSnapshot;
+    settings: SafeCheckSettings;
+    environment: UFGEnvironment;
+    account: AutomationCore.Account;
+    url: string;
+    title: string;
+    userAgent?: string;
 };

package/types/ufg/utils/extract-default-environment.d.ts

@@ -0,0 +1,5 @@
+import type { Environment } from '../types';
+import { type SpecType, type Driver } from '@applitools/driver';
+export declare function extractDefaultEnvironments<TSpec extends SpecType>({ driver, }: {
+    driver?: Driver<TSpec>;
+}): Promise<Environment[]>;

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

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

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

@@ -1,16 +1,16 @@
+import { type DomSnapshot } from '../types';
 import { type Logger } from '@applitools/logger';
-import { type SpecType, type Context } from '@applitools/driver';
-import { type DomSnapshot } from '@applitools/ufg-client';
-type RawDomSnapshot = {
+import { type SpecType, type Context, type Cookie, type ElementReference, type CommonSelector } from '@applitools/driver';
+export type RawDomSnapshot = {
     url: string;
-    selector: string;
+    selector?: string;
     cdt: {
         attributes: {
             name: string;
             value: string;
         }[];
     }[];
-    crossFrames: {
+    crossFrames?: {
         selector: string;
         index: number;
     }[];
@@ -18,32 +18,27 @@ type RawDomSnapshot = {
     resourceUrls: string[];
     blobs: {
         url: string;
-        value: string;
+        value?: string;
     }[];
+    srcAttr: string | null;
+    scriptVersion: string;
+    safeSelectors?: (CommonSelector | {
+        error: string;
+    } | null)[];
+    warnings?: string[];
 };
-export type DomSnapshotSettings = {
+export type DomSnapshotSettings<TSpec extends SpecType> = {
     disableBrowserFetching?: boolean;
     skipResources?: string[];
     chunkByteLength?: number;
     executionTimeout?: number;
     pollTimeout?: number;
     showLogs?: boolean;
+    cookies?: Cookie[];
+    elementReferences?: ElementReference<TSpec>[];
 };
 export declare function takeDomSnapshot<TSpec extends SpecType>({ context, settings, logger, }: {
     context: Context<TSpec>;
-    settings?: DomSnapshotSettings;
+    settings?: DomSnapshotSettings<TSpec>;
     logger: Logger;
 }): Promise<DomSnapshot>;
-export declare function deserializeDomSnapshot({ snapshot }: {
-    snapshot: RawDomSnapshot;
-}): DomSnapshot;
-export declare function extractCrossFrames({ snapshot, parent, logger, }: {
-    snapshot: RawDomSnapshot;
-    parent?: any;
-    logger: Logger;
-}): {
-    cdtNode: RawDomSnapshot['cdt'][number];
-    reference: any;
-    parentSnapshot: RawDomSnapshot;
-}[];
-export {};

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

@@ -1,24 +1,28 @@
-import type { Size } from '@applitools/utils';
+import type { DomSnapshot, LazyLoadOptions } from '../types';
+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 Environment } 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?: number[] | boolean;
+export type DomSnapshotsSettings<TSpec extends SpecType> = DomSnapshotSettings<TSpec> & {
+    environments: Environment[];
+    waitBeforeCapture?: number | (() => Promise<void>);
+    layoutBreakpoints?: {
+        breakpoints: number[] | boolean;
+        reload?: boolean;
+    };
+    lazyLoad?: boolean | LazyLoadOptions;
 };
 export declare function takeDomSnapshots<TSpec extends SpecType>({ driver, settings, hooks, provides, logger, }: {
     driver: Driver<TSpec>;
-    settings: DomSnapshotsSettings;
+    settings: DomSnapshotsSettings<TSpec>;
     hooks?: {
-        beforeSnapshots?(): void | Promise<void>;
         beforeEachSnapshot?(): void | Promise<void>;
     };
     provides?: {
-        getChromeEmulationDevices(): Promise<Record<ChromeEmulationDevice, Record<ScreenOrientation, Size>>>;
-        getIOSDevices(): Promise<Record<IOSDevice, Record<ScreenOrientation, Size>>>;
+        getChromeEmulationDevices(): Promise<Record<string, Record<string, Size>>>;
+        getIOSDevices(): Promise<Record<string, Record<string, Size>>>;
     };
     logger: Logger;
 }): Promise<DomSnapshot[]>;

package/types/ufg/utils/to-generated-selectors.d.ts

@@ -0,0 +1,34 @@
+import { type SpecType, type ElementReference } from '@applitools/driver';
+import type { Logger } from '@applitools/logger';
+import { type Selector as UFGSelector } from '@applitools/ufg-client';
+export declare function toGeneratedSelectors<TSpec extends SpecType>({ elementReferences, logger, transformElementReference, }: {
+    elementReferences: {
+        target?: ElementReference<TSpec>;
+        scrolling?: ElementReference<TSpec>;
+        calculate?: ElementReference<TSpec>[];
+    };
+    transformElementReference: (elementReference: ElementReference<TSpec>) => UFGSelector | undefined;
+    logger: Logger;
+}): {
+    elementReferencesToMark: (string | TSpec["element"] | TSpec["secondary"]["element"] | TSpec["selector"] | TSpec["secondary"]["selector"] | {
+        selector: string | TSpec["selector"] | TSpec["secondary"]["selector"];
+        type?: string | undefined;
+        child?: TSpec["selector"] | TSpec["secondary"]["selector"] | import("@applitools/driver").CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
+        shadow?: TSpec["selector"] | TSpec["secondary"]["selector"] | import("@applitools/driver").CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
+        frame?: TSpec["selector"] | TSpec["secondary"]["selector"] | import("@applitools/driver").CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
+        fallback?: TSpec["selector"] | TSpec["secondary"]["selector"] | import("@applitools/driver").CommonSelector<TSpec["selector"] | TSpec["secondary"]["selector"]> | undefined;
+    } | (NonNullable<TSpec["element"]> extends infer T ? T extends NonNullable<TSpec["element"]> ? T extends readonly (infer InnerArr)[] ? InnerArr : T : never : never) | (NonNullable<TSpec["secondary"]["element"]> extends infer T_1 ? T_1 extends NonNullable<TSpec["secondary"]["element"]> ? T_1 extends readonly (infer InnerArr)[] ? InnerArr : T_1 : never : never) | (NonNullable<TSpec["selector"]> extends infer T_2 ? T_2 extends NonNullable<TSpec["selector"]> ? T_2 extends readonly (infer InnerArr)[] ? InnerArr : T_2 : never : never) | (NonNullable<TSpec["secondary"]["selector"]> extends infer T_3 ? T_3 extends NonNullable<TSpec["secondary"]["selector"]> ? T_3 extends readonly (infer InnerArr)[] ? InnerArr : T_3 : never : never))[];
+    getGeneratedSelectors: (generatedSelectors?: {
+        originalSelector: UFGSelector | null;
+        safeSelector: UFGSelector | {
+            error: string;
+        } | null;
+    }[]) => {
+        target: UFGSelector | undefined;
+        scrolling: UFGSelector | undefined;
+        calculate: {
+            originalSelector: UFGSelector | null;
+            safeSelector: UFGSelector | null;
+        }[];
+    };
+};

package/types/ufg/utils/to-safe-check-settings.d.ts

@@ -0,0 +1,22 @@
+import type { CheckSettings, SafeCheckSettings } from '../types';
+import { type SpecType, type ElementReference, type CommonSelector } from '@applitools/driver';
+import { type Selector as UFGSelector } from '@applitools/ufg-client';
+export declare function toSafeCheckSettings<TSpec extends SpecType>({ settings }: {
+    settings: CheckSettings<TSpec>;
+}): {
+    elementReferences: {
+        target: ElementReference<TSpec> | undefined;
+        scrolling: ElementReference<TSpec> | undefined;
+        calculate: ElementReference<TSpec>[];
+    };
+    getSafeCheckSettings: ({ selectors, }: {
+        selectors: {
+            target: UFGSelector | undefined;
+            scrolling: UFGSelector | undefined;
+            calculate: {
+                originalSelector: CommonSelector | null;
+                safeSelector: UFGSelector | null;
+            }[];
+        };
+    }) => SafeCheckSettings;
+};

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

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

package/types/universal/core.d.ts

@@ -4,8 +4,10 @@ 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>;
+    environment?: Record<string, any>;
+    agentId: string;
+    maskLog?: boolean;
 }): Core<TSpec, TType>;
 export declare function makeManager<TSpec extends SpecType, TType extends 'classic' | 'ufg'>({ socket, core, managerRef, }: {
     socket: ClientSocket<TSpec, TType>;
@@ -17,7 +19,9 @@ export declare function makeEyes<TSpec extends SpecType, TType extends 'classic'
     core: Core<TSpec, TType>;
     eyesRef: Ref<Eyes<TSpec, TType>>;
 }): Eyes<TSpec, TType>;
-export declare function makeClientSocket<TSpec extends SpecType>({ agentId, spec, }: {
+export declare function makeClientSocket<TSpec extends SpecType>({ agentId, environment, spec, maskLog, }: {
     agentId: string;
+    environment?: Record<string, any>;
     spec: 'webdriver' | SpecDriver<TSpec>;
+    maskLog?: boolean;
 }): Promise<ClientSocket<TSpec, 'classic' | 'ufg'> & Socket<WebSocket>>;

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

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