@mablhq/playwright-tools 2.49.1

package/http/axiosProxyConfig.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyUrlToPortConfig = exports.axiosProxyConfig = exports.currentProxyConfig = exports.setTestExecutionProxyUrl = void 0;
+const cliConfigProvider_1 = require("../providers/cliConfigProvider");
+const hpagent_1 = require("hpagent");
+const httpUtil_1 = require("./httpUtil");
+const https_1 = require("https");
+let testExecutionProxyUrl;
+function setTestExecutionProxyUrl(url) {
+    testExecutionProxyUrl = url;
+}
+exports.setTestExecutionProxyUrl = setTestExecutionProxyUrl;
+async function currentProxyConfig(mode = 'mabl') {
+    const httpConfig = (await cliConfigProvider_1.CliConfigProvider.getCliConfig()).http;
+    return axiosProxyConfig(mode === 'test' ? httpConfig === null || httpConfig === void 0 ? void 0 : httpConfig.test : httpConfig === null || httpConfig === void 0 ? void 0 : httpConfig.mabl);
+}
+exports.currentProxyConfig = currentProxyConfig;
+function axiosProxyConfig(httpConfig) {
+    var _a;
+    const config = {
+        headers: {
+            [httpUtil_1.USER_AGENT_HEADER]: httpUtil_1.USER_AGENT,
+        },
+    };
+    let { proxyType, sslVerify } = httpConfig;
+    if (testExecutionProxyUrl) {
+        sslVerify = false;
+        proxyType = 'current';
+    }
+    if (!sslVerify) {
+        config.httpsAgent = new https_1.Agent({
+            rejectUnauthorized: false,
+        });
+    }
+    if (testExecutionProxyUrl || ((_a = httpConfig.proxyHost) === null || _a === void 0 ? void 0 : _a.href)) {
+        config.proxy = proxyUrlToPortConfig((testExecutionProxyUrl !== null && testExecutionProxyUrl !== void 0 ? testExecutionProxyUrl : httpConfig.proxyHost));
+    }
+    return maybeGetModifiedAxiosConfigForHttpProxy(config, sslVerify, proxyType);
+}
+exports.axiosProxyConfig = axiosProxyConfig;
+function escapeRegexDots(input) {
+    return input.replace('.', '\\.');
+}
+function proxyUrlToPortConfig(proxyUrl) {
+    const defaultPort = proxyUrl.protocol === 'https:' ? 443 : 80;
+    const maybePortNumberMatch = proxyUrl.port;
+    const portNumber = maybePortNumberMatch
+        ? parseInt(maybePortNumberMatch)
+        : defaultPort;
+    let hostname = proxyUrl.hostname +
+        (proxyUrl.search ? proxyUrl.pathname + proxyUrl.search : proxyUrl.pathname);
+    hostname = hostname.replace(new RegExp(`${escapeRegexDots(proxyUrl.hostname)}/$`), proxyUrl.hostname);
+    const config = {
+        host: hostname,
+        port: portNumber,
+        protocol: proxyUrl.protocol,
+    };
+    if (proxyUrl.username || proxyUrl.password) {
+        config.auth = {
+            username: proxyUrl.username,
+            password: proxyUrl.password,
+        };
+    }
+    return config;
+}
+exports.proxyUrlToPortConfig = proxyUrlToPortConfig;
+function maybeGetModifiedAxiosConfigForHttpProxy(config, sslVerify, _proxyType) {
+    var _a, _b;
+    if (config.proxy &&
+        (((_a = config.proxy) === null || _a === void 0 ? void 0 : _a.protocol) === 'http:' || ((_b = config.proxy) === null || _b === void 0 ? void 0 : _b.protocol) === 'http')) {
+        const newConfig = {
+            ...config,
+        };
+        newConfig.proxy = false;
+        const authConfig = config.proxy.auth;
+        let proxyString = 'http://';
+        if (authConfig) {
+            proxyString += `${authConfig.username}:${authConfig.password}@`;
+        }
+        proxyString += `${config.proxy.host}:${config.proxy.port}`;
+        const rejectUnauthorized = sslVerify === true;
+        const httpAgentConfig = {
+            keepAlive: true,
+            keepAliveMsecs: 1000,
+            maxSockets: 256,
+            maxFreeSockets: 256,
+            proxy: proxyString,
+            proxyRequestOptions: {
+                rejectUnauthorized,
+            },
+        };
+        const httpsAgentConfig = {
+            ...httpAgentConfig,
+            rejectUnauthorized,
+        };
+        newConfig.httpsAgent = new hpagent_1.HttpsProxyAgent(httpsAgentConfig);
+        newConfig.httpAgent = new hpagent_1.HttpProxyAgent(httpAgentConfig);
+        return newConfig;
+    }
+    return config;
+}

package/http/httpUtil.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postProcessHeaders = exports.getHttpAgent = exports.GENERAL_API_STEP_EXECUTION_ERROR_CODE = exports.EXECUTION_ENGINE_SSL_VERIFY = exports.USER_AGENT_HEADER = exports.USER_AGENT = void 0;
+const agent_base_1 = require("agent-base");
+const socks_proxy_agent_1 = require("socks-proxy-agent");
+const pureUtil_1 = require("../util/pureUtil");
+const MablHttpAgent_1 = require("./MablHttpAgent");
+const RequestFilteringHttpAgent_1 = require("./RequestFilteringHttpAgent");
+exports.USER_AGENT = `${(0, pureUtil_1.getCliName)()}@${(0, pureUtil_1.getCliVersion)()}`;
+exports.USER_AGENT_HEADER = 'User-Agent';
+exports.EXECUTION_ENGINE_SSL_VERIFY = false;
+exports.GENERAL_API_STEP_EXECUTION_ERROR_CODE = '-1';
+function getHttpAgent(shouldFilterHttpRequests, linkServers, proxyConfig) {
+    const linkAgent = maybeGetSocksAgent(linkServers);
+    if (linkAgent) {
+        return MablHttpAgent_1.MablHttpAgent.createNewInstance({
+            httpAgent: linkAgent,
+            httpsAgent: linkAgent,
+        });
+    }
+    else if (shouldFilterHttpRequests) {
+        return RequestFilteringHttpAgent_1.RequestFilteringHttpAgent.createNewInstance();
+    }
+    return MablHttpAgent_1.MablHttpAgent.createNewInstance({ proxyConfig });
+}
+exports.getHttpAgent = getHttpAgent;
+function maybeGetSocksAgent(linkServers) {
+    if (!(linkServers === null || linkServers === void 0 ? void 0 : linkServers.length)) {
+        return;
+    }
+    const agentOptions = linkServers.map((linkServer) => ({
+        host: linkServer.forwarding_host,
+        port: linkServer.forwarding_port,
+        userId: linkServer.workspace_id,
+        password: linkServer.label,
+        tls: {
+            rejectUnauthorized: false,
+        },
+    }));
+    if (agentOptions.length === 1) {
+        return new socks_proxy_agent_1.SocksProxyAgent(agentOptions[0]);
+    }
+    return new MultiSocksProxyAgent(agentOptions);
+}
+class MultiSocksProxyAgent extends agent_base_1.Agent {
+    constructor(options) {
+        super();
+        this.agents = options.map((proxy) => new socks_proxy_agent_1.SocksProxyAgent(proxy));
+    }
+    async callback(req, opts) {
+        return this.selectAgent().callback(req, opts);
+    }
+    selectAgent() {
+        return this.agents[Math.floor(Math.random() * this.agents.length)];
+    }
+    destroy() {
+        this.agents.forEach((agent) => agent.destroy());
+    }
+}
+function postProcessHeaders(response) {
+    var _a, _b, _c;
+    const parsed = {};
+    const rawHeaders = (_b = (_a = response.request) === null || _a === void 0 ? void 0 : _a.res) === null || _b === void 0 ? void 0 : _b.rawHeaders;
+    if (rawHeaders) {
+        for (let i = 0; i + 1 < rawHeaders.length; i += 2) {
+            const headerName = rawHeaders[i].toLowerCase();
+            const headerValue = rawHeaders[i + 1];
+            parsed[headerName] = ((_c = parsed[headerName]) !== null && _c !== void 0 ? _c : []).concat(headerValue);
+        }
+    }
+    return parsed;
+}
+exports.postProcessHeaders = postProcessHeaders;

package/http/requestInterceptor.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestInterceptor = exports.headerStringToProtocol = exports.headerStringToHeaders = exports.MAX_SERIALIZED_BODY_SIZE_BYTES = void 0;
+const axios_1 = __importDefault(require("axios"));
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const uuid_1 = require("uuid");
+const httpUtil_1 = require("./httpUtil");
+const pureUtil_1 = require("../util/pureUtil");
+exports.MAX_SERIALIZED_BODY_SIZE_BYTES = 1024 * 1024;
+const HEADER_EXTRACT_REGEXP = /^(?<rawKey>[^:]+)(:)(?<value>.*)$/;
+function headerStringToHeaders(rawHeader) {
+    const headers = {};
+    if (!rawHeader) {
+        return headers;
+    }
+    rawHeader
+        .split(/\r?\n/)
+        .filter((value) => value !== '')
+        .filter((value) => HEADER_EXTRACT_REGEXP.test(value))
+        .map((value) => value.match(HEADER_EXTRACT_REGEXP).groups)
+        .forEach(({ rawKey, value }) => {
+        var _a;
+        const normalizedHeader = rawKey.toLowerCase().trim();
+        const values = (_a = headers[normalizedHeader]) !== null && _a !== void 0 ? _a : [];
+        if (value === null || value === void 0 ? void 0 : value.trim()) {
+            values.push(value.trim());
+        }
+        headers[normalizedHeader] = values;
+    });
+    return headers;
+}
+exports.headerStringToHeaders = headerStringToHeaders;
+function headerStringToProtocol(rawHeader) {
+    var _a, _b, _c;
+    if (!rawHeader) {
+        return;
+    }
+    const firstRowTrimmed = (_b = (_a = rawHeader.split(/\r?\n/, 2)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.trim();
+    return (_c = firstRowTrimmed === null || firstRowTrimmed === void 0 ? void 0 : firstRowTrimmed.match(/\s(\S+)$/)) === null || _c === void 0 ? void 0 : _c[1];
+}
+exports.headerStringToProtocol = headerStringToProtocol;
+function headerRecordToHeaderMultiMap(input) {
+    const result = {};
+    Object.entries(input).forEach(([key, value]) => {
+        result[key] = [value];
+    });
+    return result;
+}
+function handleRawResponseBody(body) {
+    body = body !== null && body !== void 0 ? body : '';
+    switch (typeof body) {
+        case 'number':
+            return { body: body.toString(), responseSize: 8 };
+        case 'boolean':
+            return { body: body.toString(), responseSize: 4 };
+        case 'string':
+            return {
+                body: body.substring(0, exports.MAX_SERIALIZED_BODY_SIZE_BYTES),
+                responseSize: body.length,
+            };
+        case 'object':
+            const serializedBody = JSON.stringify(body);
+            if (serializedBody.length <= exports.MAX_SERIALIZED_BODY_SIZE_BYTES) {
+                return { body, responseSize: serializedBody.length };
+            }
+            return {
+                body: serializedBody.substring(0, exports.MAX_SERIALIZED_BODY_SIZE_BYTES),
+                responseSize: serializedBody.length,
+            };
+        default:
+            throw new Error(`Unhandled request intercept body type: [${typeof body}]`);
+    }
+}
+function getContentLength(headers) {
+    const contentLengthAsString = (0, pureUtil_1.getCaseInsensitiveProperty)(headers, 'content-length');
+    return contentLengthAsString ? Number(contentLengthAsString) : undefined;
+}
+class RequestInterceptor {
+    constructor() {
+        this.interceptedRequests = [];
+        this.handleRequest = this.handleRequest.bind(this);
+        this.handleResponse = this.handleResponse.bind(this);
+        this.handleError = this.handleError.bind(this);
+    }
+    get interceptedRequestBuffer() {
+        return [...this.interceptedRequests];
+    }
+    clearInterceptBuffer() {
+        this.interceptedRequests = [];
+    }
+    registerInterceptors(axiosInstance) {
+        this.requestInterceptorId = axiosInstance.interceptors.request.use(this.handleRequest, this.handleError);
+        this.responseInterceptorId = axios_1.default.interceptors.response.use(this.handleResponse, this.handleError);
+    }
+    ejectInterceptors(axiosInstance) {
+        try {
+            if (this.requestInterceptorId !== undefined) {
+                axiosInstance.interceptors.request.eject(this.requestInterceptorId);
+            }
+        }
+        catch (e) {
+            loggingProvider_1.logger.warn(`Unable to eject request interceptor ${this.requestInterceptorId}`);
+        }
+        try {
+            if (this.responseInterceptorId !== undefined) {
+                axiosInstance.interceptors.response.eject(this.responseInterceptorId);
+            }
+        }
+        catch (e) {
+            loggingProvider_1.logger.warn(`Unable to eject request interceptor ${this.responseInterceptorId}`);
+        }
+    }
+    handleRequest(config) {
+        var _a, _b, _c;
+        try {
+            const requestId = (0, uuid_1.v4)();
+            config.mablRequestId = requestId;
+            const requestResponseChain = {
+                requestId,
+                request: {
+                    headers: (_a = config.headers) !== null && _a !== void 0 ? _a : {},
+                    url: (_b = config === null || config === void 0 ? void 0 : config.url) !== null && _b !== void 0 ? _b : '<Unknown URL>',
+                    method: (_c = config.method) === null || _c === void 0 ? void 0 : _c.toUpperCase(),
+                    request_sent_time: Date.now(),
+                },
+            };
+            if (typeof config.data === 'string') {
+                requestResponseChain.request.body = config.data.substring(0, exports.MAX_SERIALIZED_BODY_SIZE_BYTES);
+            }
+            this.interceptedRequests.push(requestResponseChain);
+        }
+        catch (e) {
+            loggingProvider_1.logger.warn('Error in the response interceptor', e);
+        }
+        return config;
+    }
+    handleResponse(response) {
+        try {
+            const responseReceivedTime = Date.now();
+            const chainEntry = this.getOrCreateEntry(response.config);
+            const request = response.request;
+            if (request) {
+                chainEntry.request.headers = headerStringToHeaders(request._header);
+                chainEntry.request.protocol = (request === null || request === void 0 ? void 0 : request._header)
+                    ? headerStringToProtocol(request._header)
+                    : '<Unknown protocol>';
+            }
+            const { body, responseSize } = handleRawResponseBody(response.data);
+            const contentLength = getContentLength(response.headers);
+            chainEntry.response = {
+                headers: headerRecordToHeaderMultiMap(response.headers),
+                status: response.status,
+                response_received_time: responseReceivedTime,
+                response_size: contentLength !== null && contentLength !== void 0 ? contentLength : responseSize,
+                body,
+            };
+        }
+        catch (e) {
+            loggingProvider_1.logger.warn('Error in the response interceptor', e);
+        }
+        return response;
+    }
+    handleError(error) {
+        var _a;
+        try {
+            const config = error.config;
+            let chainEntry;
+            if (config) {
+                chainEntry = this.getOrCreateEntry(config);
+            }
+            else if (this.interceptedRequests.length) {
+                chainEntry =
+                    this.interceptedRequests[this.interceptedRequests.length - 1];
+            }
+            if (chainEntry) {
+                chainEntry.error = {
+                    code: (_a = error.code) !== null && _a !== void 0 ? _a : httpUtil_1.GENERAL_API_STEP_EXECUTION_ERROR_CODE,
+                    message: error.message,
+                    error_received_time: Date.now(),
+                };
+            }
+            if (error.response) {
+                this.handleResponse(error.response);
+            }
+        }
+        catch (e) {
+            loggingProvider_1.logger.warn('Error in the error interceptor', e);
+        }
+        return Promise.reject(error);
+    }
+    getOrCreateEntry(config) {
+        const existingEntry = this.findEntry(config);
+        if (existingEntry) {
+            return existingEntry;
+        }
+        this.handleRequest(config);
+        return this.findEntry(config);
+    }
+    findEntry(config) {
+        return this.interceptedRequests.find((chain) => chain.requestId === config.mablRequestId);
+    }
+}
+exports.RequestInterceptor = RequestInterceptor;

package/index.d.ts

@@ -0,0 +1,241 @@
+import {BrowserContext, Locator, Page, Frame} from 'playwright-core';
+import {TestType} from '@playwright/test';
+
+declare module '@mablhq/playwright-tools' {
+  export enum TestResultStatus {
+    passed = 'passed',
+    skipped = 'skipped',
+    failed = 'failed',
+  }
+  export interface TestResult {
+    status: TestResultStatus;
+    errorMessage?: string;
+    testName: string;
+    startTime: number;
+    endTime: number;
+  }
+  export interface TestResults {
+    numFailedTests: number;
+    numPassedTests: number;
+    numSkippedTests: number;
+    numTotalTests: number;
+    testResults: TestResult[];
+    startTime: number;
+    endTime: number;
+    totalTimeSeconds: number;
+    success: boolean;
+  }
+  export enum RunnerType {
+    Playwright = 'playwright',
+  }
+  export interface HttpHeadersType {
+    [key: string]: string;
+  }
+  export interface HttpConfig {
+    proxyHost?: URL;
+    sslVerify: boolean;
+    proxyType?: string;
+  }
+  export interface TestRunConfig {
+    authToken?: string;
+    basicAuthCredentialsId?: string;
+    branchName?: string;
+    branchChangesOnly?: boolean;
+    credentialsId?: string;
+    dataTableVariables?: Scenario;
+    environmentId?: string;
+    /**
+     * An object containing additional HTTP headers to be sent with every request.
+     */
+    extraHttpHeaders?: HttpHeadersType;
+    filterHttpRequests: boolean;
+    fromPlanId?: string;
+    headless?: boolean;
+    height?: number;
+    highlights?: boolean;
+    interactionSpeed?: string;
+    keepBrowserOpen?: boolean;
+    labelsExclude?: string[];
+    labelsInclude?: string[];
+    mobileConfig?: MobileConfig;
+    proxy?: HttpConfig;
+    testId?: string;
+    runId?: string;
+    url?: string;
+    width?: number;
+    workspaceId?: string;
+    runnerType?: RunnerType;
+  }
+
+  export interface Scenario {
+    variables?: Array<Variable>;
+  }
+  export interface Variable {
+    name?: string;
+    value?: string;
+  }
+
+  export interface MablApiClient {}
+  export class BrowserTestsRunner {
+    run(): Promise<TestResults>;
+  }
+  export function createBrowserTestsRunner(
+    testRunConfig: TestRunConfig,
+    apiClient?: MablApiClient,
+  ): Promise<BrowserTestsRunner>;
+  export class MobileTestsRunner {
+    run(): Promise<TestResults>;
+  }
+  export function createMobileTestsRunner(
+    testRunConfig: TestRunConfig,
+    apiClient?: MablApiClient,
+  ): Promise<MobileTestsRunner>;
+  export function getRunnerVersion(): string;
+}
+
+export interface TrainingSessionOptions {
+  authToken?: string;
+  applicationId?: string;
+  autoBranch?: boolean;
+  branchName?: string;
+  credentialsId?: string;
+  deploymentId?: string;
+  environmentId?: string;
+  height: number;
+  url?: string;
+  width: number;
+}
+export interface CreateTestTrainingSessionOptions
+  extends TrainingSessionOptions {
+  autoLogin?: boolean;
+  dataTableIds?: string[];
+  labels?: string[];
+  newPlanName?: string;
+  planId?: string;
+  testDescription?: string;
+  testName: string;
+  url: string;
+  workspaceId: string;
+}
+export interface EditTrainingSessionOptions extends TrainingSessionOptions {
+  testId?: string;
+  testRunId?: string;
+}
+export declare function trainNewTest(
+  trainingSessionOptions: CreateTestTrainingSessionOptions,
+): Promise<void>;
+export declare function editTest(
+  trainingSessionOptions: EditTrainingSessionOptions,
+): Promise<void>;
+
+export interface MobileConfig {
+  appiumAddress?: string;
+  appiumHome?: string;
+  appiumPort?: string;
+  avdName?: string;
+  isRealDevice?: boolean;
+  mobileAppFileId?: string;
+  path?: string;
+  platformName: MobilePlatformEnum;
+  udid?: string;
+}
+
+export declare enum MobilePlatformEnum {
+  Android = 'android',
+  Ios = 'ios',
+}
+
+// Playwright external tool types
+
+export interface MablToolsetOptions {
+  apiKey: string;
+  browserContext?: BrowserContext;
+  workspaceId?: string;
+  test: TestType<any, any>;
+}
+
+export interface GenAiAssertionResponse {
+  success: boolean;
+  explanation?: string;
+}
+export interface DatabaseQueryParameter {
+  id?: string;
+  type: 'String' | 'Number' | 'Boolean';
+  value: string;
+}
+
+export interface DatabaseQueryResultSet {
+  workspace_id?: string;
+  database_query_execution_id?: string;
+  metadata?: {
+    status?: 'success' | 'failed' | 'error';
+    duration?: number;
+    message?: string;
+    error_message?: string;
+    row_count?: number;
+    column_count?: number;
+    rows_affected?: number;
+    additional_properties?: object;
+  };
+  columns?: any[];
+  rows?: Array<{
+    [key: string]: any;
+  }>;
+}
+
+export interface MablToolset {
+  constructor(options: MablToolsetOptions);
+  evaluateGenAiAssertion(
+    // TODO this is any because it needs to align with the @playwright/test package's Page and we don't have that as a dependency of the CLI right now
+    page: any,
+    prompt: string,
+    locator?: Locator,
+  ): Promise<GenAiAssertionResponse>;
+  initializeContext(browserContext: BrowserContext): Promise<void>;
+  createMailBoxAddress(): Promise<string>;
+  waitForEmail(
+    emailAddress: string,
+    page: Page | Frame,
+    emailFindOptions?: EmailFindOptions,
+  ): Promise<MablMailboxEmail>;
+  openEmailUrl(page: any, emailUrl: string): Promise<MablMailboxEmail>;
+  getCredentials(credentialsId: string): Promise<UsernamePasswordCredential>;
+  getMfaCode(credentialsId: string): Promise<string>;
+  executeQuery(
+    dbConnectionId: string,
+    query: string,
+    queryParameters?: DatabaseQueryParameter[],
+    environmentId?: string,
+    timeoutMillis?: number,
+  ): Promise<DatabaseQueryResultSet>;
+  openPdfFile(filePath: string, page: Page): Promise<void>;
+}
+
+export interface MablFixtures {
+  mabl: MablToolset;
+}
+
+export declare function createMablFixtures(options?: MablToolsetOptions): {
+  mabl: ({context}: any, use: (arg0: MablToolset) => any) => Promise<void>;
+};
+
+export interface EmailFindOptions {
+  subject?: string;
+  from?: string;
+  body?: string;
+  timeoutMillis?: number;
+}
+
+export interface UsernamePasswordCredential {
+  username: string;
+  password: string;
+}
+
+export interface MablMailboxEmail {
+  open(): Promise<void>;
+  getToAddress(): Promise<string | null>;
+  getFromAddress(): Promise<string | null>;
+  getSubject(): Promise<string | null>;
+  getBodyText(): Promise<string | null>;
+  getBodyLocator(): Locator;
+}

package/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMablFixtures = exports.getRunnerVersion = exports.createRunConfig = exports.createMobileTestsRunner = exports.createBrowserTestsRunner = exports.MobileTestsRunner = exports.BrowserTestsRunner = exports.editTest = exports.trainNewTest = void 0;
+var trainingSessions_1 = require("./core/trainer/trainingSessions");
+Object.defineProperty(exports, "trainNewTest", { enumerable: true, get: function () { return trainingSessions_1.trainNewTest; } });
+Object.defineProperty(exports, "editTest", { enumerable: true, get: function () { return trainingSessions_1.editTest; } });
+var index_1 = require("./execution/index");
+Object.defineProperty(exports, "BrowserTestsRunner", { enumerable: true, get: function () { return index_1.BrowserTestsRunner; } });
+Object.defineProperty(exports, "MobileTestsRunner", { enumerable: true, get: function () { return index_1.MobileTestsRunner; } });
+Object.defineProperty(exports, "createBrowserTestsRunner", { enumerable: true, get: function () { return index_1.createBrowserTestsRunner; } });
+Object.defineProperty(exports, "createMobileTestsRunner", { enumerable: true, get: function () { return index_1.createMobileTestsRunner; } });
+Object.defineProperty(exports, "createRunConfig", { enumerable: true, get: function () { return index_1.createRunConfig; } });
+Object.defineProperty(exports, "getRunnerVersion", { enumerable: true, get: function () { return index_1.getRunnerVersion; } });
+Object.defineProperty(exports, "createMablFixtures", { enumerable: true, get: function () { return index_1.createMablFixtures; } });