@smartbear/mcp 0.9.0 → 0.11.0

package/dist/index.js

@@ -1,13 +1,8 @@
 #!/usr/bin/env node
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { ApiHubClient } from "./api-hub/client.js";
-import { BugsnagClient } from "./bugsnag/client.js";
 import Bugsnag from "./common/bugsnag.js";
-import { SmartBearMcpServer } from "./common/server.js";
-import { PactflowClient } from "./pactflow/client.js";
-import { QmetryClient } from "./qmetry/client.js";
-import { ReflectClient } from "./reflect/client.js";
-import { ZephyrClient } from "./zephyr/client.js";
+import "./common/register-clients.js"; // Register all available clients
+import { runHttpMode } from "./common/transport-http.js";
+import { runStdioMode } from "./common/transport-stdio.js";
 // This is used to report errors in the MCP server itself
 // If you want to use your own BugSnag API key, set the MCP_SERVER_BUGSNAG_API_KEY environment variable
 const McpServerBugsnagAPIKey = process.env.MCP_SERVER_BUGSNAG_API_KEY;
@@ -15,62 +10,25 @@ if (McpServerBugsnagAPIKey) {
     Bugsnag.start(McpServerBugsnagAPIKey);
 }
 async function main() {
-    const server = new SmartBearMcpServer();
-    const reflectToken = process.env.REFLECT_API_TOKEN;
-    const bugsnagToken = process.env.BUGSNAG_AUTH_TOKEN;
-    const apiHubToken = process.env.API_HUB_API_KEY;
-    const pactBrokerToken = process.env.PACT_BROKER_TOKEN;
-    const pactBrokerUrl = process.env.PACT_BROKER_BASE_URL;
-    const pactBrokerUsername = process.env.PACT_BROKER_USERNAME;
-    const pactBrokerPassword = process.env.PACT_BROKER_PASSWORD;
-    const qmetryToken = process.env.QMETRY_API_KEY;
-    const qmetryBaseUrl = process.env.QMETRY_BASE_URL;
-    const zephyrToken = process.env.ZEPHYR_API_TOKEN;
-    const zephyrBaseUrl = process.env.ZEPHYR_BASE_URL;
-    let client_defined = false;
-    if (reflectToken) {
-        server.addClient(new ReflectClient(reflectToken));
-        client_defined = true;
+    // Determine transport mode from environment variable
+    // MCP_TRANSPORT can be "stdio" (default) or "http"
+    const transportMode = process.env.MCP_TRANSPORT?.toLowerCase() || "stdio";
+    if (transportMode === "http") {
+        console.log("[MCP] Starting in HTTP mode...");
+        await runHttpMode();
     }
-    if (bugsnagToken) {
-        const bugsnagClient = new BugsnagClient(bugsnagToken, process.env.BUGSNAG_PROJECT_API_KEY, process.env.BUGSNAG_ENDPOINT);
-        await bugsnagClient.initialize();
-        server.addClient(bugsnagClient);
-        client_defined = true;
+    else if (transportMode === "stdio") {
+        await runStdioMode();
     }
-    if (apiHubToken) {
-        server.addClient(new ApiHubClient(apiHubToken));
-        client_defined = true;
-    }
-    if (pactBrokerUrl) {
-        if (pactBrokerToken) {
-            server.addClient(new PactflowClient(pactBrokerToken, pactBrokerUrl, "pactflow", server.server));
-            client_defined = true;
-        }
-        else if (pactBrokerUsername && pactBrokerPassword) {
-            server.addClient(new PactflowClient({ username: pactBrokerUsername, password: pactBrokerPassword }, pactBrokerUrl, "pact_broker", server.server));
-            client_defined = true;
-        }
-        else {
-            console.error("If the Pact Broker base URL is specified, you must specify either (a) a PactFlow token, or (b) a Pact Broker username and password pair.");
-        }
-    }
-    if (qmetryToken) {
-        server.addClient(new QmetryClient(qmetryToken, qmetryBaseUrl));
-        client_defined = true;
-    }
-    if (zephyrToken) {
-        server.addClient(new ZephyrClient(zephyrToken, zephyrBaseUrl));
-        client_defined = true;
-    }
-    if (!client_defined) {
-        console.error("Please set one of REFLECT_API_TOKEN, BUGSNAG_AUTH_TOKEN, API_HUB_API_KEY, QMETRY_API_KEY, ZEPHYR_API_TOKEN, or PACT_BROKER_BASE_URL / (and relevant Pact auth) environment variables");
+    else {
+        console.error(`[MCP] Invalid transport mode: ${transportMode}. Use "stdio" or "http".`);
         process.exit(1);
     }
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
 }
-main().catch((error) => {
+try {
+    await main();
+}
+catch (error) {
     console.error("Fatal error in main():", error);
     process.exit(1);
-});
+}

package/dist/pactflow/client/tools.js

@@ -17,7 +17,7 @@ export const TOOLS = [
         title: "Generate Pact Tests",
         summary: "Generate Pact tests using PactFlow AI. You can provide one or more of the following input types: (1) request/response pairs for specific interactions, (2) code files to analyze and extract interactions from, and/or (3) OpenAPI document to generate tests for specific endpoints. When providing an OpenAPI document, a matcher is required to specify which endpoints to generate tests for.",
         purpose: "Generate Pact tests for API interactions",
-        zodSchema: GenerationInputSchema,
+        inputSchema: GenerationInputSchema,
         handler: "generate",
         clients: ["pactflow"], // ONLY pactflow
         enableElicitation: true,
@@ -26,7 +26,7 @@ export const TOOLS = [
         title: "Review Pact Tests",
         summary: "Review Pact tests using PactFlow AI. You can provide the following inputs: (1) Pact tests to be reviewed along with metadata",
         purpose: "Review Pact tests for API interactions",
-        zodSchema: RefineInputSchema,
+        inputSchema: RefineInputSchema,
         handler: "review",
         clients: ["pactflow"],
         enableElicitation: true,
@@ -50,7 +50,7 @@ export const TOOLS = [
         title: "Can I Deploy",
         summary: "Performs a comprehensive compatibility check to determine whether a specific version of a service (pacticipant) can be safely deployed into a given environment. It analyzes the complete contract matrix of consumer-provider relationships to confirm that all required integrations are verified and compatible.",
         purpose: "To serve as a deployment safety check within the PactBroker and PactFlow ecosystem, leveraging contract testing results to validate whether a specific service / pacticipant version is compatible with all integrated services. This feature prevents unsafe releases, reduces integration risks, and enables teams to confidently automate deployments across environments with a clear, auditable record of verification results.",
-        zodSchema: CanIDeploySchema,
+        inputSchema: CanIDeploySchema,
         handler: "canIDeploy",
         clients: ["pactflow", "pact_broker"],
     },
@@ -66,7 +66,7 @@ export const TOOLS = [
             "Support informed deployment decisions by answering 'can I deploy version X of this service to production?'",
             "Expose contract verification details to non-frequent API users in a more accessible format.",
         ],
-        zodSchema: MatrixSchema,
+        inputSchema: MatrixSchema,
         handler: "getMatrix",
         clients: ["pactflow", "pact_broker"],
     },

package/dist/pactflow/client.js

@@ -1,46 +1,66 @@
+import z from "zod";
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
 import { ToolError, } from "../common/types.js";
 import { getOADMatcherRecommendations, getUserMatcherSelection, } from "./client/prompt-utils.js";
 import { PROMPTS } from "./client/prompts.js";
 import { TOOLS } from "./client/tools.js";
+const ConfigurationSchema = z.object({
+    base_url: z.string().url().describe("Pact Broker or PactFlow base URL"),
+    token: z
+        .string()
+        .optional()
+        .describe("Bearer token for PactFlow authentication (use this OR username/password)"),
+    username: z.string().optional().describe("Username for Pact Broker"),
+    password: z.string().optional().describe("Password for Pact Broker"),
+});
 // Tool definitions for PactFlow AI API client
 export class PactflowClient {
     name = "Contract Testing";
-    prefix = "contract-testing";
+    toolPrefix = "contract-testing";
+    configPrefix = "Pact-Broker";
+    config = ConfigurationSchema;
     headers;
     aiBaseUrl;
     baseUrl;
-    clientType;
-    server;
-    /**
-     * Creates an instance of the PactflowClient.
-     *
-     * @param auth The authentication token or credentials.
-     * @param baseUrl The base URL for the API.
-     * @param clientType The type of client (e.g., PactFlow, Pact Broker).
-     * @param server The SmartBear MCP server instance.
-     */
-    constructor(auth, baseUrl, clientType, server) {
+    _clientType;
+    _server;
+    get server() {
+        if (!this._server)
+            throw new Error("Server not configured");
+        return this._server;
+    }
+    get clientType() {
+        if (!this._clientType)
+            throw new Error("Client not configured");
+        return this._clientType;
+    }
+    async configure(server, config) {
         // Set headers based on the type of auth provided
-        if (typeof auth === "string") {
+        if (typeof config.token === "string") {
             this.headers = {
-                Authorization: `Bearer ${auth}`,
+                Authorization: `Bearer ${config.token}`,
                 "Content-Type": "application/json",
                 "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
             };
+            this._clientType = "pactflow";
         }
-        else {
-            const authString = `${auth.username}:${auth.password}`;
+        else if (typeof config.username === "string" &&
+            typeof config.password === "string") {
+            const authString = `${config.username}:${config.password}`;
             this.headers = {
                 Authorization: `Basic ${Buffer.from(authString).toString("base64")}`,
                 "Content-Type": "application/json",
                 "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
             };
+            this._clientType = "pact_broker";
+        }
+        else {
+            return false; // Don't configure the client if no auth is provided
         }
-        this.baseUrl = baseUrl;
+        this.baseUrl = config.base_url;
         this.aiBaseUrl = `${this.baseUrl}/api/ai`;
-        this.clientType = clientType;
-        this.server = server;
+        this._server = server.server;
+        return true;
     }
     // PactFlow AI client methods
     /**

package/dist/qmetry/client/auto-resolve.js

@@ -9,11 +9,22 @@ export const AUTO_RESOLVE_MODULES = [
         viewIdPath: "latestViews.TC.viewId",
         moduleName: "Test Cases",
     },
+    {
+        handler: QMetryToolsHandlers.CREATE_TEST_CASE,
+        folderIdPath: "rootFolders.TC.id",
+        folderIdField: "tcFolderID",
+        moduleName: "Test Cases",
+    },
     {
         handler: QMetryToolsHandlers.FETCH_REQUIREMENTS,
         viewIdPath: "latestViews.RQ.viewId",
         moduleName: "Requirements",
     },
+    {
+        handler: QMetryToolsHandlers.FETCH_TEST_SUITES,
+        viewIdPath: "latestViews.TS.viewId",
+        moduleName: "Test Suites",
+    },
     {
         handler: QMetryToolsHandlers.FETCH_TESTSUITES_FOR_TESTCASE,
         viewIdPath: "latestViews.TSFS.viewId",
@@ -21,6 +32,17 @@ export const AUTO_RESOLVE_MODULES = [
         folderIdField: "tsFolderID",
         moduleName: "Test Suites",
     },
+    {
+        handler: QMetryToolsHandlers.CREATE_TEST_SUITE,
+        folderIdPath: "rootFolders.TS.id",
+        folderIdField: "parentFolderId",
+        moduleName: "Test Suites",
+    },
+    {
+        handler: QMetryToolsHandlers.FETCH_ISSUES,
+        viewIdPath: "latestViews.IS.viewId",
+        moduleName: "Issues",
+    },
 ];
 /**
  * Helper function to safely get nested property value using dot notation

package/dist/qmetry/client/handlers.js

@@ -1,28 +1,42 @@
 import { QMetryToolsHandlers } from "../config/constants.js";
-import { fetchIssuesLinkedToTestCase } from "./issues.js";
-import { getBuilds, getPlatforms, getProjectInfo, getReleasesCycles, } from "./project.js";
+import { createIssue, fetchIssues, fetchIssuesLinkedToTestCase, linkIssuesToTestcaseRun, updateIssue, } from "./issues.js";
+import { getBuilds, getPlatforms, getProjectInfo, getProjects, getReleasesCycles, } from "./project.js";
 import { fetchRequirementDetails, fetchRequirements, fetchRequirementsLinkedToTestCase, } from "./requirement.js";
-import { fetchTestCaseDetails, fetchTestCaseExecutions, fetchTestCaseSteps, fetchTestCases, fetchTestCasesLinkedToRequirement, fetchTestCaseVersionDetails, } from "./testcase.js";
-import { fetchExecutionsByTestSuite, fetchLinkedIssuesByTestCaseRun, fetchTestCaseRunsByTestSuiteRun, fetchTestCasesByTestSuite, fetchTestSuitesForTestCase, } from "./testsuite.js";
+import { createTestCases, fetchTestCaseDetails, fetchTestCaseExecutions, fetchTestCaseSteps, fetchTestCases, fetchTestCasesLinkedToRequirement, fetchTestCaseVersionDetails, linkRequirementToTestCase, updateTestCase, } from "./testcase.js";
+import { createTestSuites, fetchExecutionsByTestSuite, fetchLinkedIssuesByTestCaseRun, fetchTestCaseRunsByTestSuiteRun, fetchTestCasesByTestSuite, fetchTestSuites, fetchTestSuitesForTestCase, linkPlatformsToTestSuite, linkTestCasesToTestSuite, reqLinkedTestCasesToTestSuite, updateTestSuite, } from "./testsuite.js";
 export const QMETRY_HANDLER_MAP = {
+    [QMetryToolsHandlers.FETCH_PROJECTS]: getProjects,
     [QMetryToolsHandlers.SET_PROJECT_INFO]: getProjectInfo,
     [QMetryToolsHandlers.FETCH_PROJECT_INFO]: getProjectInfo,
     [QMetryToolsHandlers.FETCH_RELEASES_CYCLES]: getReleasesCycles,
     [QMetryToolsHandlers.FETCH_BUILDS]: getBuilds,
     [QMetryToolsHandlers.FETCH_PLATFORMS]: getPlatforms,
+    [QMetryToolsHandlers.CREATE_TEST_CASE]: createTestCases,
+    [QMetryToolsHandlers.UPDATE_TEST_CASE]: updateTestCase,
     [QMetryToolsHandlers.FETCH_TEST_CASES]: fetchTestCases,
     [QMetryToolsHandlers.FETCH_TEST_CASE_DETAILS]: fetchTestCaseDetails,
     [QMetryToolsHandlers.FETCH_TEST_CASE_VERSION_DETAILS]: fetchTestCaseVersionDetails,
     [QMetryToolsHandlers.FETCH_TEST_CASE_STEPS]: fetchTestCaseSteps,
     [QMetryToolsHandlers.FETCH_TEST_CASE_EXECUTIONS]: fetchTestCaseExecutions,
+    [QMetryToolsHandlers.LINK_REQUIREMENT_TO_TESTCASE]: linkRequirementToTestCase,
     [QMetryToolsHandlers.FETCH_REQUIREMENTS]: fetchRequirements,
     [QMetryToolsHandlers.FETCH_REQUIREMENT_DETAILS]: fetchRequirementDetails,
     [QMetryToolsHandlers.FETCH_TESTCASES_LINKED_TO_REQUIREMENT]: fetchTestCasesLinkedToRequirement,
     [QMetryToolsHandlers.FETCH_REQUIREMENTS_LINKED_TO_TESTCASE]: fetchRequirementsLinkedToTestCase,
+    [QMetryToolsHandlers.CREATE_TEST_SUITE]: createTestSuites,
+    [QMetryToolsHandlers.UPDATE_TEST_SUITE]: updateTestSuite,
+    [QMetryToolsHandlers.FETCH_TEST_SUITES]: fetchTestSuites,
     [QMetryToolsHandlers.FETCH_TESTSUITES_FOR_TESTCASE]: fetchTestSuitesForTestCase,
+    [QMetryToolsHandlers.LINK_TESTCASES_TO_TESTSUITE]: linkTestCasesToTestSuite,
+    [QMetryToolsHandlers.REQUIREMENTS_LINKED_TESTCASES_TO_TESTSUITE]: reqLinkedTestCasesToTestSuite,
     [QMetryToolsHandlers.FETCH_TESTCASES_BY_TESTSUITE]: fetchTestCasesByTestSuite,
     [QMetryToolsHandlers.FETCH_EXECUTIONS_BY_TESTSUITE]: fetchExecutionsByTestSuite,
     [QMetryToolsHandlers.FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN]: fetchTestCaseRunsByTestSuiteRun,
     [QMetryToolsHandlers.FETCH_LINKED_ISSUES_BY_TESTCASE_RUN]: fetchLinkedIssuesByTestCaseRun,
     [QMetryToolsHandlers.FETCH_ISSUES_LINKED_TO_TESTCASE]: fetchIssuesLinkedToTestCase,
+    [QMetryToolsHandlers.CREATE_ISSUE]: createIssue,
+    [QMetryToolsHandlers.UPDATE_ISSUE]: updateIssue,
+    [QMetryToolsHandlers.FETCH_ISSUES]: fetchIssues,
+    [QMetryToolsHandlers.LINK_ISSUES_TO_TESTCASE_RUN]: linkIssuesToTestcaseRun,
+    [QMetryToolsHandlers.LINK_PLATFORMS_TO_TESTSUITE]: linkPlatformsToTestSuite,
 };

package/dist/qmetry/client/issues.js

@@ -1,7 +1,79 @@
 import { QMETRY_PATHS } from "../config/rest-endpoints.js";
-import { DEFAULT_FETCH_ISSUES_LINKED_TO_TESTCASE_PAYLOAD, } from "../types/issues.js";
+import { DEFAULT_CREATE_ISSUE_PAYLOAD, DEFAULT_FETCH_ISSUES_LINKED_TO_TESTCASE_PAYLOAD, DEFAULT_FETCH_ISSUES_PAYLOAD, DEFAULT_LINK_ISSUES_TO_TESTCASE_RUN_PAYLOAD, DEFAULT_UPDATE_ISSUE_PAYLOAD, } from "../types/issues.js";
 import { qmetryRequest } from "./api/client-api.js";
 import { resolveDefaults } from "./utils.js";
+/**
+ * Create Defect/Issue.
+ * @throws If `issueType` or `issuePriority` or `summary` are missing/invalid.
+ */
+export async function createIssue(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_CREATE_ISSUE_PAYLOAD,
+        ...payload,
+    };
+    if (typeof body.issueType !== "number") {
+        throw new Error("[createIssue] Missing or invalid required parameter: 'issueType'.");
+    }
+    if (typeof body.issuePriority !== "number") {
+        throw new Error("[createIssue] Missing or invalid required parameter: 'issuePriority'.");
+    }
+    if (typeof body.summary !== "string") {
+        throw new Error("[createIssue] Missing or invalid required parameter: 'summary'.");
+    }
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.ISSUES.CREATE_UPDATE_ISSUE,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}
+/**
+ * Update Defect/Issue.
+ * @throws If `DefectId` is missing/invalid.
+ */
+export async function updateIssue(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_UPDATE_ISSUE_PAYLOAD,
+        ...payload,
+    };
+    if (typeof body.DefectId !== "number") {
+        throw new Error("[updateIssue] Missing or invalid required parameter: 'DefectId'.");
+    }
+    return qmetryRequest({
+        method: "PUT",
+        path: QMETRY_PATHS.ISSUES.CREATE_UPDATE_ISSUE,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}
+/**
+ * Fetches a list of test suites.
+ * @throws If `viewId` or `folderPath` are missing/invalid.
+ */
+export async function fetchIssues(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_FETCH_ISSUES_PAYLOAD,
+        ...payload,
+    };
+    if (typeof body.viewId !== "number") {
+        throw new Error("[fetchIssues] Missing or invalid required parameter: 'viewId'.");
+    }
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.ISSUES.GET_ISSUES_LIST,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}
 /**
  * Fetches issues linked to a specific test case.
  * @throws If `tcID` is missing/invalid.
@@ -24,3 +96,28 @@ export async function fetchIssuesLinkedToTestCase(token, baseUrl, project, paylo
         body,
     });
 }
+/**
+ * Link Issues to Testcase Run.
+ * @throws If issueIds or tcrId are missing/invalid.
+ */
+export async function linkIssuesToTestcaseRun(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_LINK_ISSUES_TO_TESTCASE_RUN_PAYLOAD,
+        ...payload,
+    };
+    if (!Array.isArray(body.issueIds) || body.issueIds.length === 0) {
+        throw new Error("[linkIssuesToTestcaseRun] Missing or invalid required parameter: 'issueIds'.");
+    }
+    if (typeof body.tcrId !== "number") {
+        throw new Error("[linkIssuesToTestcaseRun] Missing or invalid required parameter: 'tcrId'.");
+    }
+    return qmetryRequest({
+        method: "PUT",
+        path: QMETRY_PATHS.ISSUES.LINK_ISSUES_TO_TESTCASE_RUN,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}

package/dist/qmetry/client/project.js

@@ -1,6 +1,6 @@
 import { QMETRY_DEFAULTS } from "../config/constants.js";
 import { QMETRY_PATHS } from "../config/rest-endpoints.js";
-import { DEFAULT_FETCH_BUILD_PAYLOAD, DEFAULT_FETCH_PLATFORMS_PAYLOAD, } from "../types/project.js";
+import { DEFAULT_FETCH_BUILD_PAYLOAD, DEFAULT_FETCH_PLATFORMS_PAYLOAD, DEFAULT_FETCH_PROJECTS_PAYLOAD, } from "../types/project.js";
 import { qmetryRequest } from "./api/client-api.js";
 /**
  * Retrieves project information from QMetry
@@ -26,6 +26,23 @@ export async function getProjectInfo(token, baseUrl, project) {
         project: project || QMETRY_DEFAULTS.PROJECT_KEY,
     });
 }
+/**
+ * Fetches a List of projects.
+ */
+export async function getProjects(token, baseUrl, project, payload) {
+    const body = {
+        ...DEFAULT_FETCH_PROJECTS_PAYLOAD,
+        ...payload,
+    };
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.PROJECT.GET_PROJECTS,
+        token,
+        baseUrl: baseUrl || QMETRY_DEFAULTS.BASE_URL,
+        project: project || QMETRY_DEFAULTS.PROJECT_KEY,
+        body,
+    });
+}
 export async function getReleasesCycles(token, baseUrl, project, payload = {}) {
     let showArchiveValue;
     if (payload.showArchive !== undefined) {

package/dist/qmetry/client/testcase.js

@@ -1,7 +1,57 @@
 import { QMETRY_PATHS } from "../config/rest-endpoints.js";
-import { DEFAULT_FETCH_TESTCASE_DETAILS_PAYLOAD, DEFAULT_FETCH_TESTCASE_EXECUTIONS_PAYLOAD, DEFAULT_FETCH_TESTCASE_STEPS_PAYLOAD, DEFAULT_FETCH_TESTCASE_VERSION_DETAILS_PAYLOAD, DEFAULT_FETCH_TESTCASES_LINKED_TO_REQUIREMENT_PAYLOAD, DEFAULT_FETCH_TESTCASES_PAYLOAD, } from "../types/testcase.js";
+import { DEFAULT_CREATE_TESTCASES_PAYLOAD, DEFAULT_FETCH_TESTCASE_DETAILS_PAYLOAD, DEFAULT_FETCH_TESTCASE_EXECUTIONS_PAYLOAD, DEFAULT_FETCH_TESTCASE_STEPS_PAYLOAD, DEFAULT_FETCH_TESTCASE_VERSION_DETAILS_PAYLOAD, DEFAULT_FETCH_TESTCASES_LINKED_TO_REQUIREMENT_PAYLOAD, DEFAULT_FETCH_TESTCASES_PAYLOAD, DEFAULT_LINKED_REQUIREMENT_TO_TESTCASE_PAYLOAD, DEFAULT_UPDATE_TESTCASES_PAYLOAD, } from "../types/testcase.js";
 import { qmetryRequest } from "./api/client-api.js";
 import { resolveDefaults } from "./utils.js";
+/**
+ * Create test cases.
+ * @throws If `tcFolderID` or `name` are missing/invalid.
+ */
+export async function createTestCases(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_CREATE_TESTCASES_PAYLOAD,
+        ...payload,
+    };
+    if (typeof body.tcFolderID !== "string") {
+        throw new Error("[createTestCases] Missing or invalid required parameter: 'tcFolderID'.");
+    }
+    if (typeof body.name !== "string") {
+        throw new Error("[createTestCases] Missing or invalid required parameter: 'name'.");
+    }
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.TESTCASE.CREATE_UPDATE_TC,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}
+/**
+ * Update test cases.
+ * @throws If `tcID` or `tcVersionID` are missing/invalid.
+ */
+export async function updateTestCase(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_UPDATE_TESTCASES_PAYLOAD,
+        ...payload,
+    };
+    if (typeof body.tcID !== "number") {
+        throw new Error("[updateTestCase] Missing or invalid required parameter: 'tcID'.");
+    }
+    if (typeof body.tcVersionID !== "number") {
+        throw new Error("[updateTestCase] Missing or invalid required parameter: 'tcVersionID'.");
+    }
+    return qmetryRequest({
+        method: "PUT",
+        path: QMETRY_PATHS.TESTCASE.CREATE_UPDATE_TC,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}
 /**
  * Fetches a list of test cases.
  * @throws If `viewId` or `folderPath` are missing/invalid.
@@ -140,3 +190,31 @@ export async function fetchTestCaseExecutions(token, baseUrl, project, payload)
         body,
     });
 }
+/**
+ * Links a requirement to a test case.
+ * @throws If `tcID` or `tcVersionID` or `rqVersionIds` are missing/invalid.
+ */
+export async function linkRequirementToTestCase(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_LINKED_REQUIREMENT_TO_TESTCASE_PAYLOAD,
+        ...payload,
+    };
+    if (typeof body.tcID !== "string") {
+        throw new Error("[linkRequirementToTestCase] Missing or invalid required parameter: 'tcID'.");
+    }
+    if (typeof body.tcVersionId !== "number") {
+        throw new Error("[linkRequirementToTestCase] Missing or invalid required parameter: 'tcVersionId'.");
+    }
+    if (typeof body.rqVersionIds !== "string") {
+        throw new Error("[linkRequirementToTestCase] Missing or invalid required parameter: 'rqVersionIds'.");
+    }
+    return qmetryRequest({
+        method: "PUT",
+        path: QMETRY_PATHS.TESTCASE.LINKED_RQ_TO_TC,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}