@wdio/browserstack-service 7.34.0 → 7.36.0

package/build/testOps/requestUtils.d.ts

@@ -0,0 +1,4 @@
+import type { UploadType } from '../types';
+export declare function uploadEventData(eventData: UploadType | Array<UploadType>, eventUrl?: string): Promise<void>;
+export declare function sendScreenshots(eventData: Array<UploadType>): Promise<void>;
+//# sourceMappingURL=requestUtils.d.ts.map

package/build/testOps/requestUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestUtils.d.ts","sourceRoot":"","sources":["../../src/testOps/requestUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAW1C,wBAAsB,eAAe,CAAE,SAAS,EAAE,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC,EAAE,QAAQ,GAAE,MAA4B,iBAkCvH;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,KAAK,CAAC,UAAU,CAAC,iBAE3D"}

package/build/testOps/requestUtils.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendScreenshots = exports.uploadEventData = void 0;
+const constants_1 = require("../constants");
+const bstackLogger_1 = require("../bstackLogger");
+const util_1 = require("../util");
+const got_1 = __importDefault(require("got"));
+async function uploadEventData(eventData, eventUrl = constants_1.DATA_EVENT_ENDPOINT) {
+    let logTag = 'BATCH_UPLOAD';
+    if (!Array.isArray(eventData)) {
+        logTag = (0, util_1.getLogTag)(eventData.event_type);
+    }
+    if (eventUrl === constants_1.DATA_SCREENSHOT_ENDPOINT) {
+        logTag = 'screenshot_upload';
+    }
+    if (!process.env[constants_1.TESTOPS_BUILD_COMPLETED_ENV]) {
+        throw new Error('Build start not completed yet');
+    }
+    if (!process.env[constants_1.TESTOPS_JWT_ENV]) {
+        bstackLogger_1.BStackLogger.debug(`[${logTag}] Missing Authentication Token/ Build ID`);
+        throw new Error('Token/buildID is undefined, build creation might have failed');
+    }
+    try {
+        const url = `${constants_1.DATA_ENDPOINT}/${eventUrl}`;
+        const data = await got_1.default.post(url, {
+            agent: util_1.DEFAULT_REQUEST_CONFIG.agent,
+            headers: {
+                ...util_1.DEFAULT_REQUEST_CONFIG.headers,
+                'Authorization': `Bearer ${process.env[constants_1.TESTOPS_JWT_ENV]}`
+            },
+            json: eventData
+        }).json();
+        bstackLogger_1.BStackLogger.debug(`[${logTag}] Success response: ${JSON.stringify(data)}`);
+    }
+    catch (error) {
+        bstackLogger_1.BStackLogger.debug(`[${logTag}] Failed. Error: ${error}`);
+        throw new Error('Request failed with exception: ' + error);
+    }
+}
+exports.uploadEventData = uploadEventData;
+function sendScreenshots(eventData) {
+    return uploadEventData(eventData, constants_1.DATA_SCREENSHOT_ENDPOINT);
+}
+exports.sendScreenshots = sendScreenshots;

package/build/testOps/testOpsConfig.d.ts

@@ -0,0 +1,11 @@
+declare class TestOpsConfig {
+    enabled: boolean;
+    manuallySet: boolean;
+    private static _instance;
+    buildStopped: boolean;
+    buildHashedId?: string;
+    static getInstance(...args: any[]): TestOpsConfig;
+    constructor(enabled?: boolean, manuallySet?: boolean);
+}
+export default TestOpsConfig;
+//# sourceMappingURL=testOpsConfig.d.ts.map

package/build/testOps/testOpsConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testOpsConfig.d.ts","sourceRoot":"","sources":["../../src/testOps/testOpsConfig.ts"],"names":[],"mappings":"AAAA,cAAM,aAAa;IAaJ,OAAO,EAAE,OAAO;IAChB,WAAW,EAAE,OAAO;IAb/B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAe;IAChC,YAAY,EAAE,OAAO,CAAQ;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAA;IAE7B,MAAM,CAAC,WAAW,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;gBAQtB,OAAO,GAAE,OAAc,EACvB,WAAW,GAAE,OAAe;CAI1C;AAED,eAAe,aAAa,CAAA"}

package/build/testOps/testOpsConfig.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TestOpsConfig {
+    static getInstance(...args) {
+        if (!this._instance) {
+            this._instance = new TestOpsConfig(...args);
+        }
+        return this._instance;
+    }
+    constructor(enabled = true, manuallySet = false) {
+        this.enabled = enabled;
+        this.manuallySet = manuallySet;
+        this.buildStopped = false;
+        TestOpsConfig._instance = this;
+    }
+}
+exports.default = TestOpsConfig;

package/build/testOps/usageStats.d.ts

@@ -0,0 +1,404 @@
+import FeatureStats from './featureStats';
+import FeatureUsage from './featureUsage';
+import type { TOUsageStats } from '../types';
+declare class UsageStats {
+    static instance: UsageStats;
+    testStartedStats: FeatureStats;
+    testFinishedStats: FeatureStats;
+    hookStartedStats: FeatureStats;
+    hookFinishedStats: FeatureStats;
+    cbtSessionStats: FeatureStats;
+    logStats: FeatureStats;
+    launchBuildUsage: FeatureUsage;
+    stopBuildUsage: FeatureUsage;
+    static getInstance(): UsageStats;
+    constructor();
+    add(usageStats: UsageStats): void;
+    getFormattedData(workersData: any[]): TOUsageStats;
+    addDataFromWorkers(workersData: any[]): void;
+    getEventsData(): {
+        buildEvents: {
+            started: {
+                isTriggered: boolean | undefined;
+                status: string | undefined;
+                error: string | undefined;
+            };
+            finished: {
+                isTriggered: boolean | undefined;
+                status: string | undefined;
+                error: string | undefined;
+            };
+        };
+        testEvents: {
+            triggeredCount: number;
+            sentCount: number;
+            failedCount: number;
+            started: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+            finished: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+        } | {
+            groups: Record<string, import("../types").FeatureStatsOverview>;
+            triggeredCount: number;
+            sentCount: number;
+            failedCount: number;
+            started: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+            finished: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+        } | {
+            started: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+            finished: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+        } | {
+            groups: Record<string, import("../types").FeatureStatsOverview>;
+            started: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+            finished: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+        };
+        hookEvents: {
+            triggeredCount: number;
+            sentCount: number;
+            failedCount: number;
+            started: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+            finished: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+        } | {
+            groups: Record<string, import("../types").FeatureStatsOverview>;
+            triggeredCount: number;
+            sentCount: number;
+            failedCount: number;
+            started: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+            finished: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+        } | {
+            started: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+            finished: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+        } | {
+            groups: Record<string, import("../types").FeatureStatsOverview>;
+            started: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+            finished: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+        };
+        logEvents: {
+            triggeredCount: number;
+            sentCount: number;
+            failedCount: number;
+        } | {
+            groups: Record<string, import("../types").FeatureStatsOverview>;
+            triggeredCount: number;
+            sentCount: number;
+            failedCount: number;
+        } | {
+            [x: string]: import("../types").FeatureStatsOverview;
+        } | {
+            groups: Record<string, import("../types").FeatureStatsOverview>;
+        };
+        cbtSessionEvents: {
+            triggeredCount: number;
+            sentCount: number;
+            failedCount: number;
+        } | {
+            groups: Record<string, import("../types").FeatureStatsOverview>;
+            triggeredCount: number;
+            sentCount: number;
+            failedCount: number;
+        } | {
+            [x: string]: import("../types").FeatureStatsOverview;
+        } | {
+            groups: Record<string, import("../types").FeatureStatsOverview>;
+        };
+    };
+    getDataToSave(): {
+        testEvents: {
+            started: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+            finished: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+        };
+        hookEvents: {
+            started: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+            finished: {
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+                triggeredCount: number;
+                sentCount: number;
+                failedCount: number;
+            } | {
+                [x: string]: import("../types").FeatureStatsOverview;
+            } | {
+                groups: Record<string, import("../types").FeatureStatsOverview>;
+            };
+        };
+        logEvents: {
+            triggeredCount: number;
+            sentCount: number;
+            failedCount: number;
+        } | {
+            groups: Record<string, import("../types").FeatureStatsOverview>;
+            triggeredCount: number;
+            sentCount: number;
+            failedCount: number;
+        } | {
+            [x: string]: import("../types").FeatureStatsOverview;
+        } | {
+            groups: Record<string, import("../types").FeatureStatsOverview>;
+        };
+        cbtSessionEvents: {
+            triggeredCount: number;
+            sentCount: number;
+            failedCount: number;
+        } | {
+            groups: Record<string, import("../types").FeatureStatsOverview>;
+            triggeredCount: number;
+            sentCount: number;
+            failedCount: number;
+        } | {
+            [x: string]: import("../types").FeatureStatsOverview;
+        } | {
+            groups: Record<string, import("../types").FeatureStatsOverview>;
+        };
+    };
+    static fromJSON(data: any): UsageStats;
+}
+export default UsageStats;
+//# sourceMappingURL=usageStats.d.ts.map

package/build/testOps/usageStats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usageStats.d.ts","sourceRoot":"","sources":["../../src/testOps/usageStats.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,gBAAgB,CAAA;AACzC,OAAO,YAAY,MAAM,gBAAgB,CAAA;AAGzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAE5C,cAAM,UAAU;IACZ,OAAc,QAAQ,EAAE,UAAU,CAAA;IAC3B,gBAAgB,EAAE,YAAY,CAAA;IAC9B,iBAAiB,EAAE,YAAY,CAAA;IAC/B,gBAAgB,EAAE,YAAY,CAAA;IAC9B,iBAAiB,EAAE,YAAY,CAAA;IAC/B,eAAe,EAAE,YAAY,CAAA;IAC7B,QAAQ,EAAE,YAAY,CAAA;IACtB,gBAAgB,EAAE,YAAY,CAAA;IAC9B,cAAc,EAAE,YAAY,CAAA;WAErB,WAAW,IAAI,UAAU;;IAkBhC,GAAG,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IASjC,gBAAgB,CAAC,WAAW,EAAE,GAAG,EAAE;IAsBnC,kBAAkB,CAAC,WAAW,EAAE,GAAG,EAAE;IAWrC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqBb,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAeN,QAAQ,CAAC,IAAI,EAAE,GAAG;CAUnC;AAED,eAAe,UAAU,CAAA"}

package/build/testOps/usageStats.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const featureStats_1 = __importDefault(require("./featureStats"));
+const featureUsage_1 = __importDefault(require("./featureUsage"));
+const bstackLogger_1 = require("../bstackLogger");
+const testOpsConfig_1 = __importDefault(require("./testOpsConfig"));
+class UsageStats {
+    static getInstance() {
+        if (!UsageStats.instance) {
+            UsageStats.instance = new UsageStats();
+        }
+        return UsageStats.instance;
+    }
+    constructor() {
+        this.testStartedStats = new featureStats_1.default();
+        this.testFinishedStats = new featureStats_1.default();
+        this.hookStartedStats = new featureStats_1.default();
+        this.hookFinishedStats = new featureStats_1.default();
+        this.cbtSessionStats = new featureStats_1.default();
+        this.logStats = new featureStats_1.default();
+        this.launchBuildUsage = new featureUsage_1.default();
+        this.stopBuildUsage = new featureUsage_1.default();
+    }
+    add(usageStats) {
+        this.testStartedStats.add(usageStats.testStartedStats);
+        this.testFinishedStats.add(usageStats.testFinishedStats);
+        this.hookStartedStats.add(usageStats.hookStartedStats);
+        this.hookFinishedStats.add(usageStats.hookFinishedStats);
+        this.cbtSessionStats.add(usageStats.cbtSessionStats);
+        this.logStats.add(usageStats.logStats);
+    }
+    getFormattedData(workersData) {
+        this.addDataFromWorkers(workersData);
+        const testOpsConfig = testOpsConfig_1.default.getInstance();
+        const usage = {
+            enabled: testOpsConfig.enabled,
+            manuallySet: testOpsConfig.manuallySet,
+            buildHashedId: testOpsConfig.buildHashedId
+        };
+        if (!usage.enabled) {
+            return usage;
+        }
+        try {
+            usage.events = this.getEventsData();
+        }
+        catch (e) {
+            bstackLogger_1.BStackLogger.debug('exception in getFormattedData: ' + e);
+        }
+        return usage;
+    }
+    addDataFromWorkers(workersData) {
+        workersData.map(workerData => {
+            try {
+                const usageStatsForWorker = UsageStats.fromJSON(workerData.usageStats);
+                this.add(usageStatsForWorker);
+            }
+            catch (e) {
+                bstackLogger_1.BStackLogger.debug('Exception in adding workerData: ' + e);
+            }
+        });
+    }
+    getEventsData() {
+        return {
+            buildEvents: {
+                started: this.launchBuildUsage.toJSON(),
+                finished: this.stopBuildUsage.toJSON()
+            },
+            testEvents: {
+                started: this.testStartedStats.toJSON(),
+                finished: this.testFinishedStats.toJSON({ omitGroups: true }),
+                ...this.testFinishedStats.toJSON({ onlyGroups: true })
+            },
+            hookEvents: {
+                started: this.hookStartedStats.toJSON(),
+                finished: this.hookFinishedStats.toJSON({ omitGroups: true }),
+                ...this.hookFinishedStats.toJSON({ onlyGroups: true })
+            },
+            logEvents: this.logStats.toJSON(),
+            cbtSessionEvents: this.cbtSessionStats.toJSON()
+        };
+    }
+    getDataToSave() {
+        return {
+            testEvents: {
+                started: this.testStartedStats.toJSON(),
+                finished: this.testFinishedStats.toJSON({ nestedGroups: true }),
+            },
+            hookEvents: {
+                started: this.hookStartedStats.toJSON(),
+                finished: this.hookFinishedStats.toJSON({ nestedGroups: true }),
+            },
+            logEvents: this.logStats.toJSON({ nestedGroups: true }),
+            cbtSessionEvents: this.cbtSessionStats.toJSON()
+        };
+    }
+    static fromJSON(data) {
+        const usageStats = new UsageStats();
+        usageStats.testStartedStats = featureStats_1.default.fromJSON(data.testEvents.started);
+        usageStats.testFinishedStats = featureStats_1.default.fromJSON(data.testEvents.finished);
+        usageStats.hookStartedStats = featureStats_1.default.fromJSON(data.hookEvents.started);
+        usageStats.hookFinishedStats = featureStats_1.default.fromJSON(data.hookEvents.finished);
+        usageStats.logStats = featureStats_1.default.fromJSON(data.logEvents);
+        usageStats.cbtSessionStats = featureStats_1.default.fromJSON(data.cbtSessionStats);
+        return usageStats;
+    }
+}
+exports.default = UsageStats;

package/build/types.d.ts

@@ -50,6 +50,21 @@ export interface BrowserstackConfig {
      * For e.g. buildName, projectName, BrowserStack access credentials, etc.
      */
     testObservabilityOptions?: TestObservabilityOptions;
+    /**
+     * Set this to true to enable BrowserStack Percy which will take screenshots
+     * and snapshots for your tests run on Browserstack
+     * @default false
+     */
+    percy?: boolean;
+    /**
+     * Accepts mode as a string to auto capture screenshots at different execution points
+     * Accepted values are auto, click, testcase, screenshot & manual
+     */
+    percyCaptureMode?: string;
+    /**
+     * Set the Percy related config options under this key.
+    */
+    percyOptions?: any;
     /**
     * Set this to true to enable BrowserStack Accessibility Automation which will
     * automically conduct accessibility testing on your pre-existing test builds
@@ -211,17 +226,23 @@ export interface UserConfig {
 export interface UploadType {
     event_type: string;
     hook_run?: TestData;
-    test_run?: TestData;
-    logs?: any[];
+    test_run?: TestData | CBTData;
+    logs?: LogData[];
 }
-export interface StdLog {
+export interface LogData {
     timestamp: string;
-    kind: string;
-    level?: string;
-    message?: string;
-    http_response?: any;
+    kind: 'TEST_LOG' | 'TEST_STEP' | 'HTTP' | 'TEST_SCREENSHOT';
     test_run_uuid?: string;
     hook_run_uuid?: string;
+    message?: string;
+    level?: string;
+    http_response?: any;
+}
+export interface StdLog extends LogData {
+    kind: 'TEST_LOG';
+}
+export interface ScreenshotLog extends LogData {
+    kind: 'TEST_SCREENSHOT';
 }
 export interface LaunchResponse {
     jwt: string;
@@ -267,5 +288,25 @@ interface StepData {
 interface Failure {
     backtrace: string[];
 }
+export interface FeatureStatsOverview {
+    triggeredCount: number;
+    sentCount: number;
+    failedCount: number;
+}
+export interface FeaturesUsageData {
+    isTriggered?: boolean;
+    status?: string;
+    error?: string;
+}
+export interface CBTData {
+    uuid: string;
+    integrations: IntegrationObject;
+}
+export interface TOUsageStats {
+    enabled: boolean;
+    manuallySet: boolean;
+    buildHashedId?: string;
+    events?: any;
+}
 export {};
 //# sourceMappingURL=types.d.ts.map