@mknrt/autotests-overkill 1.1.0

package/dist/src/config/consumerConfig.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+const reportPortalSchema = z.object({
+    endpoint: z.string().min(1),
+    project: z.string().min(1).optional(),
+    token: z.string().min(1).optional(),
+}).strict();
+const gitlabSchema = z.object({
+    baseUrl: z.string().min(1),
+    projectId: z.string().min(1).optional(),
+    token: z.string().min(1).optional(),
+}).strict();
+export const consumerConfigSchema = z.object({
+    repos: z.object({
+        autotests2: z.string().min(1),
+        caseplatformWeb: z.string().min(1),
+    }).strict(),
+    ci: z.object({
+        artifactsRoot: z.string().min(1),
+        reportPortal: reportPortalSchema.optional(),
+        gitlab: gitlabSchema.optional(),
+    }).strict(),
+    cacheDir: z.string().min(1).optional(),
+    projectHints: z.object({
+        defaultWidget: z.string().min(1).optional(),
+    }).strict().optional(),
+}).strict();
+export function resolveRepoPath(value, baseDir = process.cwd()) {
+    return path.resolve(baseDir, value);
+}
+export function parseConsumerConfig(input, baseDir = process.cwd()) {
+    const parsed = consumerConfigSchema.parse(input);
+    return {
+        ...parsed,
+        repos: {
+            autotests2: resolveRepoPath(parsed.repos.autotests2, baseDir),
+            caseplatformWeb: resolveRepoPath(parsed.repos.caseplatformWeb, baseDir),
+        },
+        ci: {
+            artifactsRoot: resolveRepoPath(parsed.ci.artifactsRoot, baseDir),
+            reportPortal: parsed.ci.reportPortal,
+            gitlab: parsed.ci.gitlab,
+        },
+        cacheDir: resolveRepoPath(parsed.cacheDir ?? '.overkill-cache', baseDir),
+    };
+}
+export function loadConsumerConfig(configPath = path.resolve(process.cwd(), 'overkill.config.json')) {
+    const raw = fs.readFileSync(configPath, 'utf8');
+    return parseConsumerConfig(JSON.parse(raw), path.dirname(configPath));
+}
+export function createDefaultConsumerConfig(baseDir = process.cwd()) {
+    return parseConsumerConfig({
+        repos: {
+            autotests2: '../autotests2',
+            caseplatformWeb: '../caseplatform-web',
+        },
+        ci: {
+            artifactsRoot: '../autotests2/cypress',
+        },
+        cacheDir: '.overkill-cache',
+    }, baseDir);
+}

package/dist/src/connectors/autotests2Connector.d.ts

@@ -0,0 +1,41 @@
+export type TestSpecMatch = {
+    path: string;
+    title: string;
+    body: string;
+    score: number;
+};
+export type CommandMatch = {
+    path: string;
+    name: string;
+    body: string;
+};
+export type HelperMatch = {
+    path: string;
+    name: string;
+    body: string;
+};
+export declare class Autotests2Connector {
+    private readonly root;
+    private readonly fs;
+    constructor(root: string);
+    findSpecs(featureHint?: string): Promise<TestSpecMatch[]>;
+    findCommands(): Promise<CommandMatch[]>;
+    findHelpers(featureHint?: string): Promise<HelperMatch[]>;
+    getAreaDocs(): {
+        contextPath: string;
+        testingPath: string;
+        contextText: string;
+        testingText: string;
+        supportBaseText: string;
+        supportBaseConfText: string;
+    };
+    findSelectors(featureHint?: string): Promise<{
+        path: string;
+        body: string;
+    }[]>;
+    summarizeSpec(spec: TestSpecMatch): {
+        path: string;
+        describeNames: string[];
+        itNames: string[];
+    };
+}

package/dist/src/connectors/autotests2Connector.js

@@ -0,0 +1,94 @@
+import path from 'node:path';
+import { FilesystemConnector } from './filesystemConnector.js';
+import { basenameWithoutExt, pathIncludes, toPosixPath } from '../utils/pathUtils.js';
+import { extractMatches, scoreTextMatch } from '../utils/textUtils.js';
+export class Autotests2Connector {
+    root;
+    fs = new FilesystemConnector();
+    constructor(root) {
+        this.root = root;
+    }
+    async findSpecs(featureHint) {
+        const files = await this.fs.glob(this.root, ['cypress/e2e/tests/**/*.cy.js']);
+        const results = [];
+        for (const filePath of files) {
+            const body = this.fs.read(filePath);
+            const score = featureHint ? scoreTextMatch(filePath, featureHint) + scoreTextMatch(body, featureHint) : 1;
+            if (score > 0) {
+                results.push({
+                    path: filePath,
+                    title: basenameWithoutExt(filePath),
+                    body,
+                    score,
+                });
+            }
+        }
+        return results.sort((left, right) => right.score - left.score);
+    }
+    async findCommands() {
+        const files = await this.fs.glob(this.root, ['cypress/support/**/*.js']);
+        const results = [];
+        for (const filePath of files) {
+            const body = this.fs.read(filePath);
+            const names = extractMatches(body, /Cypress\.Commands\.add\((?:'|")([^'"]+)(?:'|")/g);
+            for (const name of names) {
+                results.push({ path: filePath, name, body });
+            }
+            if (pathIncludes(filePath, 'widget') || body.includes('getWidget')) {
+                results.push({ path: filePath, name: 'getWidget', body });
+            }
+        }
+        return dedupeByName(results);
+    }
+    async findHelpers(featureHint) {
+        const files = await this.fs.glob(this.root, ['cypress/support/functions/**/*.js']);
+        const results = [];
+        for (const filePath of files) {
+            const body = this.fs.read(filePath);
+            const names = [
+                ...extractMatches(body, /export function ([A-Za-z0-9_]+)/g),
+                ...extractMatches(body, /function ([A-Za-z0-9_]+)/g),
+            ];
+            for (const name of names) {
+                if (!featureHint || scoreTextMatch(`${filePath}\n${body}`, featureHint) > 0) {
+                    results.push({ path: filePath, name, body });
+                }
+            }
+        }
+        return dedupeByName(results);
+    }
+    getAreaDocs() {
+        return {
+            contextPath: path.join(this.root, '.codex', 'context.md'),
+            testingPath: path.join(this.root, '.codex', 'testing.md'),
+            contextText: this.fs.read(path.join(this.root, '.codex', 'context.md')),
+            testingText: this.fs.read(path.join(this.root, '.codex', 'testing.md')),
+            supportBaseText: this.fs.read(path.join(this.root, 'cypress', 'support', 'base.js')),
+            supportBaseConfText: this.fs.read(path.join(this.root, 'cypress', 'support', 'baseConf.js')),
+        };
+    }
+    async findSelectors(featureHint) {
+        const files = await this.fs.glob(this.root, ['cypress/support/selectors/**/*.js']);
+        return files
+            .map((filePath) => ({ path: filePath, body: this.fs.read(filePath) }))
+            .filter((file) => !featureHint || scoreTextMatch(`${file.path}\n${file.body}`, featureHint) > 0);
+    }
+    summarizeSpec(spec) {
+        const describeNames = extractMatches(spec.body, /describe\((?:'|")([^'"]+)/g);
+        const itNames = extractMatches(spec.body, /it\((?:'|")([^'"]+)/g);
+        return {
+            path: toPosixPath(spec.path),
+            describeNames,
+            itNames,
+        };
+    }
+}
+function dedupeByName(items) {
+    const seen = new Map();
+    for (const item of items) {
+        if (!seen.has(item.name)) {
+            seen.set(item.name, item);
+        }
+    }
+    return [...seen.values()];
+}

package/dist/src/connectors/caseplatformConnector.d.ts

@@ -0,0 +1,35 @@
+export type WidgetFiles = {
+    controlFile?: string;
+    singletonFile?: string;
+    handlersFile?: string;
+    templateFile?: string;
+    dataControlFile?: string;
+    supportFiles: string[];
+    allFiles: string[];
+};
+export type FeatureFiles = WidgetFiles & {
+    mode: 'widget' | 'conf' | 'unknown';
+    primaryFiles: string[];
+};
+export type IndexableCaseplatformSource = {
+    path: string;
+    title: string;
+    body: string;
+    sourceKind: string;
+    metadata: Record<string, unknown>;
+};
+export declare class CaseplatformConnector {
+    private readonly root;
+    private readonly fs;
+    constructor(root: string);
+    listIndexableSources(): Promise<IndexableCaseplatformSource[]>;
+    resolveFeatureFiles(featureHint: string): Promise<FeatureFiles>;
+    resolveWidgetFiles(widgetHint: string): Promise<WidgetFiles>;
+    read(filePath: string): string;
+    classifyFileKind(filePath: string): "widget" | "support" | "controller" | "view" | "model" | "store";
+    classifyIndexSourceKind(filePath: string): "frontend-widget" | "frontend-formrunner" | "conf-view" | "conf-controller" | "conf-model" | "conf-store" | "conf-support" | "frontend-support" | "caseplatform-support";
+    private resolveImportedSupportFiles;
+    private resolveImportPath;
+    private isSupportFile;
+    private resolveConfFiles;
+}

package/dist/src/connectors/caseplatformConnector.js

@@ -0,0 +1,251 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { FilesystemConnector } from './filesystemConnector.js';
+import { featureNameCandidates, pathIncludes, unique, widgetNameCandidates } from '../utils/pathUtils.js';
+import { scoreTextMatch } from '../utils/textUtils.js';
+export class CaseplatformConnector {
+    root;
+    fs = new FilesystemConnector();
+    constructor(root) {
+        this.root = root;
+    }
+    async listIndexableSources() {
+        const files = await this.fs.glob(this.root, [
+            'vcm/**/*.{ts,tsx,js}',
+            'FormRunner/**/*.{ts,tsx,js}',
+            'conf/**/*.{ts,tsx,js}',
+        ]);
+        return unique(files)
+            .map((filePath) => ({
+            path: filePath,
+            title: path.basename(filePath),
+            body: this.read(filePath),
+            sourceKind: this.classifyIndexSourceKind(filePath),
+            metadata: {
+                fileKind: this.classifyFileKind(filePath),
+            },
+        }))
+            .filter((source) => source.body.trim().length > 0);
+    }
+    async resolveFeatureFiles(featureHint) {
+        const widgetFiles = await this.resolveWidgetFiles(featureHint);
+        if (widgetFiles.allFiles.length > 0) {
+            return {
+                mode: 'widget',
+                primaryFiles: [widgetFiles.controlFile, widgetFiles.singletonFile, widgetFiles.handlersFile, widgetFiles.templateFile].filter(Boolean),
+                ...widgetFiles,
+            };
+        }
+        const confFiles = await this.resolveConfFiles(featureHint);
+        if (confFiles.allFiles.length > 0) {
+            return confFiles;
+        }
+        return {
+            mode: 'unknown',
+            primaryFiles: [],
+            supportFiles: [],
+            allFiles: [],
+        };
+    }
+    async resolveWidgetFiles(widgetHint) {
+        const files = await this.fs.glob(this.root, [
+            'vcm/jqVCM/widget/**/*.{ts,tsx,js}',
+            'FormRunner/**/*.{ts,tsx,js}',
+        ]);
+        const candidates = widgetNameCandidates(widgetHint);
+        const matching = files.filter((filePath) => candidates.some((candidate) => pathIncludes(filePath, candidate)));
+        const rankFile = (filePath) => candidates.reduce((score, candidate) => score + scoreTextMatch(filePath, candidate), 0);
+        const ordered = matching.sort((left, right) => rankFile(right) - rankFile(left));
+        const dataControlFile = ordered.find((filePath) => /DataControl\.(ts|js)$/i.test(filePath));
+        const controlFile = ordered.find((filePath) => /(?:Control|_control)\.(ts|js)$/i.test(filePath) && filePath !== dataControlFile);
+        const singletonFile = ordered.find((filePath) => /(?:Singleton|_singleton)\.(ts|js)$/i.test(filePath));
+        const handlersFile = ordered.find((filePath) => /(?:Handlers|_handlers)\.(ts|js)$/i.test(filePath));
+        const templateFile = ordered.find((filePath) => /Templates\.(tsx|ts|js)$/i.test(filePath));
+        const widgetDirectory = controlFile
+            ? controlFile.replace(/[\\/][^\\/]+$/, '')
+            : singletonFile
+                ? singletonFile.replace(/[\\/][^\\/]+$/, '')
+                : ordered[0]?.replace(/[\\/][^\\/]+$/, '');
+        const localSupportFiles = widgetDirectory
+            ? files
+                .filter((filePath) => filePath.startsWith(widgetDirectory))
+                .filter((filePath) => ![controlFile, singletonFile, handlersFile, templateFile, dataControlFile].includes(filePath))
+                .filter((filePath) => this.isSupportFile(filePath))
+            : [];
+        const importedSupportFiles = this.resolveImportedSupportFiles([
+            controlFile,
+            singletonFile,
+            handlersFile,
+            templateFile,
+            dataControlFile,
+            ...localSupportFiles,
+        ].filter(Boolean));
+        const supportFiles = unique([...localSupportFiles, ...importedSupportFiles]);
+        const allFiles = unique([...ordered, ...supportFiles]);
+        return {
+            controlFile,
+            singletonFile,
+            handlersFile,
+            templateFile,
+            dataControlFile,
+            supportFiles,
+            allFiles,
+        };
+    }
+    read(filePath) {
+        return this.fs.read(filePath);
+    }
+    classifyFileKind(filePath) {
+        const normalized = filePath.replaceAll('\\', '/').toLowerCase();
+        if (normalized.includes('/controller/')) {
+            return 'controller';
+        }
+        if (normalized.includes('/view/')) {
+            return 'view';
+        }
+        if (normalized.includes('/model/')) {
+            return 'model';
+        }
+        if (normalized.includes('/store/')) {
+            return 'store';
+        }
+        if (normalized.includes('/widget/')) {
+            return 'widget';
+        }
+        return 'support';
+    }
+    classifyIndexSourceKind(filePath) {
+        const normalized = filePath.replaceAll('\\', '/').toLowerCase();
+        if (normalized.includes('/vcm/jqvcm/widget/')) {
+            return 'frontend-widget';
+        }
+        if (normalized.includes('/formrunner/')) {
+            return 'frontend-formrunner';
+        }
+        if (normalized.includes('/conf/app/view/')) {
+            return 'conf-view';
+        }
+        if (normalized.includes('/conf/app/controller/')) {
+            return 'conf-controller';
+        }
+        if (normalized.includes('/conf/app/model/')) {
+            return 'conf-model';
+        }
+        if (normalized.includes('/conf/app/store/')) {
+            return 'conf-store';
+        }
+        if (normalized.includes('/conf/')) {
+            return 'conf-support';
+        }
+        if (normalized.includes('/vcm/')) {
+            return 'frontend-support';
+        }
+        return 'caseplatform-support';
+    }
+    resolveImportedSupportFiles(seedFiles) {
+        const visited = new Set();
+        const supportFiles = [];
+        const queue = [...seedFiles];
+        while (queue.length > 0) {
+            const currentFile = queue.shift();
+            if (!currentFile || visited.has(currentFile)) {
+                continue;
+            }
+            visited.add(currentFile);
+            const body = this.read(currentFile);
+            if (!body) {
+                continue;
+            }
+            const specifiers = [
+                ...body.matchAll(/(?:import|export)\s+(?:[^'"]+?\s+from\s+)?['"]([^'"]+)['"]/g),
+            ].map((match) => match[1]).filter(Boolean);
+            for (const specifier of specifiers) {
+                const resolvedFile = this.resolveImportPath(currentFile, specifier);
+                if (!resolvedFile || !this.isSupportFile(resolvedFile)) {
+                    continue;
+                }
+                supportFiles.push(resolvedFile);
+                queue.push(resolvedFile);
+            }
+        }
+        return unique(supportFiles);
+    }
+    resolveImportPath(fromFile, specifier) {
+        let rawPath;
+        if (specifier.startsWith('.')) {
+            rawPath = path.resolve(path.dirname(fromFile), specifier);
+        }
+        else if (specifier.startsWith('@VCM/')) {
+            rawPath = path.resolve(this.root, 'vcm', specifier.slice('@VCM/'.length));
+        }
+        else if (specifier.startsWith('@CONF/')) {
+            rawPath = path.resolve(this.root, 'conf', specifier.slice('@CONF/'.length));
+        }
+        if (!rawPath) {
+            return undefined;
+        }
+        const candidates = [
+            rawPath,
+            `${rawPath}.ts`,
+            `${rawPath}.tsx`,
+            `${rawPath}.js`,
+            path.join(rawPath, 'index.ts'),
+            path.join(rawPath, 'index.tsx'),
+            path.join(rawPath, 'index.js'),
+        ];
+        return candidates.find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
+    }
+    isSupportFile(filePath) {
+        const normalized = filePath.replaceAll('\\', '/').toLowerCase();
+        return normalized.includes('/widget/utils/')
+            || /(constants|validation|replace|helper|template|data|config|day)/i.test(path.basename(normalized));
+    }
+    async resolveConfFiles(featureHint) {
+        const files = await this.fs.glob(this.root, [
+            'conf/**/*.{ts,tsx,js}',
+        ]);
+        const candidates = featureNameCandidates(featureHint);
+        const scored = files
+            .map((filePath) => {
+            const body = this.read(filePath);
+            const pathScore = candidates.reduce((score, candidate) => score + scoreTextMatch(filePath, candidate), 0);
+            const bodyScore = candidates.reduce((score, candidate) => score + scoreTextMatch(body, candidate), 0);
+            const kindBoost = this.classifyFileKind(filePath) === 'view' ? 3 : this.classifyFileKind(filePath) === 'controller' ? 2 : 1;
+            return {
+                path: filePath,
+                body,
+                score: pathScore * 2 + bodyScore + kindBoost,
+            };
+        })
+            .filter((item) => item.score > 0)
+            .sort((left, right) => right.score - left.score);
+        const primaryFiles = pickDiverseConfFiles(scored, this);
+        const importedSupportFiles = this.resolveImportedSupportFiles(primaryFiles)
+            .filter((filePath) => filePath.replaceAll('\\', '/').includes('/conf/'));
+        const supportFiles = unique(importedSupportFiles.filter((filePath) => !primaryFiles.includes(filePath)).slice(0, 6));
+        const allFiles = unique([...primaryFiles, ...supportFiles]);
+        return {
+            mode: allFiles.length > 0 ? 'conf' : 'unknown',
+            primaryFiles,
+            supportFiles,
+            allFiles,
+        };
+    }
+}
+function pickDiverseConfFiles(scored, connector) {
+    const byKind = new Map();
+    for (const item of scored) {
+        const kind = connector.classifyFileKind(item.path);
+        byKind.set(kind, [...(byKind.get(kind) ?? []), item.path]);
+    }
+    const picked = [
+        ...(byKind.get('view') ?? []).slice(0, 5),
+        ...(byKind.get('controller') ?? []).slice(0, 2),
+        ...(byKind.get('model') ?? []).slice(0, 1),
+        ...(byKind.get('store') ?? []).slice(0, 1),
+    ];
+    if (picked.length < 8) {
+        picked.push(...scored.map((item) => item.path));
+    }
+    return unique(picked).slice(0, 8);
+}

package/dist/src/connectors/ciArtifactsConnector.d.ts

@@ -0,0 +1,23 @@
+export type StatsReport = {
+    total?: number;
+    passed?: number;
+    failed?: number;
+    skipped?: number;
+    failed_specs?: string[];
+    failed_specs_string?: string;
+    launch_link?: string;
+    launch_id?: string;
+    specs?: Array<{
+        file: string;
+        stats?: Record<string, number>;
+        tests?: Array<{
+            title: string;
+            status: string;
+            duration?: number;
+        }>;
+    }>;
+};
+export declare class CiArtifactsConnector {
+    readStats(filePath: string): StatsReport;
+    listArtifacts(root: string, pattern: string): string[];
+}

package/dist/src/connectors/ciArtifactsConnector.js

@@ -0,0 +1,14 @@
+import fg from 'fast-glob';
+import { readJson } from '../utils/fileUtils.js';
+export class CiArtifactsConnector {
+    readStats(filePath) {
+        return readJson(filePath);
+    }
+    listArtifacts(root, pattern) {
+        return fg.sync(pattern, {
+            cwd: root,
+            absolute: true,
+            onlyFiles: true,
+        });
+    }
+}

package/dist/src/connectors/diffConnector.d.ts

@@ -0,0 +1 @@
+export declare function normalizeChangedFiles(changedFiles: string[]): string[];

package/dist/src/connectors/diffConnector.js

@@ -0,0 +1,4 @@
+import path from 'node:path';
+export function normalizeChangedFiles(changedFiles) {
+    return changedFiles.map((file) => path.resolve(file));
+}

package/dist/src/connectors/filesystemConnector.d.ts

@@ -0,0 +1,4 @@
+export declare class FilesystemConnector {
+    glob(root: string, patterns: string[]): Promise<string[]>;
+    read(filePath: string): string;
+}

package/dist/src/connectors/filesystemConnector.js

@@ -0,0 +1,15 @@
+import fg from 'fast-glob';
+import { readTextIfExists } from '../utils/fileUtils.js';
+export class FilesystemConnector {
+    async glob(root, patterns) {
+        return fg(patterns, {
+            cwd: root,
+            absolute: true,
+            onlyFiles: true,
+            dot: true,
+        });
+    }
+    read(filePath) {
+        return readTextIfExists(filePath);
+    }
+}

package/dist/src/connectors/gitlabConnector.d.ts

@@ -0,0 +1,14 @@
+import type { ConsumerConfig } from '../config/consumerConfig.js';
+export type GitLabPipelineContext = {
+    pipelineUrl?: string;
+    pipelineStatus?: string;
+    source: 'config-only' | 'live-api' | 'unavailable';
+    warnings: string[];
+};
+export declare class GitLabConnector {
+    private readonly config?;
+    constructor(config?: ConsumerConfig['ci']['gitlab']);
+    describePipeline(input?: {
+        sha?: string;
+    }): Promise<GitLabPipelineContext>;
+}

package/dist/src/connectors/gitlabConnector.js

@@ -0,0 +1,64 @@
+export class GitLabConnector {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async describePipeline(input) {
+        if (!this.config) {
+            return {
+                source: 'unavailable',
+                warnings: [],
+            };
+        }
+        if (!this.config.projectId || !this.config.token) {
+            return {
+                source: 'config-only',
+                warnings: ['GitLab live lookup is disabled because projectId or token is missing. Using local artifacts only.'],
+            };
+        }
+        const sha = input?.sha ?? process.env.CI_COMMIT_SHA;
+        if (!sha) {
+            return {
+                source: 'config-only',
+                warnings: ['GitLab live lookup is disabled because no commit SHA was provided by CI_COMMIT_SHA or tool input.'],
+            };
+        }
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 1500);
+            const response = await fetch(`${this.config.baseUrl.replace(/\/+$/, '')}/api/v4/projects/${encodeURIComponent(this.config.projectId)}/pipelines?sha=${encodeURIComponent(sha)}`, {
+                headers: {
+                    'PRIVATE-TOKEN': this.config.token,
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                return {
+                    source: 'config-only',
+                    warnings: [`GitLab live lookup failed with status ${response.status}. Using local artifacts only.`],
+                };
+            }
+            const payload = await response.json();
+            const pipeline = payload[0];
+            if (!pipeline) {
+                return {
+                    source: 'config-only',
+                    warnings: [`GitLab did not return a pipeline for commit ${sha}. Using local artifacts only.`],
+                };
+            }
+            return {
+                pipelineUrl: pipeline.web_url,
+                pipelineStatus: pipeline.status,
+                source: 'live-api',
+                warnings: [],
+            };
+        }
+        catch (error) {
+            return {
+                source: 'config-only',
+                warnings: [`GitLab live lookup failed: ${error instanceof Error ? error.message : 'unknown error'}. Using local artifacts only.`],
+            };
+        }
+    }
+}

package/dist/src/connectors/reportPortalConnector.d.ts

@@ -0,0 +1,14 @@
+import type { ConsumerConfig } from '../config/consumerConfig.js';
+import type { StatsReport } from './ciArtifactsConnector.js';
+export type ReportPortalLaunchContext = {
+    launchLink?: string;
+    launchId?: string;
+    launchStatus?: string;
+    source: 'local-stats' | 'live-api' | 'unavailable';
+    warnings: string[];
+};
+export declare class ReportPortalConnector {
+    private readonly config?;
+    constructor(config?: ConsumerConfig['ci']['reportPortal']);
+    describeLaunch(stats: StatsReport): Promise<ReportPortalLaunchContext>;
+}