newman-reporter-qase 1.0.7 → 2.0.0-beta.1

package/README.md

@@ -29,22 +29,11 @@ pm.test('expect response be 200', function () {
 ```
 ### Execute rom CLI:
 ```
-QASE_RUN_ID=34 # Specify Run ID using ENV
-newman run \
-    -r qase \ # Enable Qase logger
-    --reporter-qase-logging \ # Use reporter logger (like debug)
-    --reporter-qase-projectCode project_code \ # Specify Project Code
-    --reporter-qase-apiToken api_token \ # Specify API token
-    --reporter-qase-runId 34 \ # Specify Run ID using CLI parameters
-    --reporter-qase-basePath https://api.qase.io/v1 \ # URL Qase.io
-    --reporter-qase-runName 'API test Execution' \ # Specify Run name using CLI parameters
-    --reporter-qase-runDescription 'Check API consistency' \ # Specify Run description using CLI parameters
-    --reporter-qase-rootSuiteTitle 'Newman tests' \ # A parent suite for your autocreated tests
-    -x # WA for issue https://github.com/postmanlabs/newman/issues/2148#issuecomment-665229759
+QASE_MODE=testops newman run ./sample-collection.json -r qase
 ```
 
 <p align="center">
-  <img width="65%" src="./examples/screenshots/screenshot.png">
+  <img width="65%" src="./screenshots/screenshot.png">
 </p>
 
 A test run will be performed and available at:
@@ -54,13 +43,61 @@ https://app.qase.io/run/QASE_PROJECT_CODE
 ```
 
 <p align="center">
-  <img src="./examples/screenshots/demo.gif">
+  <img src="./screenshots/demo.gif">
 </p>
 
+## Configuration
+
+Qase reporter supports passing parameters using two ways:
+using `.qaserc`/`qase.config.json` file and using ENV variables.
+
+`.qaserc` parameters, (* - required):
+- `mode` - `testops`/`off` Enables reporter, default - `off`
+- `debug` - Enables debug logging, defaule - `false`
+- `environment` - To execute with the sending of the envinroment information 
+- *`testops.api.token` - Token for API access, you can find more information
+  [here](https://developers.qase.io/#authentication)
+- *`testops.project` - Code of your project (can be extracted from main
+  page of your project: `https://app.qase.io/project/DEMOTR` -
+  `DEMOTR` is project code here)
+- `testops.run.id` - Pass Run ID
+- `testops.run.title` - Set custom Run name, when new run is created
+- `testops.run.description` - Set custom Run description, when new run is created
+- `testops.run.complete` - Whether the run should be completed
+
+Example configuration file:
+
+```json
+{
+  "mode": "testops",
+  "debug": true,
+  "environment": 1,
+  "testops": {
+    "api": {
+      "token": "api_key"
+    },
+    "projectCode": "project_code"
+  }
+}
+```
+
+Supported ENV variables:
+
+- `QASE_MODE` - Same as `mode`
+- `QASE_DEBUG` - Same as `debug`
+- `QASE_ENVIRONMENT` - Same as `environment` 
+- `QASE_TESTOPS_API_TOKEN` - Same as `testops.api.token`
+- `QASE_TESTOPS_PROJECT` - Same as `testops.project`
+- `QASE_TESTOPS_RUN_ID` - Pass Run ID from ENV and override reporter option `testops.run.id`
+- `QASE_TESTOPS_RUN_TITLE` - Same as `testops.run.title`
+- `QASE_TESTOPS_RUN_DESCRIPTION` - Same as `testops.run.description`
+
 ## Requirements
 
 We maintain the reporter on LTS versions of Node. You can find the current versions by following the [link](https://nodejs.org/en/about/releases/)
 
+`newman >= 5.3.0`
+
 <!-- references -->
 
 [auth]: https://developers.qase.io/#authentication

package/dist/index.d.ts

@@ -1,39 +1,2 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { NewmanRunOptions } from 'newman';
-interface QaseOptions {
-    apiToken: string;
-    basePath?: string;
-    rootSuiteTitle?: string;
-    projectCode: string;
-    runId?: string;
-    runPrefix?: string;
-    runName?: string;
-    runDescription?: string;
-    logging?: boolean;
-    runComplete?: boolean;
-    environmentId?: number;
-}
-declare class NewmanQaseReporter {
-    private api;
-    private prePending;
-    private options;
-    private collectionOptions;
-    private runId?;
-    private isDisabled;
-    constructor(emitter: EventEmitter, _options: QaseOptions, collectionRunOptions: NewmanRunOptions);
-    private createHeaders;
-    private getEnv;
-    private log;
-    private getPackageVersion;
-    private addRunnerListeners;
-    private extractIds;
-    private checkProject;
-    private createRun;
-    private createRunObject;
-    private checkRun;
-    private itemName;
-    private logTestItem;
-    private createBulkResultsBodyObject;
-}
+import { NewmanQaseReporter } from './reporter';
 export = NewmanQaseReporter;

package/dist/index.js

@@ -1,420 +1,3 @@
 "use strict";
-var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
-    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
-    return cooked;
-};
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArrays = (this && this.__spreadArrays) || function () {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var src_1 = require("qaseio/dist/src");
-var child_process_1 = require("child_process");
-var qaseio_1 = require("qaseio");
-var chalk_1 = __importDefault(require("chalk"));
-var fs_1 = require("fs");
-var Envs;
-(function (Envs) {
-    Envs["report"] = "QASE_REPORT";
-    Envs["apiToken"] = "QASE_API_TOKEN";
-    Envs["basePath"] = "QASE_API_BASE_URL";
-    Envs["projectCode"] = "QASE_PROJECT_CODE";
-    Envs["runId"] = "QASE_RUN_ID";
-    Envs["runName"] = "QASE_RUN_NAME";
-    Envs["runDescription"] = "QASE_RUN_DESCRIPTION";
-    Envs["runComplete"] = "QASE_RUN_COMPLETE";
-    Envs["environmentId"] = "QASE_ENVIRONMENT_ID";
-    Envs["rootSuiteTitle"] = "QASE_ROOT_SUITE_TITLE";
-})(Envs || (Envs = {}));
-var NewmanQaseReporter = /** @class */ (function () {
-    function NewmanQaseReporter(emitter, _options, collectionRunOptions) {
-        this.prePending = {};
-        this.isDisabled = false;
-        this.options = _options;
-        this.options.projectCode =
-            _options.projectCode || this.getEnv(Envs.projectCode) || '';
-        this.collectionOptions = collectionRunOptions;
-        this.options.runComplete =
-            !!this.getEnv(Envs.runComplete) || this.options.runComplete || false;
-        this.options.environmentId = Number(this.getEnv(Envs.environmentId)) || this.options.environmentId || undefined;
-        this.api = new qaseio_1.QaseApi(this.getEnv(Envs.apiToken) || this.options.apiToken || '', this.getEnv(Envs.basePath) || this.options.basePath, this.createHeaders());
-        this.log(chalk_1.default(templateObject_1 || (templateObject_1 = __makeTemplateObject(["{yellow Current PID: ", "}"], ["{yellow Current PID: ", "}"])), process.pid));
-        if (!this.options.projectCode) {
-            return;
-        }
-        this.addRunnerListeners(emitter);
-    }
-    NewmanQaseReporter.prototype.createHeaders = function () {
-        var nodeVersion = process.version, os = process.platform, arch = process.arch;
-        var npmVersion = child_process_1.execSync('npm -v', { encoding: 'utf8' }).replace(/['"\n]+/g, '');
-        var qaseapiVersion = this.getPackageVersion('qaseio');
-        var frameworkVersion = this.getPackageVersion('newman');
-        var reporterVersion = this.getPackageVersion('newman-reporter-qase');
-        var xPlatformHeader = "node=" + nodeVersion + "; npm=" + npmVersion + "; os=" + os + "; arch=" + arch;
-        // eslint-disable-next-line max-len
-        var xClientHeader = "newman=" + frameworkVersion + "; qase-newman=" + reporterVersion + "; qaseapi=" + qaseapiVersion;
-        return {
-            'X-Client': xClientHeader,
-            'X-Platform': xPlatformHeader,
-        };
-    };
-    NewmanQaseReporter.prototype.getEnv = function (name) {
-        return process.env[name];
-    };
-    NewmanQaseReporter.prototype.log = function (message) {
-        var optionalParams = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            optionalParams[_i - 1] = arguments[_i];
-        }
-        if (this.options.logging) {
-            console.log.apply(console, __spreadArrays([chalk_1.default(templateObject_2 || (templateObject_2 = __makeTemplateObject(["{bold {blue qase:}} ", ""], ["{bold {blue qase:}} ", ""])), message)], optionalParams));
-        }
-    };
-    NewmanQaseReporter.prototype.getPackageVersion = function (name) {
-        var UNDEFINED = 'undefined';
-        try {
-            var pathToPackageJson = require.resolve(name + "/package.json", {
-                paths: [process.cwd()],
-            });
-            if (pathToPackageJson) {
-                try {
-                    var packageString = fs_1.readFileSync(pathToPackageJson, {
-                        encoding: 'utf8',
-                    });
-                    if (packageString) {
-                        var packageObject = JSON.parse(packageString);
-                        return packageObject.version;
-                    }
-                    return UNDEFINED;
-                }
-                catch (error) {
-                    return UNDEFINED;
-                }
-            }
-        }
-        catch (error) {
-            return UNDEFINED;
-        }
-    };
-    NewmanQaseReporter.prototype.addRunnerListeners = function (runner) {
-        var _this = this;
-        runner.on('start', function () {
-            if (_this.isDisabled) {
-                return;
-            }
-        });
-        runner.on('beforeItem', function (err, args) {
-            var item = args.item;
-            var name = _this.itemName(args);
-            var ids = _this.extractIds(item.events);
-            if (name) {
-                _this.log('Test', name, 'starting, case ids:', ids);
-                _this.prePending[name] = {
-                    name: name,
-                    result: src_1.ResultCreateStatusEnum.PASSED,
-                    duration: 0,
-                    ids: ids,
-                    startStamp: Date.now(),
-                };
-            }
-        });
-        runner.on('request', function (err, args) {
-            var name = _this.itemName(args);
-            if (name && _this.prePending[name]) {
-                _this.prePending[name].response = args.response;
-            }
-        });
-        runner.on('assertion', function (err, args) {
-            var name = _this.itemName(args);
-            if (name && _this.prePending[name] && err) {
-                _this.prePending[name].result = src_1.ResultCreateStatusEnum.FAILED;
-                _this.prePending[name].err = err;
-            }
-        });
-        runner.on('item', function (err, args) {
-            var name = _this.itemName(args);
-            if (name && _this.prePending[name]) {
-                var item = _this.prePending[name];
-                item.endStamp = Date.now();
-                item.duration = item.endStamp - item.startStamp;
-                _this.logTestItem(_this.prePending[name]);
-            }
-        });
-        runner.on('beforeDone', function () {
-            void _this.checkProject(_this.options.projectCode, function (prjExists) { return __awaiter(_this, void 0, void 0, function () {
-                var providedRunId;
-                var _this = this;
-                return __generator(this, function (_a) {
-                    if (!prjExists) {
-                        this.log(chalk_1.default(templateObject_3 || (templateObject_3 = __makeTemplateObject(["{red Project ", " does not exist}"], ["{red Project ", " does not exist}"])), this.options.projectCode));
-                        this.isDisabled = true;
-                        return [2 /*return*/];
-                    }
-                    this.log(chalk_1.default(templateObject_4 || (templateObject_4 = __makeTemplateObject(["{green Project ", " exists}"], ["{green Project ", " exists}"])), this.options.projectCode));
-                    providedRunId = this.getEnv(Envs.runId) || this.options.runId;
-                    if (providedRunId) {
-                        this.runId = providedRunId;
-                        return [2 /*return*/, this.checkRun(this.runId, function (runExists) {
-                                if (runExists) {
-                                    _this.log(chalk_1.default(templateObject_5 || (templateObject_5 = __makeTemplateObject(["{green Using run ", " to publish test results}"], ["{green Using run ", " to publish test results}"])), _this.runId));
-                                }
-                                else {
-                                    _this.log(chalk_1.default(templateObject_6 || (templateObject_6 = __makeTemplateObject(["{red Run ", " does not exist}"], ["{red Run ", " does not exist}"])), _this.runId));
-                                    _this.isDisabled = true;
-                                }
-                            })];
-                    }
-                    else {
-                        return [2 /*return*/, this.createRun(this.getEnv(Envs.runName) || this.options.runName, this.getEnv(Envs.runDescription) ||
-                                this.options.runDescription, function (created) {
-                                var _a;
-                                if (created) {
-                                    _this.runId = (_a = created.result) === null || _a === void 0 ? void 0 : _a.id;
-                                    process.env.QASE_RUN_ID = String(_this.runId);
-                                    _this.log(chalk_1.default(templateObject_7 || (templateObject_7 = __makeTemplateObject(["{green Using run ", " to publish test results}"], ["{green Using run ", " to publish test results}"])), _this.runId));
-                                }
-                                else {
-                                    _this.log(chalk_1.default(templateObject_8 || (templateObject_8 = __makeTemplateObject(["{red Could not create run in project ", "}"], ["{red Could not create run in project ", "}"])), _this.options.projectCode));
-                                    _this.isDisabled = true;
-                                }
-                            })];
-                    }
-                    return [2 /*return*/];
-                });
-            }); }).then(function () {
-                var config = {
-                    apiToken: _this.getEnv(Envs.apiToken) || _this.options.apiToken || '',
-                    basePath: _this.getEnv(Envs.basePath) || _this.options.basePath,
-                    headers: _this.createHeaders(),
-                    code: _this.options.projectCode,
-                    runId: Number(_this.runId),
-                    body: {
-                        results: _this.createBulkResultsBodyObject(),
-                    },
-                    runComplete: _this.options.runComplete,
-                };
-                child_process_1.spawnSync('node', [__dirname + "/reportBulk.js"], {
-                    stdio: 'inherit',
-                    env: Object.assign(process.env, {
-                        reporting_config: JSON.stringify(config),
-                    }),
-                });
-            });
-        });
-        runner.on('done', function () {
-            _this.log('Done');
-            _this.log('Run finished');
-        });
-    };
-    NewmanQaseReporter.prototype.extractIds = function (eventList) {
-        var regex = /\/\/\s?[qQ]ase:\s?((?:[\d]+[\s,]{0,})+)/g;
-        var ids = [];
-        eventList.each(function (event) {
-            if (event.listen === 'test' && event.script.exec) {
-                event.script.exec.forEach(function (line) {
-                    var m;
-                    while ((m = regex.exec(line)) !== null) {
-                        if (m.index === regex.lastIndex) {
-                            regex.lastIndex++;
-                        }
-                        m.forEach(function (match, groupIndex) {
-                            if (groupIndex === 1) {
-                                var hereIds = match.split(/[, ]/).filter(function (val) { return val !== ''; });
-                                ids.push.apply(ids, hereIds);
-                            }
-                        });
-                    }
-                });
-            }
-        });
-        return ids;
-    };
-    NewmanQaseReporter.prototype.checkProject = function (projectCode, cb) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var resp, err_1;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 3, , 4]);
-                        return [4 /*yield*/, this.api.projects.getProject(projectCode)];
-                    case 1:
-                        resp = _b.sent();
-                        return [4 /*yield*/, cb(Boolean((_a = resp.data.result) === null || _a === void 0 ? void 0 : _a.code))];
-                    case 2:
-                        _b.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        err_1 = _b.sent();
-                        this.log(err_1);
-                        this.isDisabled = true;
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NewmanQaseReporter.prototype.createRun = function (name, description, cb) {
-        return __awaiter(this, void 0, void 0, function () {
-            var runObject, resp, err_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        runObject = this.createRunObject(name || "Automated run " + new Date().toISOString(), [], {
-                            description: description || 'Newman automated run',
-                            is_autotest: true,
-                            environment_id: this.options.environmentId,
-                        });
-                        return [4 /*yield*/, this.api.runs.createRun(this.options.projectCode, runObject)];
-                    case 1:
-                        resp = _a.sent();
-                        cb(resp.data);
-                        return [3 /*break*/, 3];
-                    case 2:
-                        err_2 = _a.sent();
-                        this.log("Error on creating run " + err_2);
-                        this.isDisabled = true;
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NewmanQaseReporter.prototype.createRunObject = function (name, cases, args) {
-        return __assign({ title: name, cases: cases }, args);
-    };
-    NewmanQaseReporter.prototype.checkRun = function (runId, cb) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                if (runId === undefined) {
-                    cb(false);
-                    return [2 /*return*/];
-                }
-                return [2 /*return*/, this.api.runs
-                        .getRun(this.options.projectCode, Number(runId))
-                        .then(function (resp) {
-                        var _a, _b;
-                        _this.log("Get run result on checking run " + ((_a = resp.data.result) === null || _a === void 0 ? void 0 : _a.id));
-                        cb(Boolean((_b = resp.data.result) === null || _b === void 0 ? void 0 : _b.id));
-                    })
-                        .catch(function (err) {
-                        _this.log("Error on checking run " + err);
-                        _this.isDisabled = true;
-                    })];
-            });
-        });
-    };
-    NewmanQaseReporter.prototype.itemName = function (args) {
-        if (args.item) {
-            var item = args.item;
-            var name_1 = item.name;
-            return name_1;
-        }
-    };
-    NewmanQaseReporter.prototype.logTestItem = function (test) {
-        var map = {
-            failed: chalk_1.default(templateObject_9 || (templateObject_9 = __makeTemplateObject(["{red Test ", " ", "}"], ["{red Test ", " ", "}"])), test.name, test.result),
-            passed: chalk_1.default(templateObject_10 || (templateObject_10 = __makeTemplateObject(["{green Test ", " ", "}"], ["{green Test ", " ", "}"])), test.name, test.result),
-            pending: chalk_1.default(templateObject_11 || (templateObject_11 = __makeTemplateObject(["{blueBright Test ", " ", "}"], ["{blueBright Test ", " ", "}"])), test.name, test.result),
-        };
-        if (test.result) {
-            this.log(map[test.result]);
-        }
-    };
-    NewmanQaseReporter.prototype.createBulkResultsBodyObject = function () {
-        var _this = this;
-        var prePandingValuesArray = Object.values(this.prePending);
-        return prePandingValuesArray.reduce(function (accum, test) {
-            var _a;
-            var ids = test.ids;
-            if (ids && ids.length > 0) {
-                var testsByIdArray = ids.map(function (id) {
-                    var _a;
-                    return ({
-                        case_id: Number(id),
-                        status: test.result,
-                        time_ms: test.duration,
-                        stacktrace: (_a = test.err) === null || _a === void 0 ? void 0 : _a.stack,
-                        comment: test.err ? test.err.message : '',
-                        defect: test.result === src_1.ResultCreateStatusEnum.FAILED,
-                    });
-                });
-                return __spreadArrays(accum, testsByIdArray);
-            }
-            else {
-                var testByIdArray = [
-                    {
-                        case: {
-                            title: test.name,
-                            suite_title: _this.options.rootSuiteTitle || 'Autocreated Root Suite',
-                        },
-                        status: test.result,
-                        time_ms: test.duration,
-                        stacktrace: (_a = test.err) === null || _a === void 0 ? void 0 : _a.stack,
-                        comment: test.err ? test.err.message : '',
-                        defect: test.result === src_1.ResultCreateStatusEnum.FAILED,
-                    },
-                ];
-                return __spreadArrays(accum, testByIdArray);
-            }
-        }, []);
-    };
-    return NewmanQaseReporter;
-}());
-var templateObject_1, templateObject_2, templateObject_3, templateObject_4, templateObject_5, templateObject_6, templateObject_7, templateObject_8, templateObject_9, templateObject_10, templateObject_11;
-module.exports = NewmanQaseReporter;
-//# sourceMappingURL=index.js.map
+const reporter_1 = require("./reporter");
+module.exports = reporter_1.NewmanQaseReporter;

package/dist/reporter.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { ConfigType, ConfigLoader } from 'qase-javascript-commons';
+export type NewmanQaseOptionsType = ConfigType;
+/**
+ * @class NewmanQaseReporter
+ */
+export declare class NewmanQaseReporter {
+    /**
+     * @type {RegExp}
+     */
+    static qaseIdRegExp: RegExp;
+    /**
+     * @param {EventList} eventList
+     * @returns {number[]}
+     * @private
+     */
+    private static getCaseIds;
+    /**
+     * @param {PropertyBase<PropertyBaseDefinition>} item
+     * @param {string[]} titles
+     * @returns {string[]}
+     * @private
+     */
+    private static getParentTitles;
+    /**
+     * @type {ReporterInterface}
+     * @private
+     */
+    private reporter;
+    /**
+     * @type {Map<string, TestResultType>}
+     * @private
+     */
+    private pendingResultMap;
+    /**
+     * @type {Map<string, number>}
+     * @private
+     */
+    private timerMap;
+    /**
+     * @param {EventEmitter} emitter
+     * @param {NewmanQaseOptionsType} options
+     * @param {unknown} _
+     * @param {ConfigLoaderInterface} configLoader
+     */
+    constructor(emitter: EventEmitter, options: NewmanQaseOptionsType, _: unknown, configLoader?: ConfigLoader<Partial<ConfigType> & Record<string, unknown>>);
+    /**
+     * @param {EventEmitter} runner
+     * @private
+     */
+    private addRunnerListeners;
+    /**
+     * @private
+     */
+    private preventExit;
+}