@applitools/core 4.58.2 → 4.59.1-debug.0

package/dist/utils/extract-git-info.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractBranchLookupFallbackList = exports.isISODate = exports.extractBranchingTimestamp = exports.extractBuildIdFromCI = exports.extractGitRepo = exports.extractGitBranch = exports.extractLatestCommitInfo = exports.getPrimaryRemoteName = exports.cacheKey = void 0;
+exports.extractBranchLookupFallbackList = exports.isISODate = exports.extractBranchingTimestamp = exports.extractBuildIdFromCI = exports.extractCIBranchName = exports.extractGitRepo = exports.extractGitBranch = exports.extractLatestCommitInfo = exports.getPrimaryRemoteName = exports.cacheKey = void 0;
 const utils = __importStar(require("@applitools/utils"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -89,20 +89,24 @@ exports.extractLatestCommitInfo = utils.general.cachify(async function ({ execOp
     }
 }, () => exports.cacheKey);
 exports.extractGitBranch = utils.general.cachify(async function ({ execOptions, logger = (0, logger_1.makeLogger)() }) {
-    if (process.env.GITHUB_HEAD_REF) {
-        return process.env.GITHUB_HEAD_REF;
-    }
-    if (process.env.GITHUB_REF) {
-        return process.env.GITHUB_REF.split('/').splice(2).join('/');
+    // 1. Try CI environment variables first (fast, no subprocess, handles detached HEAD in CI)
+    const ciBranch = extractCIBranchName();
+    if (ciBranch) {
+        logger.log(`Extracted branch name from CI environment: "${ciBranch}"`);
+        return ciBranch;
     }
+    // 2. Fall back to git command (works when on an actual branch locally)
     const result = await executeWithLog('git branch --show-current', { execOptions, logger });
     if (result.stderr) {
         logger.log(`Error during extracting current branch from git`, result.stderr);
     }
     else {
         const branch = result.stdout.trim();
-        logger.log(`Extracted current git branch: "${branch}"`);
-        return branch;
+        if (branch) {
+            logger.log(`Extracted current git branch: "${branch}"`);
+            return branch;
+        }
+        logger.log('git branch --show-current returned empty (detached HEAD), no branch name available');
     }
 }, args => { var _a, _b, _c; return ({ cwd: (_b = (_a = args[0]) === null || _a === void 0 ? void 0 : _a.execOptions) === null || _b === void 0 ? void 0 : _b.cwd, ignoreGitBranching: (_c = args[0]) === null || _c === void 0 ? void 0 : _c.ignoreGitBranching }); });
 exports.extractGitRepo = utils.general.cachify(async function ({ execOptions, logger = (0, logger_1.makeLogger)() }) {
@@ -139,6 +143,17 @@ exports.extractGitRepo = utils.general.cachify(async function ({ execOptions, lo
         }
     }
 }, () => exports.cacheKey);
+function extractCIBranchName() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    return ((_j = (_h = (_g = (_f = (_e = (_d = (_c = (_b = (_a = (process.env.GITHUB_HEAD_REF || // github (pull requests)
+        extractGithubRefBranch() || // github (push events)
+        process.env.CI_COMMIT_REF_NAME)) !== null && _a !== void 0 ? _a : process.env.CIRCLE_BRANCH) !== null && _b !== void 0 ? _b : process.env.BRANCH_NAME) !== null && _c !== void 0 ? _c : process.env.GIT_BRANCH) !== null && _d !== void 0 ? _d : process.env.BUILD_SOURCEBRANCHNAME) !== null && _e !== void 0 ? _e : process.env.BITBUCKET_BRANCH) !== null && _f !== void 0 ? _f : process.env.TRAVIS_BRANCH) !== null && _g !== void 0 ? _g : process.env.BUILDKITE_BRANCH) !== null && _h !== void 0 ? _h : process.env.CODEBUILD_WEBHOOK_HEAD_REF) !== null && _j !== void 0 ? _j : undefined);
+}
+exports.extractCIBranchName = extractCIBranchName;
+function extractGithubRefBranch() {
+    var _a;
+    return (_a = process.env.GITHUB_REF) === null || _a === void 0 ? void 0 : _a.split('/').splice(2).join('/');
+}
 async function extractBuildIdFromCI() {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     return ((_k = (_j = (_h = (_g = (_f = (_e = (_d = (_c = (_b = (_a = process.env.GITHUB_RUN_ID) !== null && _a !== void 0 ? _a : process.env.CI_JOB_ID) !== null && _b !== void 0 ? _b : process.env.CIRCLE_BUILD_NUM) !== null && _c !== void 0 ? _c : process.env.BUILD_BUILDID) !== null && _d !== void 0 ? _d : process.env.BITBUCKET_BUILD_NUMBER) !== null && _e !== void 0 ? _e : process.env.CODEBUILD_BUILD_ID) !== null && _f !== void 0 ? _f : process.env.BUILD_ID) !== null && _g !== void 0 ? _g : process.env.BUILD_NUMBER) !== null && _h !== void 0 ? _h : process.env.TRAVIS_BUILD_ID) !== null && _j !== void 0 ? _j : process.env.BUILDKITE_BUILD_ID) !== null && _k !== void 0 ? _k : process.env.BAMBOO // TODO: Bamboo

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "4.58.2",
+  "version": "4.59.1-debug.0",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -60,19 +60,19 @@
     "setup:standalone": "sh -c 'yarn chromedriver --port=4444 --verbose &'"
   },
   "dependencies": {
-    "@applitools/core-base": "1.32.3",
-    "@applitools/dom-capture": "11.6.12",
-    "@applitools/dom-snapshot": "4.16.1",
-    "@applitools/driver": "1.25.3",
-    "@applitools/ec-client": "1.12.23",
-    "@applitools/logger": "2.2.9",
-    "@applitools/nml-client": "1.11.21",
-    "@applitools/req": "1.9.1",
-    "@applitools/screenshoter": "3.12.16",
-    "@applitools/snippets": "2.8.0",
-    "@applitools/socket": "1.3.10",
-    "@applitools/ufg-client": "1.20.0",
-    "@applitools/utils": "1.14.2",
+    "@applitools/core-base": "1.32.4",
+    "@applitools/dom-capture": "11.7.0",
+    "@applitools/dom-snapshot": "4.16.3",
+    "@applitools/driver": "1.25.4",
+    "@applitools/ec-client": "1.12.24",
+    "@applitools/logger": "2.2.10",
+    "@applitools/nml-client": "1.11.23",
+    "@applitools/req": "1.9.2",
+    "@applitools/screenshoter": "3.12.17",
+    "@applitools/snippets": "2.8.1",
+    "@applitools/socket": "1.3.11",
+    "@applitools/ufg-client": "1.20.2",
+    "@applitools/utils": "1.14.3",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
     "node-fetch": "2.6.7",
@@ -81,11 +81,11 @@
   },
   "devDependencies": {
     "@applitools/bongo": "^5.10.0",
-    "@applitools/spec-driver-puppeteer": "^1.7.3",
-    "@applitools/spec-driver-selenium": "^1.7.14",
-    "@applitools/test-server": "^1.4.1",
+    "@applitools/spec-driver-puppeteer": "^1.7.4",
+    "@applitools/spec-driver-selenium": "^1.7.15",
+    "@applitools/test-server": "^1.4.2",
     "@applitools/test-utils": "^1.5.17",
-    "@applitools/tunnel-client": "^1.11.8",
+    "@applitools/tunnel-client": "^1.11.9",
     "@types/mocha": "^10.0.7",
     "@types/node": "^12.20.55",
     "@types/selenium-webdriver": "^4.1.2",
@@ -113,5 +113,6 @@
       "selenium-webdriver>ws>bufferutil": false,
       "selenium-webdriver>ws>utf-8-validate": false
     }
-  }
+  },
+  "stableVersion": "4.59.1-debug.0"
 }

package/types/automation/types.d.ts

@@ -158,6 +158,8 @@ export interface ScreenshotSettings<TSpec extends SpecType> extends BaseCore.Ima
     sendDom?: boolean;
     captureStatusBar?: boolean;
     mobileOptions?: MobileOptions;
+    /** @internal */
+    skipRootHtmlResource?: boolean;
 }
 export type LocateSettings<TLocator extends string, TSpec extends SpecType> = BaseCore.LocateSettings<TLocator, Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;
 export type LocateTextSettings<TPattern extends string, TSpec extends SpecType> = BaseCore.LocateTextSettings<TPattern, Region | ElementReference<TSpec>> & ScreenshotSettings<TSpec>;

package/types/cli/cli.d.ts

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

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

@@ -32,6 +32,7 @@ export declare function makeCheckAndClose<TSpec extends SpecType>({ eyes, target
             domains?: string[] | undefined;
         }) | undefined;
         headers?: Record<string, string> | undefined;
+        skipRootHtmlResource?: boolean | undefined;
     } & import("@applitools/core-base").CloseSettings & {
         environments?: Environment[] | undefined;
     }) | undefined;

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

@@ -1,15 +1,14 @@
 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';
+import { type SpecType, type Driver } from '@applitools/driver';
 type Options<TSpec extends SpecType> = {
     core: Core<TSpec>;
-    spec: SpecDriver<TSpec>;
     fetchConcurrency?: number;
     signal?: AbortSignal;
     logger: Logger;
 };
-export declare function makeTakeSnapshots<TSpec extends SpecType>({ core, spec, fetchConcurrency, signal, logger: mainLogger, }: Options<TSpec>): ({ driver, settings, account, logger, }: {
+export declare function makeTakeSnapshots<TSpec extends SpecType>({ core, fetchConcurrency, signal, logger: mainLogger, }: Options<TSpec>): ({ driver, settings, account, logger, }: {
     driver: Driver<TSpec>;
     settings?: SnapshotSettings<TSpec> | undefined;
     account: Account;

package/types/ufg/types.d.ts

@@ -67,6 +67,8 @@ export type SnapshotSettings<TSpec extends SpecType> = AutomationCore.CheckSetti
         domains?: string[];
     };
     headers?: Record<string, string>;
+    /** @internal */
+    skipRootHtmlResource?: boolean;
 };
 export type CheckSettings<TSpec extends SpecType> = SnapshotSettings<TSpec>;
 export type SafeCheckSettings = CheckSettings<SpecType<never, never, UFGSelector, never, never>>;

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

@@ -31,6 +31,8 @@ export type RawDomSnapshot = {
 export type DomSnapshotSettings<TSpec extends SpecType> = {
     disableBrowserFetching?: boolean;
     skipResources?: string[];
+    /** @internal */
+    skipRootHtmlResource?: boolean;
     fetchConcurrency?: number;
     chunkByteLength?: number;
     executionTimeout?: number;

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

@@ -1,13 +1,12 @@
 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, logDeprecations, }: {
+export declare function toGeneratedSelectors<TSpec extends SpecType>({ elementReferences, logger, logDeprecations, }: {
     elementReferences: {
         target?: ElementReference<TSpec>;
         scrolling?: ElementReference<TSpec>;
         calculate?: ElementReference<TSpec>[];
     };
-    transformElementReference: (elementReference: ElementReference<TSpec>) => UFGSelector | undefined;
     logger: Logger;
     logDeprecations: (...args: string[]) => void;
 }): {

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

@@ -0,0 +1,9 @@
+/// <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

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

package/types/universal/history.d.ts

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

package/types/universal/refer.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,15 @@
+import type { Ref, ServerSocket, UniversalSpecDriver } from './types';
+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 UserFunction = Ref;
+export type PrimarySpecType = SpecType<Driver, Context, Element, Selector, never, UserFunction>;
+export type SpecDriver = BaseSpecDriver<PrimarySpecType>;
+type CommandName = keyof UniversalSpecDriver<PrimarySpecType>;
+export declare function makeSpec({ socket, spec, }: {
+    socket: ServerSocket<PrimarySpecType, any>;
+    spec: CommandName[];
+}): SpecDriver;
+export {};

package/types/universal/types.d.ts

@@ -0,0 +1,205 @@
+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: {
+        spec: 'webdriver' | (keyof UniversalSpecDriver<TSpec>)[];
+        agentId: string;
+        environment?: Record<string, any>;
+        cwd: string;
+    }): 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>;
+    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>;
+    getElementRegion(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<Region>;
+    getElementAttribute(options: {
+        context: T['context'];
+        element: T['element'];
+        attr: string;
+    }): Promise<string>;
+    setElementText(options: {
+        context: T['context'];
+        element: T['element'];
+        text: string;
+    }): Promise<void>;
+    getElementText(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<string>;
+    hover(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<void>;
+    click(options: {
+        context: T['context'];
+        element: T['element'];
+    }): Promise<void>;
+    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']>;
+    getDriverInfo(options: {
+        driver: T['driver'];
+    }): Promise<DriverInfo>;
+    getCapabilities(options: {
+        driver: T['driver'];
+    }): Promise<Record<string, any>>;
+    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>;
+    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;
+        };
+    }>;
+    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>;
+    getCookies(options: {
+        driver: T['driver'] | T['context'];
+        context?: boolean;
+    }): Promise<Cookie[]>;
+    getTitle(options: {
+        driver: T['driver'];
+    }): Promise<string>;
+    getUrl(options: {
+        driver: T['driver'];
+    }): Promise<string>;
+    takeScreenshot(options: {
+        driver: T['driver'];
+    }): Promise<string>;
+    performAction(options: {
+        driver: T['driver'];
+        steps: any[];
+    }): Promise<void>;
+    visit(options: {
+        driver: T['driver'];
+        url: string;
+    }): 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>;
+    reload(options: {
+        driver: T['driver'];
+    }): Promise<void>;
+    isUserFunction(ref: any): Promise<boolean>;
+    executeUserFunction(userFunction: Ref): Promise<any>;
+    executeBrowserCommands(options: {
+        driver?: T['driver'];
+        commands: any[];
+    }): Promise<any>;
+    bringToFront(options: {
+        driver: T['driver'];
+    }): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Server as WsServer } from 'ws';
+import { Logger } from '@applitools/logger';
+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 | undefined, logger: Logger): Promise<{
+    server?: WsServer;
+    port: number;
+}>;

package/types/utils/extract-git-info.d.ts

@@ -66,6 +66,7 @@ export declare const extractGitRepo: (({ execOptions, logger }: Options) => Prom
     clearCache(): void;
     TTL?: number | undefined;
 };
+export declare function extractCIBranchName(): string | undefined;
 export declare function extractBuildIdFromCI(): Promise<string | undefined>;
 export declare const extractBranchingTimestamp: (({ branchName, parentBranchName, execOptions, logger, }: ExtractGitBranchingTimestampOptions) => Promise<string | undefined>) & {
     getCachedValues(): Promise<string | undefined>[];