playwright-cucumber-ts-steps 1.1.8 → 1.1.10

package/dist/backend/actions/waits.js

@@ -1,22 +1,40 @@
 "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 be idle (no active connections for 500ms).
- * Useful after clicking a button that triggers complex API calls.
- * Pattern: When I wait for network idle
+ * 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.
  */
-(0, registry_1.Step)("I wait for network idle", async (page) => {
+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 state.
- * Options: "load", "domcontentloaded", "networkidle".
- * Pattern: When I wait for load state "domcontentloaded"
+ * 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.
  */
-(0, registry_1.Step)("I wait for load state {string}", async (page, state) => {
+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.`);
     }
@@ -24,28 +42,42 @@ const state_1 = require("../utils/state");
     console.log(`⏳ Reached load state: "${state}"`);
 });
 /**
- * Explicitly waits for the stored element to be visible.
- * Pattern: When I wait for element to be visible
+ * 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
+ * ```
  */
-(0, registry_1.Step)("I wait for element to be visible", async (page) => {
+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 stored element to be hidden/detached.
- * Pattern: When I wait for element to be hidden
+ * 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
+ * ```
  */
-(0, registry_1.Step)("I wait for element to be hidden", async (page) => {
+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 for a specific URL pattern.
- * Pattern: When I wait for URL to contain "dashboard"
+ * 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.
  */
-(0, registry_1.Step)("I wait for URL to contain {string}", async (page, urlPart) => {
+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/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

@@ -1,2 +1,61 @@
-export {};
+/**
+ * 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

@@ -1 +1 @@
-{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../../src/backend/api/network.ts"],"names":[],"mappings":""}
+{"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

@@ -1,26 +1,24 @@
 "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
+/**
+ * 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 if the runner passes them
-    // 1. Remove surrounding triple quotes """ if present
+    // Clean up DocString artifacts
     text = text.replace(/^"""/g, "").replace(/"""$/g, "");
-    // 2. Trim whitespace/newlines
     text = text.trim();
-    // Debug Log: Show exactly what we are trying to parse
-    // console.log(`🔍 [Debug] Parsing JSON for ${context}:`, text);
     try {
         return JSON.parse(text);
     }
     catch (e) {
-        // If simple parse fails, it might be due to unquoted keys or single quotes
-        // You could add a 'loose JSON' parser here if needed, but for now, strict JSON is best.
         throw new Error(`❌ Invalid JSON for ${context}.\nReceived: ${text.slice(0, 50)}...\nError: ${e.message}`);
     }
 }
@@ -28,10 +26,17 @@ function safeJsonParse(input, context) {
 // 1. INTERCEPTION / MOCKING
 // =============================
 /**
- * Intercepts a URL and returns a JSON response (Mocking).
- * Uses Regex to support optional trailing colon.
+ * 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" }
+ * """
+ * ```
  */
-(0, registry_1.Step)(/^I intercept URL "([^"]+)" and stub body:?$/, async (page, url, body) => {
+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({
@@ -44,8 +49,12 @@ function safeJsonParse(input, context) {
 });
 /**
  * Intercepts a URL and stubs it with a raw string (non-JSON).
+ * * @example
+ * ```gherkin
+ * When I intercept URL "/health" and stub body "OK"
+ * ```
  */
-(0, registry_1.Step)("I intercept URL {string} and stub body {string}", async (page, url, body) => {
+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,
@@ -56,9 +65,14 @@ function safeJsonParse(input, context) {
     console.log(`📡 Stubbed "${url}" with raw text: "${body}"`);
 });
 /**
- * Intercepts a URL but allows it to continue (Spying).
+ * 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/*"
+ * ```
  */
-(0, registry_1.Step)("I intercept URL {string}", async (page, url) => {
+exports.InterceptSpy = (0, registry_1.Step)("I intercept URL {string}", async (page, url) => {
     await page.route(url, async (route) => {
         await route.continue();
     });
@@ -68,9 +82,14 @@ function safeJsonParse(input, context) {
 // 2. MAKING API REQUESTS
 // =============================
 /**
- * Makes a GET request and stores the response.
+ * 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)"
+ * ```
  */
-(0, registry_1.Step)("I make request to {string}", async (page, url) => {
+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();
@@ -85,10 +104,16 @@ function safeJsonParse(input, context) {
     console.log(`✅ Status: ${status}`);
 });
 /**
- * Makes a POST request with a JSON body.
- * Uses Regex to support optional trailing colon.
+ * 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" }
+ * """
+ * ```
  */
-(0, registry_1.Step)(/^I make a POST request to "([^"]+)" with JSON body:?$/, async (page, url, docString) => {
+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 });
@@ -104,9 +129,16 @@ function safeJsonParse(input, context) {
     console.log(`✅ Status: ${status}`);
 });
 /**
- * Makes a generic browser-context HTTP request (fetch).
+ * 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"} |
+ * ```
  */
-(0, registry_1.Step)('I make a "{word}" request to {string}', async (page, method, url, table) => {
+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)) {

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"}