playwright-cucumber-ts-steps 1.1.7 → 1.1.9

package/dist/backend/actions/waits.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaitForUrlContain = exports.WaitForElementHidden = exports.WaitForElementVisible = exports.WaitForLoadState = exports.WaitForNetworkIdle = void 0;
+const registry_1 = require("../../core/registry");
+const state_1 = require("../utils/state");
+// =============================
+// WAIT STRATEGIES
+// =============================
+/**
+ * Waits for the network to reach an "idle" state.
+ * In Playwright terms, this means there are no new network connections for at least 500ms.
+ *
+ * ```gherkin
+ * When I wait for network idle
+ * ```
+ *
+ * @remarks
+ * **Warning:** This can be flaky on pages that have constant background polling (e.g., real-time chats, analytics).
+ * If the test times out here, consider using `I wait for element to be visible` instead.
+ */
+exports.WaitForNetworkIdle = (0, registry_1.Step)("I wait for network idle", async (page) => {
+    await page.waitForLoadState("networkidle");
+    console.log("⏳ Network is idle");
+});
+/**
+ * Waits for the page to reach a specific load lifecycle event.
+ *
+ * ```gherkin
+ * When I wait for load state "domcontentloaded"
+ * ```
+ *
+ * @param state - The state to wait for. Options:
+ * - `"load"`: Window load event fired.
+ * - `"domcontentloaded"`: DOM is ready (scripts might still be loading).
+ * - `"networkidle"`: No network connections for 500ms.
+ */
+exports.WaitForLoadState = (0, registry_1.Step)("I wait for load state {string}", async (page, state) => {
+    if (!["load", "domcontentloaded", "networkidle"].includes(state)) {
+        throw new Error(`❌ Invalid load state: "${state}". Use load, domcontentloaded, or networkidle.`);
+    }
+    await page.waitForLoadState(state);
+    console.log(`⏳ Reached load state: "${state}"`);
+});
+/**
+ * Explicitly waits for the currently stored (active) element to become visible.
+ * Useful for ensuring animations complete or modals appear before proceeding.
+ *
+ * ```gherkin
+ * When I wait for element to be visible
+ * ```
+ */
+exports.WaitForElementVisible = (0, registry_1.Step)("I wait for element to be visible", async (page) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await element.waitFor({ state: "visible" });
+    console.log("⏳ Element is now visible");
+});
+/**
+ * Explicitly waits for the currently stored (active) element to become hidden or detached from the DOM.
+ * Useful for verifying that loading spinners have disappeared.
+ *
+ * ```gherkin
+ * When I wait for element to be hidden
+ * ```
+ */
+exports.WaitForElementHidden = (0, registry_1.Step)("I wait for element to be hidden", async (page) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await element.waitFor({ state: "hidden" });
+    console.log("⏳ Element is now hidden");
+});
+/**
+ * Waits until the page URL contains the specified substring (Regex match).
+ * Useful for verifying redirects (e.g., after login).
+ *
+ * ```gherkin
+ * When I wait for URL to contain "dashboard"
+ * ```
+ *
+ * @param urlPart - The substring to look for in the current URL.
+ */
+exports.WaitForUrlContain = (0, registry_1.Step)("I wait for URL to contain {string}", async (page, urlPart) => {
+    await page.waitForURL(new RegExp(urlPart));
+    console.log(`⏳ URL now contains: "${urlPart}"`);
+});

package/dist/backend/api/assertions.d.ts

@@ -1,2 +1,33 @@
-export {};
+/**
+ * Asserts that the HTTP status code of the last API response matches the expected integer.
+ *
+ * ```gherkin
+ * Then I expect the response status to be 200
+ * ```
+ *
+ * @param statusCode - The expected HTTP status code (e.g., 200, 404, 500).
+ */
+export declare const ExpectResponseStatus: void;
+/**
+ * Asserts that the body text of the last API response contains a specific substring.
+ *
+ * ```gherkin
+ * Then I expect the response body to contain "success"
+ * ```
+ *
+ * @param text - The text substring to look for in the response body.
+ */
+export declare const ExpectResponseBodyContain: void;
+/**
+ * Asserts that a specific property in the JSON response matches a string value.
+ * Supports dot notation for nested properties.
+ *
+ * ```gherkin
+ * Then I expect the response property "user.id" to be "12345"
+ * ```
+ *
+ * @param jsonPath - The dot-notation path to the JSON property (e.g., "data.user.name").
+ * @param value - The expected string value of the property.
+ */
+export declare const ExpectResponseProperty: void;
 //# sourceMappingURL=assertions.d.ts.map

package/dist/backend/api/assertions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../../../src/backend/api/assertions.ts"],"names":[],"mappings":""}
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../../../src/backend/api/assertions.ts"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,MAMhC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,MAOrC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,MAWlC,CAAC"}

package/dist/backend/api/assertions.js

@@ -1,26 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpectResponseProperty = exports.ExpectResponseBodyContain = exports.ExpectResponseStatus = void 0;
 const test_1 = require("@playwright/test");
 const registry_1 = require("../../core/registry");
 const state_1 = require("./state");
-// Check Status Code
-(0, registry_1.Step)("I expect the response status to be {int}", async (page, statusCode) => {
+// =============================
+// API ASSERTIONS
+// =============================
+/**
+ * Asserts that the HTTP status code of the last API response matches the expected integer.
+ *
+ * ```gherkin
+ * Then I expect the response status to be 200
+ * ```
+ *
+ * @param statusCode - The expected HTTP status code (e.g., 200, 404, 500).
+ */
+exports.ExpectResponseStatus = (0, registry_1.Step)("I expect the response status to be {int}", async (page, statusCode) => {
     const response = state_1.apiState.getResponse();
     (0, test_1.expect)(response.status()).toBe(statusCode);
 });
-// Check entire Body Text
-(0, registry_1.Step)("I expect the response body to contain {string}", async (page, text) => {
+/**
+ * Asserts that the body text of the last API response contains a specific substring.
+ *
+ * ```gherkin
+ * Then I expect the response body to contain "success"
+ * ```
+ *
+ * @param text - The text substring to look for in the response body.
+ */
+exports.ExpectResponseBodyContain = (0, registry_1.Step)("I expect the response body to contain {string}", async (page, text) => {
     const response = state_1.apiState.getResponse();
     const body = await response.text();
     (0, test_1.expect)(body).toContain(text);
 });
-// Check JSON Property
-(0, registry_1.Step)("I expect the response property {string} to be {string}", async (page, jsonPath, value) => {
+/**
+ * Asserts that a specific property in the JSON response matches a string value.
+ * Supports dot notation for nested properties.
+ *
+ * ```gherkin
+ * Then I expect the response property "user.id" to be "12345"
+ * ```
+ *
+ * @param jsonPath - The dot-notation path to the JSON property (e.g., "data.user.name").
+ * @param value - The expected string value of the property.
+ */
+exports.ExpectResponseProperty = (0, registry_1.Step)("I expect the response property {string} to be {string}", async (page, jsonPath, value) => {
     const response = state_1.apiState.getResponse();
     const json = await response.json();
     // FIX: Added ': string' to the 'i' parameter
-    const actualValue = jsonPath
-        .split(".")
-        .reduce((o, i) => o[i], json);
+    const actualValue = jsonPath.split(".").reduce((o, i) => o[i], json);
     (0, test_1.expect)(String(actualValue)).toBe(value);
 });

package/dist/backend/api/index.d.ts

@@ -1,4 +1,5 @@
 import "./requests";
 import "./assertions";
 import "./mock";
+import "./network";
 //# sourceMappingURL=index.d.ts.map

package/dist/backend/api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backend/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,CAAC;AACpB,OAAO,cAAc,CAAC;AACtB,OAAO,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backend/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,CAAC;AACpB,OAAO,cAAc,CAAC;AACtB,OAAO,QAAQ,CAAC;AAChB,OAAO,WAAW,CAAC"}

package/dist/backend/api/index.js

@@ -3,3 +3,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("./requests");
 require("./assertions");
 require("./mock");
+require("./network");

package/dist/backend/api/mock.d.ts

@@ -1,2 +1,35 @@
-export {};
+/**
+ * @module NetworkMocking
+ */
+/**
+ * Mocks a specific API endpoint with a hardcoded inline JSON response body.
+ * * @example
+ * ```gherkin
+ * Given I mock the API endpoint "/api/users" with body '{"id": 1, "name": "Fake"}'
+ * ```
+ * * @param urlPattern - The URL or glob pattern to intercept.
+ * @param jsonBody - The raw JSON string to return as the response.
+ */
+export declare const MockApiWithInlineJson: void;
+/**
+ * Mocks an API endpoint using the contents of a local JSON file.
+ * * @example
+ * ```gherkin
+ * Given I mock the API endpoint "/api/users" with response from "mocks/users.json"
+ * ```
+ * * @param urlPattern - The URL pattern to intercept.
+ * @param filePath - Path to the JSON file relative to the project root.
+ */
+export declare const MockApiWithFile: void;
+/**
+ * Mocks an API endpoint to return a specific HTTP status code only.
+ * Useful for simulating server errors like 500 or 404.
+ * * @example
+ * ```gherkin
+ * Given I mock the API endpoint "/api/broken" with status 500
+ * ```
+ * * @param urlPattern - The URL pattern to intercept.
+ * @param statusCode - The HTTP status code to return.
+ */
+export declare const MockApiStatus: void;
 //# sourceMappingURL=mock.d.ts.map

package/dist/backend/api/mock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../../src/backend/api/mock.ts"],"names":[],"mappings":""}
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../../src/backend/api/mock.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,MAajC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,MAoB3B,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,MAQzB,CAAC"}

package/dist/backend/api/mock.js

@@ -33,12 +33,23 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-const registry_1 = require("../../core/registry");
+exports.MockApiStatus = exports.MockApiWithFile = exports.MockApiWithInlineJson = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-// 1. Mock with Inline JSON
-// Usage: Given I mock the API endpoint "/api/users" with body '{"id": 1, "name": "Fake"}'
-(0, registry_1.Step)("I mock the API endpoint {string} with body {string}", async (page, urlPattern, jsonBody) => {
+const registry_1 = require("../../core/registry");
+/**
+ * @module NetworkMocking
+ */
+/**
+ * Mocks a specific API endpoint with a hardcoded inline JSON response body.
+ * * @example
+ * ```gherkin
+ * Given I mock the API endpoint "/api/users" with body '{"id": 1, "name": "Fake"}'
+ * ```
+ * * @param urlPattern - The URL or glob pattern to intercept.
+ * @param jsonBody - The raw JSON string to return as the response.
+ */
+exports.MockApiWithInlineJson = (0, registry_1.Step)("I mock the API endpoint {string} with body {string}", async (page, urlPattern, jsonBody) => {
     await page.route(urlPattern, async (route) => {
         const json = JSON.parse(jsonBody);
         await route.fulfill({
@@ -49,9 +60,16 @@ const path = __importStar(require("path"));
     });
     console.log(`🎭 Mocked ${urlPattern} with inline JSON`);
 });
-// 2. Mock with File
-// Usage: Given I mock the API endpoint "/api/users" with response from "mocks/users.json"
-(0, registry_1.Step)("I mock the API endpoint {string} with response from {string}", async (page, urlPattern, filePath) => {
+/**
+ * Mocks an API endpoint using the contents of a local JSON file.
+ * * @example
+ * ```gherkin
+ * Given I mock the API endpoint "/api/users" with response from "mocks/users.json"
+ * ```
+ * * @param urlPattern - The URL pattern to intercept.
+ * @param filePath - Path to the JSON file relative to the project root.
+ */
+exports.MockApiWithFile = (0, registry_1.Step)("I mock the API endpoint {string} with response from {string}", async (page, urlPattern, filePath) => {
     const fullPath = path.resolve(process.cwd(), filePath);
     if (!fs.existsSync(fullPath)) {
         throw new Error(`❌ Mock file not found at: ${fullPath}`);
@@ -66,10 +84,19 @@ const path = __importStar(require("path"));
     });
     console.log(`🎭 Mocked ${urlPattern} with file: ${filePath}`);
 });
-// 3. Mock Status Code Only (Simulate Errors)
-// Usage: Given I mock the API endpoint "/api/broken" with status 500
-(0, registry_1.Step)("I mock the API endpoint {string} with status {int}", async (page, urlPattern, statusCode) => {
+/**
+ * Mocks an API endpoint to return a specific HTTP status code only.
+ * Useful for simulating server errors like 500 or 404.
+ * * @example
+ * ```gherkin
+ * Given I mock the API endpoint "/api/broken" with status 500
+ * ```
+ * * @param urlPattern - The URL pattern to intercept.
+ * @param statusCode - The HTTP status code to return.
+ */
+exports.MockApiStatus = (0, registry_1.Step)("I mock the API endpoint {string} with status {int}", async (page, urlPattern, statusCode) => {
     await page.route(urlPattern, async (route) => {
         await route.fulfill({ status: statusCode });
     });
+    console.log(`🎭 Mocked ${urlPattern} with status ${statusCode}`);
 });

package/dist/backend/api/network.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Intercepts a network URL and returns a stubbed JSON response.
+ * Supports Gherkin DocStrings for the body content.
+ * * @example
+ * ```gherkin
+ * When I intercept URL "/api/user" and stub body:
+ * """
+ * { "id": 101, "status": "active" }
+ * """
+ * ```
+ */
+export declare const InterceptStubJson: void;
+/**
+ * Intercepts a URL and stubs it with a raw string (non-JSON).
+ * * @example
+ * ```gherkin
+ * When I intercept URL "/health" and stub body "OK"
+ * ```
+ */
+export declare const InterceptStubRaw: void;
+/**
+ * Intercepts a URL but allows it to continue (Network Spying).
+ * Useful for monitoring traffic without changing the response.
+ * * @example
+ * ```gherkin
+ * When I intercept URL "/api/*"
+ * ```
+ */
+export declare const InterceptSpy: void;
+/**
+ * Makes a GET request and stores the response in the test state.
+ * Stores values in `lastResponse` and `lastStatusCode`.
+ * * @example
+ * ```gherkin
+ * When I make request to "[https://api.example.com/v1/users](https://api.example.com/v1/users)"
+ * ```
+ */
+export declare const ApiGetRequest: void;
+/**
+ * Makes a POST request with a JSON body provided via DocString.
+ * * @example
+ * ```gherkin
+ * When I make a POST request to "/api/login" with JSON body:
+ * """
+ * { "username": "admin", "password": "password123" }
+ * """
+ * ```
+ */
+export declare const ApiPostRequest: void;
+/**
+ * Makes a generic HTTP request using the browser's `fetch` API.
+ * Supports a data table for headers and an optional body.
+ * * @example
+ * ```gherkin
+ * When I make a "PUT" request to "/api/settings"
+ * | Authorization | Bearer my-token |
+ * | body          | {"theme": "dark"} |
+ * ```
+ */
+export declare const BrowserFetchRequest: void;
+//# sourceMappingURL=network.d.ts.map

package/dist/backend/api/network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../../src/backend/api/network.ts"],"names":[],"mappings":"AAkCA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,MAe7B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,MAY5B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,MAKvB,CAAC;AAMH;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,MAexB,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,MAoB1B,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,MA+C/B,CAAC"}

package/dist/backend/api/network.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserFetchRequest = exports.ApiPostRequest = exports.ApiGetRequest = exports.InterceptSpy = exports.InterceptStubRaw = exports.InterceptStubJson = void 0;
+const registry_1 = require("../../core/registry");
+const state_1 = require("../utils/state");
+/**
+ * Helper: Safely parse JSON even if it comes with DocString quotes or is undefined.
+ * Used internally by API steps to process Gherkin DocStrings.
+ */
+function safeJsonParse(input, context) {
+    if (!input) {
+        throw new Error(`❌ Missing JSON input for ${context}. Did you forget the DocString?`);
+    }
+    let text = typeof input === "string" ? input : JSON.stringify(input);
+    // Clean up DocString artifacts
+    text = text.replace(/^"""/g, "").replace(/"""$/g, "");
+    text = text.trim();
+    try {
+        return JSON.parse(text);
+    }
+    catch (e) {
+        throw new Error(`❌ Invalid JSON for ${context}.\nReceived: ${text.slice(0, 50)}...\nError: ${e.message}`);
+    }
+}
+// =============================
+// 1. INTERCEPTION / MOCKING
+// =============================
+/**
+ * Intercepts a network URL and returns a stubbed JSON response.
+ * Supports Gherkin DocStrings for the body content.
+ * * @example
+ * ```gherkin
+ * When I intercept URL "/api/user" and stub body:
+ * """
+ * { "id": 101, "status": "active" }
+ * """
+ * ```
+ */
+exports.InterceptStubJson = (0, registry_1.Step)(/^I intercept URL "([^"]+)" and stub body:?$/, async (page, url, body) => {
+    const parsedBody = safeJsonParse(body, `stubbing "${url}"`);
+    await page.route(url, (route) => {
+        route.fulfill({
+            status: 200,
+            contentType: "application/json",
+            body: JSON.stringify(parsedBody),
+        });
+    });
+    console.log(`📡 Stubbed "${url}" with JSON response.`);
+});
+/**
+ * Intercepts a URL and stubs it with a raw string (non-JSON).
+ * * @example
+ * ```gherkin
+ * When I intercept URL "/health" and stub body "OK"
+ * ```
+ */
+exports.InterceptStubRaw = (0, registry_1.Step)("I intercept URL {string} and stub body {string}", async (page, url, body) => {
+    await page.route(url, (route) => {
+        route.fulfill({
+            status: 200,
+            contentType: "text/plain",
+            body: body,
+        });
+    });
+    console.log(`📡 Stubbed "${url}" with raw text: "${body}"`);
+});
+/**
+ * Intercepts a URL but allows it to continue (Network Spying).
+ * Useful for monitoring traffic without changing the response.
+ * * @example
+ * ```gherkin
+ * When I intercept URL "/api/*"
+ * ```
+ */
+exports.InterceptSpy = (0, registry_1.Step)("I intercept URL {string}", async (page, url) => {
+    await page.route(url, async (route) => {
+        await route.continue();
+    });
+    console.log(`📡 Spying on URL "${url}" (allowed to continue).`);
+});
+// =============================
+// 2. MAKING API REQUESTS
+// =============================
+/**
+ * Makes a GET request and stores the response in the test state.
+ * Stores values in `lastResponse` and `lastStatusCode`.
+ * * @example
+ * ```gherkin
+ * When I make request to "[https://api.example.com/v1/users](https://api.example.com/v1/users)"
+ * ```
+ */
+exports.ApiGetRequest = (0, registry_1.Step)("I make request to {string}", async (page, url) => {
+    console.log(`⚡ GET request to: ${url}`);
+    const response = await page.request.get(url);
+    const status = response.status();
+    const body = await response.text();
+    let jsonBody;
+    try {
+        jsonBody = JSON.parse(body);
+    }
+    catch { }
+    (0, state_1.setVariable)(page, "lastResponse", { status, body, json: jsonBody });
+    (0, state_1.setVariable)(page, "lastStatusCode", status);
+    console.log(`✅ Status: ${status}`);
+});
+/**
+ * Makes a POST request with a JSON body provided via DocString.
+ * * @example
+ * ```gherkin
+ * When I make a POST request to "/api/login" with JSON body:
+ * """
+ * { "username": "admin", "password": "password123" }
+ * """
+ * ```
+ */
+exports.ApiPostRequest = (0, registry_1.Step)(/^I make a POST request to "([^"]+)" with JSON body:?$/, async (page, url, docString) => {
+    const payload = safeJsonParse(docString, `POST to "${url}"`);
+    console.log(`⚡ POST request to: ${url}`);
+    const response = await page.request.post(url, { data: payload });
+    const status = response.status();
+    const body = await response.text();
+    let jsonBody;
+    try {
+        jsonBody = JSON.parse(body);
+    }
+    catch { }
+    (0, state_1.setVariable)(page, "lastResponse", { status, body, json: jsonBody });
+    (0, state_1.setVariable)(page, "lastStatusCode", status);
+    console.log(`✅ Status: ${status}`);
+});
+/**
+ * Makes a generic HTTP request using the browser's `fetch` API.
+ * Supports a data table for headers and an optional body.
+ * * @example
+ * ```gherkin
+ * When I make a "PUT" request to "/api/settings"
+ * | Authorization | Bearer my-token |
+ * | body          | {"theme": "dark"} |
+ * ```
+ */
+exports.BrowserFetchRequest = (0, registry_1.Step)('I make a "{word}" request to {string}', async (page, method, url, table) => {
+    const options = { method: method.toUpperCase() };
+    const rows = table && typeof table.rows === "function" ? table.rows() : table || [];
+    if (Array.isArray(rows)) {
+        rows.forEach((row) => {
+            const key = Array.isArray(row) ? row[0] : row.header || row.key;
+            const val = Array.isArray(row) ? row[1] : row.value;
+            if (!key)
+                return;
+            if (key.toLowerCase() === "body") {
+                options.body = val;
+            }
+            else {
+                if (!options.headers)
+                    options.headers = {};
+                options.headers[key] = val;
+            }
+        });
+    }
+    console.log(`⚡ Browser Fetch: ${method} ${url}`);
+    const res = await page.evaluate(async ({ url, options }) => {
+        const response = await fetch(url, options);
+        return {
+            status: response.status,
+            body: await response.text(),
+            headers: Object.fromEntries(response.headers.entries()),
+        };
+    }, { url, options });
+    let jsonBody;
+    try {
+        jsonBody = JSON.parse(res.body);
+    }
+    catch { }
+    (0, state_1.setVariable)(page, "lastResponse", { ...res, json: jsonBody });
+    (0, state_1.setVariable)(page, "lastStatusCode", res.status);
+    console.log(`✅ Status: ${res.status}`);
+});

package/dist/backend/api/requests.d.ts

@@ -1,2 +1,44 @@
-export {};
+/**
+ * @module ApiActions
+ */
+/**
+ * Performs a standard HTTP GET request and stores the response in the global API state.
+ * * @example
+ * ```gherkin
+ * When I make a GET request to "[https://api.example.com/users](https://api.example.com/users)"
+ * ```
+ * * @param url - The full URL or endpoint path.
+ */
+export declare const MakeGetRequest: void;
+/**
+ * Performs a standard HTTP DELETE request and stores the response in the global API state.
+ * * @example
+ * ```gherkin
+ * When I make a DELETE request to "/api/users/1"
+ * ```
+ * * @param url - The endpoint path to delete.
+ */
+export declare const MakeDeleteRequest: void;
+/**
+ * Performs an HTTP POST request using a Gherkin Data Table as the JSON payload.
+ * * @example
+ * ```gherkin
+ * When I make a POST request to "/api/users" with data
+ * | name | John |
+ * | job  | Dev  |
+ * ```
+ * * @param url - The target endpoint.
+ * @param tableData - The Gherkin Data Table (automatically converted to a JSON object).
+ */
+export declare const MakePostRequestWithTable: void;
+/**
+ * Performs an HTTP POST request using the contents of a local JSON file as the payload.
+ * * @example
+ * ```gherkin
+ * When I make a POST request to "/api/users" with payload from "data/user.json"
+ * ```
+ * * @param url - The target endpoint.
+ * @param filePath - Path to the JSON file relative to the project root.
+ */
+export declare const MakePostRequestWithFile: void;
 //# sourceMappingURL=requests.d.ts.map

package/dist/backend/api/requests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requests.d.ts","sourceRoot":"","sources":["../../../src/backend/api/requests.ts"],"names":[],"mappings":""}
+{"version":3,"file":"requests.d.ts","sourceRoot":"","sources":["../../../src/backend/api/requests.ts"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,MAIzB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,MAI5B,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,MAmBpC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,MAoBnC,CAAC"}