qase-javascript-commons 2.0.0-beta.0 → 2.0.0-beta.1

package/dist/config/config-loader-interface.d.ts

@@ -0,0 +1,4 @@
+import { ConfigType } from './config-type';
+export interface ConfigLoaderInterface<T extends Partial<ConfigType>> {
+    load(files: string[]): (T & ConfigType) | null;
+}

package/dist/config/config-loader-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/config-loader.d.ts

@@ -0,0 +1,10 @@
+import { JSONSchemaType } from 'ajv';
+import { ConfigLoaderInterface } from './config-loader-interface';
+import { ConfigType } from './config-type';
+export declare class ConfigLoader<T extends Partial<ConfigType> & Record<string, unknown>> implements ConfigLoaderInterface<T> {
+    private paths;
+    private validationSchema;
+    constructor(validationSchema?: JSONSchemaType<T>, paths?: string[]);
+    private read;
+    load(): (T & ConfigType) | null;
+}

package/dist/config/config-loader.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLoader = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const lodash_merge_1 = __importDefault(require("lodash.merge"));
+const qase_error_1 = require("../utils/qase-error");
+const validate_json_1 = require("../utils/validate-json");
+const config_validation_schema_1 = require("./config-validation-schema");
+class ConfigLoader {
+    constructor(validationSchema, paths = ['qase.config.json', '.qaserc']) {
+        this.paths = paths;
+        this.validationSchema = (0, lodash_merge_1.default)({}, config_validation_schema_1.configValidationSchema, validationSchema);
+    }
+    read() {
+        for (const path of this.paths) {
+            const filePath = (0, path_1.join)(process.cwd(), path);
+            try {
+                return (0, fs_1.readFileSync)(filePath, 'utf8');
+            }
+            catch (error) {
+                const isNotFound = error instanceof Error &&
+                    'code' in error &&
+                    (error.code === 'ENOENT' || error.code === 'EISDIR');
+                if (!isNotFound) {
+                    throw new qase_error_1.QaseError('Cannot read config file', { cause: error });
+                }
+            }
+        }
+        return null;
+    }
+    load() {
+        try {
+            const data = this.read();
+            if (data) {
+                const json = JSON.parse(data);
+                (0, validate_json_1.validateJson)(this.validationSchema, json);
+                return json;
+            }
+        }
+        catch (error) {
+            if (error instanceof validate_json_1.JsonValidationError) {
+                const [validationError] = error.validationErrors;
+                const { instancePath = '', message = '' } = validationError ?? {};
+                const configPath = instancePath
+                    ? `\`${instancePath.substring(1).replace('/', '.')}\``
+                    : 'it';
+                throw new Error(`Invalid config: "${configPath}" ${message}`);
+            }
+            throw error;
+        }
+        return null;
+    }
+}
+exports.ConfigLoader = ConfigLoader;

package/dist/config/config-type.d.ts

@@ -0,0 +1,2 @@
+import { OptionsType } from '../options';
+export type ConfigType = Omit<OptionsType, 'frameworkPackage' | 'frameworkName' | 'reporterName'>;

package/dist/config/config-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/config-validation-schema.d.ts

@@ -0,0 +1,6 @@
+import { JSONSchemaType } from 'ajv';
+import { ConfigType } from './config-type';
+/**
+ * @type {JSONSchemaType<ConfigType>}
+ */
+export declare const configValidationSchema: JSONSchemaType<ConfigType>;

package/dist/config/config-validation-schema.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configValidationSchema = void 0;
+const options_1 = require("../options");
+const writer_1 = require("../writer");
+/**
+ * @type {JSONSchemaType<ConfigType>}
+ */
+exports.configValidationSchema = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: [options_1.ModeEnum.report, options_1.ModeEnum.testops, options_1.ModeEnum.off],
+            nullable: true,
+        },
+        debug: {
+            type: 'boolean',
+            nullable: true,
+        },
+        environment: {
+            type: ['string', 'number'],
+            nullable: true,
+        },
+        testops: {
+            type: 'object',
+            nullable: true,
+            properties: {
+                api: {
+                    type: 'object',
+                    nullable: true,
+                    properties: {
+                        token: {
+                            type: 'string',
+                            nullable: true,
+                        },
+                        baseUrl: {
+                            type: 'string',
+                            nullable: true,
+                        },
+                        headers: {
+                            type: 'object',
+                            nullable: true,
+                            additionalProperties: false,
+                            patternProperties: {
+                                '^.*$': {
+                                    type: 'string',
+                                },
+                            },
+                        },
+                        retries: {
+                            type: 'number',
+                            nullable: true,
+                        },
+                        retryDelay: {
+                            type: 'number',
+                            nullable: true,
+                        },
+                    },
+                },
+                project: {
+                    type: 'string',
+                    nullable: true,
+                },
+                uploadAttachments: {
+                    type: 'boolean',
+                    nullable: true,
+                },
+                baseUrl: {
+                    type: 'string',
+                    nullable: true,
+                },
+                run: {
+                    type: 'object',
+                    nullable: true,
+                    properties: {
+                        id: {
+                            type: 'number',
+                            nullable: true,
+                        },
+                        title: {
+                            type: 'string',
+                            nullable: true,
+                        },
+                        description: {
+                            type: 'string',
+                            nullable: true,
+                        },
+                        complete: {
+                            type: 'boolean',
+                            nullable: true,
+                        },
+                        environment: {
+                            type: 'number',
+                            nullable: true,
+                        },
+                    },
+                },
+            },
+        },
+        report: {
+            type: 'object',
+            nullable: true,
+            properties: {
+                driver: {
+                    type: 'string',
+                    enum: [writer_1.DriverEnum.local],
+                    nullable: true,
+                },
+                connections: {
+                    type: 'object',
+                    nullable: true,
+                    properties: {
+                        [writer_1.DriverEnum.local]: {
+                            type: 'object',
+                            nullable: true,
+                            properties: {
+                                path: {
+                                    type: 'string',
+                                    nullable: true,
+                                },
+                                ext: {
+                                    type: 'string',
+                                    nullable: true,
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};

package/dist/config/index.d.ts

@@ -0,0 +1,4 @@
+export { type ConfigType } from './config-type';
+export { configValidationSchema } from './config-validation-schema';
+export { type ConfigLoaderInterface } from './config-loader-interface';
+export { ConfigLoader } from './config-loader';

package/dist/config/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLoader = exports.configValidationSchema = void 0;
+var config_validation_schema_1 = require("./config-validation-schema");
+Object.defineProperty(exports, "configValidationSchema", { enumerable: true, get: function () { return config_validation_schema_1.configValidationSchema; } });
+var config_loader_1 = require("./config-loader");
+Object.defineProperty(exports, "ConfigLoader", { enumerable: true, get: function () { return config_loader_1.ConfigLoader; } });

package/dist/env/env-enum.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @enum {string}
+ */
+export declare enum EnvEnum {
+    mode = "QASE_MODE",
+    debug = "QASE_DEBUG",
+    environment = "QASE_ENVIRONMENT"
+}
+/**
+ * @enum {string}
+ */
+export declare enum EnvTestOpsEnum {
+    project = "QASE_TESTOPS_PROJECT",
+    baseUrl = "QASE_TESTOPS_BASE_URL",
+    uploadAttachments = "QASE_TESTOPS_UPLOAD_ATTACHMENTS"
+}
+/**
+ * @enum {string}
+ */
+export declare enum EnvApiEnum {
+    token = "QASE_TESTOPS_API_TOKEN",
+    baseUrl = "QASE_TESTOPS_API_BASE_URL"
+}
+/**
+ * @enum {string}
+ */
+export declare enum EnvRunEnum {
+    id = "QASE_TESTOPS_RUN_ID",
+    title = "QASE_TESTOPS_RUN_TITLE",
+    description = "QASE_TESTOPS_RUN_DESCRIPTION",
+    complete = "QASE_TESTOPS_RUN_COMPLETE",
+    environment = "QASE_TESTOPS_ENVIRONMENT"
+}
+/**
+ * @enum {string}
+ */
+export declare enum EnvLocalEnum {
+    path = "QASE_REPORT_CONNECTIONS_LOCAL_PATH",
+    ext = "QASE_REPORT_CONNECTIONS_LOCAL_EXT"
+}

package/dist/env/env-enum.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvLocalEnum = exports.EnvRunEnum = exports.EnvApiEnum = exports.EnvTestOpsEnum = exports.EnvEnum = void 0;
+/**
+ * @enum {string}
+ */
+var EnvEnum;
+(function (EnvEnum) {
+    EnvEnum["mode"] = "QASE_MODE";
+    EnvEnum["debug"] = "QASE_DEBUG";
+    EnvEnum["environment"] = "QASE_ENVIRONMENT";
+})(EnvEnum || (exports.EnvEnum = EnvEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvTestOpsEnum;
+(function (EnvTestOpsEnum) {
+    EnvTestOpsEnum["project"] = "QASE_TESTOPS_PROJECT";
+    EnvTestOpsEnum["baseUrl"] = "QASE_TESTOPS_BASE_URL";
+    EnvTestOpsEnum["uploadAttachments"] = "QASE_TESTOPS_UPLOAD_ATTACHMENTS";
+})(EnvTestOpsEnum || (exports.EnvTestOpsEnum = EnvTestOpsEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvApiEnum;
+(function (EnvApiEnum) {
+    EnvApiEnum["token"] = "QASE_TESTOPS_API_TOKEN";
+    EnvApiEnum["baseUrl"] = "QASE_TESTOPS_API_BASE_URL";
+})(EnvApiEnum || (exports.EnvApiEnum = EnvApiEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvRunEnum;
+(function (EnvRunEnum) {
+    EnvRunEnum["id"] = "QASE_TESTOPS_RUN_ID";
+    EnvRunEnum["title"] = "QASE_TESTOPS_RUN_TITLE";
+    EnvRunEnum["description"] = "QASE_TESTOPS_RUN_DESCRIPTION";
+    EnvRunEnum["complete"] = "QASE_TESTOPS_RUN_COMPLETE";
+    EnvRunEnum["environment"] = "QASE_TESTOPS_ENVIRONMENT";
+})(EnvRunEnum || (exports.EnvRunEnum = EnvRunEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvLocalEnum;
+(function (EnvLocalEnum) {
+    EnvLocalEnum["path"] = "QASE_REPORT_CONNECTIONS_LOCAL_PATH";
+    EnvLocalEnum["ext"] = "QASE_REPORT_CONNECTIONS_LOCAL_EXT";
+})(EnvLocalEnum || (exports.EnvLocalEnum = EnvLocalEnum = {}));

package/dist/env/env-to-config.d.ts

@@ -0,0 +1,7 @@
+import { EnvType } from './env-type';
+import { ConfigType } from '../config';
+/**
+ * @param {EnvType} env
+ * @returns {ConfigType}
+ */
+export declare const envToConfig: (env: EnvType) => ConfigType;

package/dist/env/env-to-config.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envToConfig = void 0;
+const env_enum_1 = require("./env-enum");
+const writer_1 = require("../writer");
+/**
+ * @param {EnvType} env
+ * @returns {ConfigType}
+ */
+const envToConfig = (env) => ({
+    mode: env[env_enum_1.EnvEnum.mode],
+    debug: env[env_enum_1.EnvEnum.debug],
+    environment: env[env_enum_1.EnvEnum.environment],
+    testops: {
+        project: env[env_enum_1.EnvTestOpsEnum.project],
+        baseUrl: env[env_enum_1.EnvTestOpsEnum.baseUrl],
+        uploadAttachments: env[env_enum_1.EnvTestOpsEnum.uploadAttachments],
+        api: {
+            token: env[env_enum_1.EnvApiEnum.token],
+            baseUrl: env[env_enum_1.EnvApiEnum.baseUrl],
+        },
+        run: {
+            id: env[env_enum_1.EnvRunEnum.id],
+            title: env[env_enum_1.EnvRunEnum.title],
+            description: env[env_enum_1.EnvRunEnum.description],
+            complete: env[env_enum_1.EnvRunEnum.complete],
+            environment: env[env_enum_1.EnvRunEnum.environment],
+        },
+    },
+    report: {
+        connections: {
+            [writer_1.DriverEnum.local]: {
+                path: env[env_enum_1.EnvLocalEnum.path],
+                ext: env[env_enum_1.EnvLocalEnum.ext],
+            },
+        },
+    },
+});
+exports.envToConfig = envToConfig;

package/dist/env/env-type.d.ts

@@ -0,0 +1,19 @@
+import { EnvEnum, EnvTestOpsEnum, EnvApiEnum, EnvRunEnum, EnvLocalEnum } from './env-enum';
+import { ModeEnum } from '../options';
+export type EnvType = {
+    [EnvEnum.mode]?: `${ModeEnum}`;
+    [EnvEnum.debug]?: boolean;
+    [EnvEnum.environment]?: string | number;
+    [EnvTestOpsEnum.project]?: string;
+    [EnvTestOpsEnum.baseUrl]?: string;
+    [EnvTestOpsEnum.uploadAttachments]?: boolean;
+    [EnvApiEnum.token]?: string;
+    [EnvApiEnum.baseUrl]?: string;
+    [EnvRunEnum.id]?: number;
+    [EnvRunEnum.title]?: string;
+    [EnvRunEnum.description]?: string;
+    [EnvRunEnum.complete]?: boolean;
+    [EnvRunEnum.environment]?: number;
+    [EnvLocalEnum.path]?: string;
+    [EnvLocalEnum.ext]?: string;
+};

package/dist/env/env-type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const env_enum_1 = require("./env-enum");

package/dist/env/env-validation-schema.d.ts

@@ -0,0 +1,6 @@
+import { JSONSchemaType } from 'env-schema';
+import { EnvType } from './env-type';
+/**
+ * @type {JSONSchemaType<EnvType>}
+ */
+export declare const envValidationSchema: JSONSchemaType<EnvType>;

package/dist/env/env-validation-schema.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envValidationSchema = void 0;
+const env_enum_1 = require("./env-enum");
+const options_1 = require("../options");
+/**
+ * @type {JSONSchemaType<EnvType>}
+ */
+exports.envValidationSchema = {
+    type: 'object',
+    properties: {
+        [env_enum_1.EnvEnum.mode]: {
+            type: 'string',
+            enum: [options_1.ModeEnum.report, options_1.ModeEnum.testops, options_1.ModeEnum.off],
+            nullable: true,
+        },
+        [env_enum_1.EnvEnum.debug]: {
+            type: 'boolean',
+            nullable: true,
+        },
+        [env_enum_1.EnvEnum.environment]: {
+            type: ['string', 'number'],
+            nullable: true,
+        },
+        [env_enum_1.EnvTestOpsEnum.project]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvTestOpsEnum.uploadAttachments]: {
+            type: 'boolean',
+            nullable: true,
+        },
+        [env_enum_1.EnvTestOpsEnum.baseUrl]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvApiEnum.token]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvApiEnum.baseUrl]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvRunEnum.id]: {
+            type: 'number',
+            nullable: true,
+        },
+        [env_enum_1.EnvRunEnum.title]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvRunEnum.description]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvRunEnum.complete]: {
+            type: 'boolean',
+            nullable: true,
+        },
+        [env_enum_1.EnvRunEnum.environment]: {
+            type: 'number',
+            nullable: true,
+        },
+        [env_enum_1.EnvLocalEnum.path]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvLocalEnum.ext]: {
+            type: 'string',
+            nullable: true,
+        },
+    },
+};

package/dist/env/index.d.ts

@@ -0,0 +1,4 @@
+export { EnvEnum, EnvTestOpsEnum, EnvApiEnum, EnvRunEnum, EnvLocalEnum, } from './env-enum';
+export { type EnvType } from './env-type';
+export { envValidationSchema } from './env-validation-schema';
+export { envToConfig } from './env-to-config';

package/dist/env/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envToConfig = exports.envValidationSchema = exports.EnvLocalEnum = exports.EnvRunEnum = exports.EnvApiEnum = exports.EnvTestOpsEnum = exports.EnvEnum = void 0;
+var env_enum_1 = require("./env-enum");
+Object.defineProperty(exports, "EnvEnum", { enumerable: true, get: function () { return env_enum_1.EnvEnum; } });
+Object.defineProperty(exports, "EnvTestOpsEnum", { enumerable: true, get: function () { return env_enum_1.EnvTestOpsEnum; } });
+Object.defineProperty(exports, "EnvApiEnum", { enumerable: true, get: function () { return env_enum_1.EnvApiEnum; } });
+Object.defineProperty(exports, "EnvRunEnum", { enumerable: true, get: function () { return env_enum_1.EnvRunEnum; } });
+Object.defineProperty(exports, "EnvLocalEnum", { enumerable: true, get: function () { return env_enum_1.EnvLocalEnum; } });
+var env_validation_schema_1 = require("./env-validation-schema");
+Object.defineProperty(exports, "envValidationSchema", { enumerable: true, get: function () { return env_validation_schema_1.envValidationSchema; } });
+var env_to_config_1 = require("./env-to-config");
+Object.defineProperty(exports, "envToConfig", { enumerable: true, get: function () { return env_to_config_1.envToConfig; } });

package/dist/formatter/formatter-interface.d.ts

@@ -0,0 +1,3 @@
+export interface FormatterInterface {
+    format(result: unknown): Promise<string>;
+}

package/dist/formatter/formatter-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/formatter/index.d.ts

@@ -0,0 +1,2 @@
+export { type FormatterInterface } from './formatter-interface';
+export { JsonFormatter } from './json-formatter';

package/dist/formatter/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFormatter = void 0;
+var json_formatter_1 = require("./json-formatter");
+Object.defineProperty(exports, "JsonFormatter", { enumerable: true, get: function () { return json_formatter_1.JsonFormatter; } });

package/dist/formatter/json-formatter.d.ts

@@ -0,0 +1,13 @@
+import { FormatterInterface } from './formatter-interface';
+export type JsonFormatterOptionsType = {
+    space?: number | undefined;
+};
+/**
+ * @class JsonFormatter
+ * @implements FormatterInterface
+ */
+export declare class JsonFormatter implements FormatterInterface {
+    private space;
+    constructor(options?: JsonFormatterOptionsType);
+    format(object: unknown): Promise<string>;
+}

package/dist/formatter/json-formatter.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFormatter = void 0;
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+/**
+ * @class JsonFormatter
+ * @implements FormatterInterface
+ */
+class JsonFormatter {
+    constructor(options = {}) {
+        const { space = 4 } = options;
+        this.space = space;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async format(object) {
+        return JSON.stringify(object, (key, value) => {
+            if (key === 'error' && value instanceof Error) {
+                return (0, strip_ansi_1.default)(String(value));
+            }
+            return value;
+        }, this.space);
+    }
+}
+exports.JsonFormatter = JsonFormatter;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './qase';
+export * from './config';
+export * from './env';
+export * from './formatter';
+export * from './models';
+export * from './options';
+export * from './reporters';
+export * from './writer';
+export * from './utils/get-package-version';

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./qase"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./env"), exports);
+__exportStar(require("./formatter"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./options"), exports);
+__exportStar(require("./reporters"), exports);
+__exportStar(require("./writer"), exports);
+__exportStar(require("./utils/get-package-version"), exports);

package/dist/models/index.d.ts

@@ -0,0 +1,2 @@
+export { type TestResultType, TestStatusEnum as TestStatusEnum, } from './test-result';
+export { type TestStepType, StepStatusEnum } from './test-step';

package/dist/models/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepStatusEnum = exports.TestStatusEnum = void 0;
+var test_result_1 = require("./test-result");
+Object.defineProperty(exports, "TestStatusEnum", { enumerable: true, get: function () { return test_result_1.TestStatusEnum; } });
+var test_step_1 = require("./test-step");
+Object.defineProperty(exports, "StepStatusEnum", { enumerable: true, get: function () { return test_step_1.StepStatusEnum; } });

package/dist/models/test-result.d.ts

@@ -0,0 +1,25 @@
+import { TestStepType } from './test-step';
+/**
+ * @enum {string}
+ */
+export declare enum TestStatusEnum {
+    passed = "passed",
+    failed = "failed",
+    skipped = "skipped",
+    disabled = "disabled",
+    blocked = "blocked",
+    invalid = "invalid"
+}
+export type TestResultType = {
+    id: string;
+    testOpsId: number[];
+    title: string;
+    status: `${TestStatusEnum}`;
+    suiteTitle?: string | string[] | undefined;
+    error?: Error | undefined;
+    startTime?: number | undefined;
+    duration?: number | undefined;
+    endTime?: number | undefined;
+    steps?: TestStepType[] | undefined;
+    attachments?: string[] | undefined;
+};