@mablhq/playwright-tools 2.49.1

package/Globals.js

@@ -0,0 +1,69 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Globals = void 0;
+const os = __importStar(require("os"));
+class Globals {
+    static getFindOverallTimeoutMs() {
+        return Globals.findOverallTimeoutMs;
+    }
+    static setFindOverallTimeoutMs(timeout) {
+        Globals.findOverallTimeoutMs = timeout;
+    }
+    static getPlaywrightInteractionWarningMs() {
+        return Globals.playwrightInteractionWarningMs;
+    }
+    static setPlaywrightInteractionWarningMs(timeout) {
+        Globals.playwrightInteractionWarningMs = timeout;
+    }
+    static getSslCaDir() {
+        return Globals.sslCaDir;
+    }
+    static getTestMaxAgeMs() {
+        return Globals.testMaxAgeMs;
+    }
+    static setTestMaxAgeMs(age) {
+        Globals.testMaxAgeMs = age;
+    }
+    static getUploadDirectory() {
+        return Globals.uploadDirectory;
+    }
+    static setUploadDirectory(dir) {
+        Globals.uploadDirectory = dir;
+    }
+    static getUploadDirectoryPrefix() {
+        return Globals.uploadDirectoryPrefix;
+    }
+    static setUploadDirectoryPrefix(prefix) {
+        Globals.uploadDirectoryPrefix = prefix;
+    }
+}
+exports.Globals = Globals;
+Globals.findOverallTimeoutMs = 18.5 * 60 * 1000;
+Globals.playwrightInteractionWarningMs = 30 * 1000;
+Globals.sslCaDir = '/usr/local/share/http-proxy-certs';
+Globals.testMaxAgeMs = 1000 * 60 * 60 * 24;
+Globals.uploadDirectory = os.tmpdir();
+Globals.uploadDirectoryPrefix = `mablTestRunUploads-`;

package/LICENSE.txt

@@ -0,0 +1,29 @@
+LICENSE AGREEMENT
+
+
+PLEASE READ THE TERMS OF THIS LICENSE AGREEMENT (“AGREEMENT”) CAREFULLY AS BY INSTALLING, ACCESSING AND/OR USING THE TOOL (AS DEFINED BELOW), YOU EXPRESSLY ACKNOWLEDGE AND AGREE THAT YOU, OR THE COMPANY YOU REPRESENT, (“YOU” OR “LICENSEE”) ARE ENTERING INTO A LEGAL AGREEMENT WITH mabl Inc. (“mabl”), AND UNDERSTAND AND AGREE TO COMPLY WITH, AND BE LEGALLY BOUND BY, THE TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU ARE ENTERING INTO THIS AGREEMENT ON BEHALF OF AN ENTITY, YOU REPRESENT AND WARRANT THAT THAT YOU HAVE THE LEGAL AUTHORITY TO BIND THAT ENTITY TO THIS AGREEMENT. TO THE EXTENT PERMITTED UNDER APPLICABLE LAW, YOU HEREBY WAIVE ANY FORMALITIES UNDER ANY APPLICABLE LAW OR REGULATION IN ANY JURISDICTION REQUIRING AN EXCHANGE OF ORIGINAL (NON-ELECTRONIC) SIGNATURES FOR THE EXECUTION OF A VALID AND ENFORCEABLE CONTRACT.
+BACKGROUND
+	mabl has developed a software tool, and mabl wishes to license the tool in object code form (the “Tool”) to Licensee, and Licensee wishes to license the Tool from mabl to develop an interface for its products to mabl’s products.  mabl is willing to license the Tool to Licensee subject to the terms and conditions of this Agreement.
+
+	For the purposes of this Agreement, the term “Tool” shall include all (i) new versions, updates, revisions, enhancements, and other derivative works of the Tool; and (ii) all related documentation including user guides and technical manuals (“Documentation”), made available or delivered by mabl to Licensee, if any.
+	Therefore, the parties agree as follows:
+1.	No Fee.
+	There is no fee to Licensee for the license granted under this Agreement.
+2.	Ownership, Grant of License.
+	(a)  Ownership.  mabl is and shall remain the exclusive owner or licensee of the Tool and all copies thereof, and of all patent, copyright, trademark, trade secret, and other intellectual property rights therein.  Licensee shall not acquire any rights to the Tool other than those specified in this Agreement
+	(b)  Grant of License.  Subject to the terms of this Agreement, mabl hereby grants to Licensee a non-exclusive, non-transferable, revocable, and royalty-free, license (without the right to sublicense) to use the Tool only for the limited purpose of developing an interface for Licensee’s products to interoperate with mabl’s products.
+	(c) Reservation of Rights, Use Restrictions. Other than the rights explicitly granted in this Agreement, Licensee shall have no other rights, express or implied, in the Tool. Without limiting the foregoing, Licensee shall not (i) modify, adapt or create derivative works of the Tool,  (ii) distribute, sell, transfer, rent, lease, or loan the Tool to any third party, (iii) reverse engineer, decompile, or disassemble the Tool or otherwise take any action to reduce the Tool’s code to human-perceivable form or determine the Tool’s source code, (iv) copy or allow copies of the Tool to be made, (v) remove, alter or obscure any proprietary notice or identification, including copyright, trademark, patent or other notices, contained in or displayed on or via the Tool, and (vi) use the Tool to violate any applicable laws, rules or regulations.
+	(d)  Copying.  Notwithstanding any terms to the contrary in this Agreement, Licensee may make one (1) copy of the Tool for backup or archival purposes.
+	(e)  Nondisclosure.  Licensee shall not disclose, publish, or disseminate to any third party any non-public information or trade secrets regarding, or related to, the Tool or mabl disclosed by mabl to Licensee under this Agreement (collectively, “Confidential Information”). Licensee will take all necessary precautions to prevent any unauthorized use, disclosure, publication, or dissemination of Confidential information. Licensee shall use Confidential Information only for the purpose for which it was disclosed and shall not otherwise use or exploit the Confidential Information and/or Tool for its own benefit or the benefit of another without the prior written consent of mabl.  Licensee shall allow access to the Confidential Information only to those employees and representatives who have the need to access it for the limited purpose set forth herein, and shall take appropriate action by written agreement with its employees and representatives to satisfy its obligations hereunder.
+
+	(f)  Equitable Relief.  Licensee acknowledges that a violation of this Section 2 would cause irreparable harm to mabl.  Accordingly, Licensee agrees that mabl shall, without limiting its other rights or remedies, have the right to seek and obtain immediate injunctive relief to enforce Licensee’s obligations under this Agreement without posting bond or offering proof of damages.
+3.	Disclaimer of Warranty.  THE TOOL IS PROVIDED “AS IS” WITHOUT WARRANTY OF ANY KIND.  mabl HEREBY DISCLAIMS ALL WARRANTIES, WHETHER EXPRESS OR IMPLIED, WRITTEN OR ORAL, STATUTORY OR OTHERWISE, WITH REGARD TO THE TOOL, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OF NONINFRINGEMENT, MERCHANTABILITY, TITLE OR FITNESS FOR A PARTICULAR PURPOSE.  LICENSEE SHALL BEAR ALL RISKS IN UTILIZING THE TOOL AS PROVIDED HEREUNDER.
+4.	Limitation of Liability.  IN NO EVENT SHALL mabl HAVE ANY OBLIGATION OR LIABILITY TO LICENSEE OR ANY THIRD PARTY FOR DAMAGES, LOSSES, COSTS OR EXPENSES OF ANY TYPE OR NATURE, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING OUT OF OR RELATING TO THIS AGREEMENT OR THE TOOL, OR IN CONNECTION WITH USE OF THE TOOL.  WITHOUT LIMITING THE FOREGOING, IN NO EVENT SHALL MABL BE LIABLE FOR INDIRECT, INCIDENTAL, SPECIAL, DIRECT OR CONSEQUENTIAL DAMAGES, INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOST PROFITS, LOSS OF DATA OR INABILITY TO USE THE TOOL, EVEN IF MABL WAS AWARE OF OR WAS NOTIFIED OF THE POSSIBILITY OF SUCH DAMAGES.
+5.	Maintenance.  mabl shall have no obligation to maintain or support the Tool.
+6.	Term and Termination.
+	(a)  Term.  The initial term of this Agreement shall be for a period of one (1) year from the date entered into by Licensee’s installation, access or use of the Tool, subject to earlier termination as provided for in this Section.  Thereafter, this Agreement shall automatically renew for successive one (1) year renewal terms unless earlier terminated by a party.
+	(b)  Termination.  mabl may immediately terminate this Agreement and the license to the Tool at any time for any or no reason, and without notice. Licensee may terminate this Agreement at any time by removing the Tool from their system and destroying all copies of the Tool and Documentation. Licensee’s unauthorized copying of the Tool or Documentation or disclosure of Confidential Information, or failure to otherwise comply with this Agreement will result in automatic immediate termination of this Agreement and the license to the Tool, and will make available to mabl legal remedies.
+	(c)  Effect of Termination.  Following termination of this Agreement for any reason, the license granted hereunder will immediately terminate, and Licensee will(i) promptly cease use of the Tool and/or Documentation, and (ii) remove the Tool from all hard drives, networks and other storage media and destroy all copies of the Tool, Documentation and/or Confidential Information in Licensee’s possession or under Licensee’s control.
+	(d)  Survival.  The terms of Sections 2(a), 2(c), 2(e), 2(f), and 3-7 shall survive any termination of this Agreement.
+7.	General.
+This Agreement constitutes the entire agreement between the parties and supersedes all prior statements and undertakings with respect to the subject matter.  All modifications to this Agreement shall be in writing and signed by an authorized representative of each party. The headings in this Agreement are for convenience only and shall not be used in the interpreting this Agreement.  Any failure by either party to enforce strict performance by the other of any provision herein shall not constitute a waiver of the right to subsequently enforce such provision or any other provision of this Agreement. Licensee may not assign its rights or delegate its obligations hereunder, either in whole or in part, whether by operation of law or otherwise, without the prior written consent of mabl.  The rights and liabilities of the parties under this Agreement will bind and inure to the benefit of the parties' respective successors and permitted assigns.  This Agreement shall be governed by and construed in accordance with the laws of the Commonwealth of Massachusetts, excluding its conflict of law principles.

package/README.md

@@ -0,0 +1,219 @@
+# mabl Playwright Tools
+
+## Introduction
+
+Leverage the power of the mabl cloud from within their own Playwright tests. By using mabl playwright tools, developers can easily introduce advanced test functionality such as email, database, generative AI testing, and more.
+
+### Email testing
+
+Mabl playwright tools gives developers the ability to create and use temporary emails as well as long-lived emails for use within their Playwright tests. With these abilities, developers are able to create full end-to-end functional tests that validate sign-up and login functionality without the overhead of managing their own email servers and accounts. 
+
+### Generative AI testing
+
+With the generative AI testing functionality of mabl playwright tools, developers can easily leverage the power of AI to do more complex validations of their test environments without complex test code. Using the tools, developers can implement complex assertions in their tests that validate images, analyze text (translations, tone, sorting, etc), validate chatbot interactions, and a whole lot more.
+
+### Multi-factor authentication and credentials testing
+
+Mabl playwright tools allows developers to create functional end-to-end tests that rely on securely stored and managed passwords in the mabl cloud. With these tools, developers have a central place to manage credentials securely outside their codebase and leverage more sophisticated login flows that require generating two-factor authentication codes to complete a login. This functionality also works alongside the email testing tools for cases where login flows require opening emails to extract MFA codes or follow login links.
+
+### Database testing
+
+Mabl’s database connectivity tool gives developers secure access to test databases connected to the mabl cloud, allowing them to manage test environment DB state as well as validate it all without having to install database drivers and manage test environment networking. Developers can write setup and teardown code from within their Playwright tests that ensure the database state is correct for executing tests. They can also assert during their tests that the correct state has been updated as expected, offering more depth to the validations their Playwright tests are capable of.
+
+### PDF Testing
+
+Mabl playwright tools allows developers to load PDF documents downloaded during test execution into a Playwright tab as testable HTML. This allows for Playwright tests to not only validate the PDF downloaded but also validate the contents of the document are what is expected.
+
+## Quickstart
+
+### Before you begin
+
+- Sign up or log in to your mabl workspace
+- Create an API key to use in your test suite
+  - Navigate to Settings > APIs and click “Create API key”
+  - Select “Command Line Interface” as the key option, give it a name, and click “Save”
+
+### Prerequisites
+
+To leverage mabl playwright tools, you will need a developer environment with:
+- NodeJS >= 18.0.0
+- Playwright test suite
+
+### Installing mabl playwright tools
+
+```
+npm install @mablhq/playwright-tools
+```
+
+### Using the mabl tools
+
+You can set up mabl playwright tools inside your Playwright Test Fixtures for use across the entire test suite by importing and calling the `createMablFixtures` function inside the Playwright `extend` function.
+
+```typescript
+import {test as base} from '@playwright/test';
+
+// Import the initialization function for mabl playwright tools
+import {createMablFixtures, MablFixtures} from '@mablhq/playwright-tools';
+
+// For TypeScript you can include the MablFixtures typing when extending
+export const test = base.extend<MablFixtures>({
+
+  // existing fixture configuration can remain in place
+
+  // this function will generate all the mabl Fixtures and configure them to use the supplied API key 
+  ...createMablFixtures({
+    apiKey: process.env.MABL_PLAYWRIGHT_TESTS_KEY,
+    test: base,
+  }),
+});
+
+export {expect} from '@playwright/test';
+```
+
+With the fixtures configured, you will now have access to the mabl object inside your test cases, which allows you to access any of the mabl tools.
+
+## Examples
+
+### Email testing
+
+```typescript
+import {SandboxPage} from '../utils/SandboxPage';
+import {expect, test} from '../utils/fixtures';
+
+test('Validate emails can be received using mabl sandbox app', async ({
+  page,
+  mabl,
+}) => {
+  await page.goto('https://sandbox.mabl.com');
+  const sandbox = new SandboxPage(page);
+  sandbox.maybeWaitForReady();
+  const mailboxPage = await sandbox.goToMailboxPage();
+  // Create a temporary mailbox for the test case using the mabl tools
+  const emailAddress = await mabl.createMailBoxAddress();
+  const subject = 'Test email';
+  const body = 'This is a test email';
+  // This uses the email as a destination address inside the test case 
+  await mailboxPage.fillOutAndSendEmail(emailAddress, subject, body);
+
+  // Leverage the mabl Tooset to wait for an email to appear in the temporary mailbox generated earlier in the test.
+  const mablEmail = await mabl.waitForEmail(emailAddress, page, {subject});
+  // Open the email in the supplied Playwright Page
+  await mablEmail.open();
+
+  // The mabl tools returns a MablMailboxEmail object that allows for easy access to all the received email attributes for faster validation 
+  expect(await mablEmail.getToAddress()).toBe(emailAddress);
+  expect(await mablEmail.getSubject()).toBe(subject);
+  expect(await mablEmail.getBodyText()).toBe(body);
+  expect(await mablEmail.getFromAddress()).toBe('test_mailer@m.mablmail.com');
+});
+```
+
+### Generative AI testing
+
+```typescript
+import {expect, test} from '../utils/fixtures';
+
+test('Evaluate a GenAI assertion to validate the state of a page', async ({
+  page,
+  mabl,
+}) => {
+  await page.goto('https://www.mabl.com');
+  // Create a prompt to supply to the Gen AI tool
+  const prompt =
+    'Please validate that the web page you are looking at is a marketing page for a company named mabl which does automated UI testing. Also validate that there are no broken images on the page';
+
+  // Supply the Playwright Page to the evaluate function so mabl can extract a screenshot and other information to use with the prompt 
+  const result = await mabl.evaluateGenAiAssertion(page, prompt);
+  
+  // The result returned includes both a success (true/false) attribute as well as an explanation for the evaluation
+  console.log(`GEN AI EXPLANATION: [${result.explanation}]`);
+  expect(result.success).toBe(true);
+});
+```
+
+### Database testing
+
+```typescript
+import {expect, test} from '../utils/fixtures';
+
+// Database connection ID from your mabl workspace
+const MABL_DATABASE_CONNECTION = 'grm9yi7lFN36WMjCQ4K2jg-dc';
+
+test('Evaluate a mabl database query', async ({page, mabl}) => {
+  const dbQuery = 'SELECT * from pets LIMIT 15';
+  const result = await mabl.executeQuery(MABL_DATABASE_CONNECTION, dbQuery, []);
+  expect(result.metadata?.status).toBe('success');
+  expect(result.columns?.length).toEqual(5);
+  expect(result.rows?.length).toEqual(15);
+});
+```
+
+### PDF testing
+
+```typescript
+test('Validate PDFs downloaded from the app', async ({
+  browser,
+  page,
+  mabl,
+}) => {
+  await page.goto('https://sandbox.mabl.com');
+  await page.locator("a:has-text('downloads and pdfs')");
+
+  // get ready for the download
+  const downloadPromise = page.waitForEvent('download');
+
+  // click to download PDF
+  await page.locator("a:has-text('download pdf')").click(); 
+
+  // wait for download to complete
+  const download = await downloadPromise;
+  const pdfPath = await download.path();
+
+  // create a Page for the downloaded PDF to open in
+  const pageForPdf = await browser.newPage();
+
+  // use the mabl tools to open the file in a new Page 
+  await mabl.openPdfFile(pdfPath, pageForPdf);
+
+  // validate the contents of the PDF
+  const element = pageForPdf.locator('text=Journey run export');
+  expect(await element.isVisible()).toBeTruthy();
+});
+```
+
+### Multi-factor Authentication and credentials testing
+
+You will need the IDs for any credentials you’d like to use in your tests. These can be found in the mabl app by going to Configuration > Credentials and clicking on the credential you’d like to use. The View mabl CLI IDs utility can be found in the upper left of the credentials details UI.
+
+You can also use the mabl CLI from your terminal to list the credentials and their IDs using the command $ mabl credentials list 
+
+```typescript
+import {expect, test} from '../utils/fixtures';
+import {SandboxPage} from '../utils/SandboxPage';
+
+// This is the ID of the mabl credentials to use in a test
+const MFA_CREDENTIALS_ID = 'L7HamCgVXVY4UbelLPTRzA-c';
+
+test('Validate that we can get an MFA token from mabl', async ({
+  page,
+  mabl,
+}) => {
+  await page.goto('https://sandbox.mabl.com');
+  const mfaToken = await mabl.getMfaCode(MFA_CREDENTIALS_ID);
+  // now use the MFA token inside your test
+});
+
+test('Validate that we can get and use credentials from mabl', async ({
+  page,
+  mabl,
+}) => {
+  await page.goto('https://sandbox.mabl.com');
+  const sandbox = new SandboxPage(page);
+  sandbox.maybeWaitForReady();
+  const loginPage = await sandbox.goToLoginPage();
+
+  // fetches the latest version of the credentials from mabl
+  const creds = await mabl.getCredentials(MFA_CREDENTIALS_ID);
+  await loginPage.fillOutAndSubmitLoginForm(creds.username, creds.password);
+});
+```

package/api/ApiError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+class ApiError extends Error {
+    constructor(message, statusCode, cause) {
+        super(message);
+        this.statusCode = statusCode;
+        this.cause = cause;
+    }
+}
+exports.ApiError = ApiError;

package/api/atlassian/bitBucketApiClient.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitBucketApiClient = exports.CODE_INSIGHTS_PORT = exports.CODE_INSIGHTS_PROXY = exports.CUSTOM_CODE_INSIGHTS_PIPE_PROXY = void 0;
+const axios_1 = __importDefault(require("axios"));
+const ApiError_1 = require("../ApiError");
+const API_VERSION = '2.0';
+exports.CUSTOM_CODE_INSIGHTS_PIPE_PROXY = 'host.docker.internal';
+exports.CODE_INSIGHTS_PROXY = 'localhost';
+exports.CODE_INSIGHTS_PORT = 29418;
+class BitBucketApiClient {
+    constructor(username, token, isCustomPipe, noProxy) {
+        const config = {
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+        };
+        if (noProxy) {
+            config.auth = {
+                username,
+                password: token,
+            };
+            this.baseUrl = `https://api.bitbucket.org/${API_VERSION}`;
+        }
+        else {
+            if (!isCustomPipe) {
+                config.proxy = {
+                    host: exports.CODE_INSIGHTS_PROXY,
+                    port: 29418,
+                };
+            }
+            else {
+                config.proxy = {
+                    host: exports.CUSTOM_CODE_INSIGHTS_PIPE_PROXY,
+                    port: 29418,
+                };
+            }
+            this.baseUrl = `http://api.bitbucket.org/${API_VERSION}`;
+        }
+        config.validateStatus = () => true;
+        this.apiClient = axios_1.default.create(config);
+    }
+    createUrl(path) {
+        return `${this.baseUrl}${path}`;
+    }
+    checkResponseStatusCode(response) {
+        const statusCode = response.status;
+        if (!statusCode || statusCode >= 400) {
+            throw new ApiError_1.ApiError(`[${statusCode} - ${response.statusText}]`, statusCode);
+        }
+    }
+    async makeGetRequest(path, config) {
+        const response = await this.apiClient.get(this.createUrl(path), config);
+        this.checkResponseStatusCode(response);
+        return response.data;
+    }
+    async makePutRequest(path, requestBody, config) {
+        const response = await this.apiClient.put(this.createUrl(path), JSON.stringify(requestBody), config);
+        this.checkResponseStatusCode(response);
+        return response.data;
+    }
+    putCodeReport(codeReport, workspace, repoSlug, node) {
+        return this.makePutRequest(`/repositories/${workspace}/${repoSlug}/commit/${node}/reports/${codeReport.external_id}`, codeReport);
+    }
+    getCodeReport(externalId, workspace, repoSlug, node) {
+        return this.makeGetRequest(`/repositories/${workspace}/${repoSlug}/commit/${node}/reports/${externalId}`);
+    }
+    getCodeReports(workspace, repoSlug, node) {
+        return this.makeGetRequest(`/repositories/${workspace}/${repoSlug}/commit/${node}/reports`);
+    }
+    putCodeAnnotation(codeAnnotation, workspace, repoSlug, node, codeReportExternalId) {
+        return this.makePutRequest(`/repositories/${workspace}/${repoSlug}/commit/${node}/reports/${codeReportExternalId}/annotations/${codeAnnotation.external_id}`, codeAnnotation);
+    }
+    getPullRequest(pullRequestId, workspace, repoSlug) {
+        return this.makeGetRequest(`/repositories/${workspace}/${repoSlug}/pullrequests/${pullRequestId}`);
+    }
+}
+exports.BitBucketApiClient = BitBucketApiClient;

package/api/atlassian/entities/CodeAnnotation.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeInsightsAnnotationType = void 0;
+var CodeInsightsAnnotationType;
+(function (CodeInsightsAnnotationType) {
+    CodeInsightsAnnotationType["BUG"] = "BUG";
+    CodeInsightsAnnotationType["CODE_SMELL"] = "CODE_SMELL";
+    CodeInsightsAnnotationType["VULNERABILITY"] = "VULNERABILITY";
+})(CodeInsightsAnnotationType || (exports.CodeInsightsAnnotationType = CodeInsightsAnnotationType = {}));

package/api/atlassian/entities/CodeReport.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeInsightsResult = exports.CodeReportType = void 0;
+var CodeReportType;
+(function (CodeReportType) {
+    CodeReportType["BUG"] = "BUG";
+    CodeReportType["COVERAGE"] = "COVERAGE";
+    CodeReportType["SECURITY"] = "SECURITY";
+    CodeReportType["TEST"] = "TEST";
+})(CodeReportType || (exports.CodeReportType = CodeReportType = {}));
+var CodeInsightsResult;
+(function (CodeInsightsResult) {
+    CodeInsightsResult["FAILED"] = "FAILED";
+    CodeInsightsResult["PASSED"] = "PASSED";
+})(CodeInsightsResult || (exports.CodeInsightsResult = CodeInsightsResult = {}));

package/api/atlassian/entities/PullRequest.js

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