@playq/core 0.2.77

package/dist/exec/sgGenerator.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractStepGroups = extractStepGroups;
+exports.generateStepGroups = generateStepGroups;
+exports.generateStepGroupsIfNeeded = generateStepGroupsIfNeeded;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+function sha256(content) {
+    return crypto_1.default.createHash('sha256').update(content).digest('hex');
+}
+const stepGroupDir = path_1.default.resolve('tests/bdd/step_group');
+const outputFilePath = path_1.default.resolve('tests/bdd/steps/_step_group/stepGroup_steps.ts');
+// ---- Step Group Caching ----
+const cacheFilePath = path_1.default.resolve('_Temp/.cache/stepGroupMeta.json');
+function loadCache() {
+    if (!fs_1.default.existsSync(cacheFilePath))
+        return {};
+    try {
+        return JSON.parse(fs_1.default.readFileSync(cacheFilePath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveCache(data) {
+    fs_1.default.mkdirSync(path_1.default.dirname(cacheFilePath), { recursive: true });
+    fs_1.default.writeFileSync(cacheFilePath, JSON.stringify(data, null, 2), 'utf8');
+}
+function getStepGroupFiles() {
+    if (!fs_1.default.existsSync(stepGroupDir))
+        return [];
+    return fs_1.default.readdirSync(stepGroupDir)
+        .filter(f => f.endsWith('.feature'))
+        .map(file => {
+        const fullPath = path_1.default.join(stepGroupDir, file);
+        const stat = fs_1.default.statSync(fullPath);
+        return { file, fullPath, mtimeMs: stat.mtimeMs };
+    });
+}
+// Regex for valid StepGroup tag
+const stepGroupTagRegex = /^@StepGroup:([a-zA-Z0-9_]+)\.sg$/;
+const scenarioRegex = /^Scenario:\s*(.*)$/;
+const invalidScenarioRegex = /^Scenario Outline:/;
+function extractStepGroups(fileContent, filename) {
+    const lines = fileContent.split(/\r?\n/);
+    // Ensure @StepGroup tag appears before Feature declaration
+    let hasStepGroupTag = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line === '@StepGroup') {
+            hasStepGroupTag = true;
+            break;
+        }
+        if (line.startsWith('Feature:'))
+            break; // Stop if Feature is encountered first
+    }
+    if (!hasStepGroupTag) {
+        console.warn(`⚠️ Skipping file "${filename}" — missing @StepGroup tag before Feature declaration.`);
+        return [];
+    }
+    const stepGroups = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith('@StepGroup:') && !stepGroupTagRegex.test(line)) {
+            throw new Error(`❌ Invalid @StepGroup tag format in file ${filename}.\n` +
+                `   → Offending line: ${line}\n` +
+                `   → Only alphanumeric and underscores are allowed in group names (e.g., @StepGroup:valid_name.sg)`);
+        }
+        const tagMatch = line.match(stepGroupTagRegex);
+        if (tagMatch) {
+            const rawName = tagMatch[1];
+            const groupName = `${rawName}.sg`;
+            // Validate group name: only alphanumeric and underscores allowed
+            if (!/^[a-zA-Z0-9_]+$/.test(rawName)) {
+                throw new Error(`❌ Invalid step group name "${rawName}" in file ${filename}.\n` +
+                    `   → Step group names must be alphanumeric with underscores only (no spaces, dashes, or special characters).`);
+            }
+            // Skip empty lines to find Scenario
+            let j = i + 1;
+            while (j < lines.length && lines[j].trim() === '')
+                j++;
+            if (j < lines.length) {
+                const descLine = lines[j].trim();
+                if (invalidScenarioRegex.test(descLine)) {
+                    throw new Error(`❌ Scenario Outline is not allowed in Step Group files.\n` +
+                        `   → File: ${filename}\n` +
+                        `   → Offending Line: ${j + 1}: ${descLine}`);
+                }
+                const descMatch = descLine.match(scenarioRegex);
+                if (descMatch) {
+                    const description = descMatch[1].trim();
+                    // Collect steps until next @ tag or EOF
+                    const steps = [];
+                    let k = j + 1;
+                    while (k < lines.length && !lines[k].trim().startsWith('@')) {
+                        const rawLine = lines[k];
+                        const stepKeywords = ['*', 'Given', 'When', 'Then', 'And', 'But'];
+                        if (stepKeywords.some(keyword => rawLine.trim().startsWith(keyword))) {
+                            steps.push(rawLine);
+                        }
+                        k++;
+                    }
+                    console.log(`🧪 Captured ${steps.length} steps for group: ${groupName}`);
+                    stepGroups.push({ name: groupName, description, steps });
+                    i = k - 1; // continue after last processed line
+                }
+            }
+        }
+    }
+    return stepGroups;
+}
+function generateStepDef(group) {
+    const { name, description, steps } = group;
+    const commentBlock = steps.length
+        ? [
+            `    /*StepGroup:${name}`,
+            ...steps.map(s => `    ${s.trimEnd()}`),
+            '    */'
+        ].join('\n')
+        : '    // No steps defined';
+    return `Given('Step Group: -${name}- -${description}-', async function () {
+${commentBlock}
+});`;
+}
+function run(options = {}) {
+    const cachedTimes = loadCache();
+    const filesMeta = getStepGroupFiles();
+    const defStat = fs_1.default.existsSync(outputFilePath) ? fs_1.default.statSync(outputFilePath) : null;
+    const cachedDefMtime = cachedTimes["__stepGroupDef"];
+    const stepGroupJsonCachePath = path_1.default.resolve('_Temp/.cache/stepGroup_cache.json');
+    const cacheStat = fs_1.default.existsSync(stepGroupJsonCachePath) ? fs_1.default.statSync(stepGroupJsonCachePath) : null;
+    const cachedJsonDefMtime = cachedTimes["__stepGroupCache"];
+    if (!options.force &&
+        defStat &&
+        defStat.mtimeMs === cachedDefMtime &&
+        cacheStat &&
+        cacheStat.mtimeMs === cachedJsonDefMtime &&
+        filesMeta.every(f => cachedTimes[f.file] === f.mtimeMs)) {
+        // All step group files, generated output, and cache are up-to-date
+        console.log('⏩ Step group definitions are up-to-date. Skipping regeneration.');
+        return;
+    }
+    const shouldReprocessAll = options.force ||
+        (defStat && defStat.mtimeMs !== cachedDefMtime) ||
+        (cacheStat && cacheStat.mtimeMs !== cachedJsonDefMtime);
+    const changedFiles = shouldReprocessAll
+        ? filesMeta
+        : filesMeta.filter(f => cachedTimes[f.file] !== f.mtimeMs);
+    const allGroups = [];
+    changedFiles.forEach(({ file, fullPath }) => {
+        const content = fs_1.default.readFileSync(fullPath, 'utf8');
+        const groups = extractStepGroups(content, file);
+        allGroups.push(...groups);
+    });
+    const groupListBlock = `/*@StepGroupList\n${JSON.stringify({ groups: allGroups.map(g => g.name) }, null, 2)}\n*/\n\n`;
+    const header = `// ************************** IMPORTANT **************************
+// This file is auto-generated by PlayQ for Step Group.
+// Do not edit it manually. File is auto-generated.
+// Any changes done directly will be lost on the next generation.
+// ***************************************************************
+
+import { Given } from '@cucumber/cucumber';
+
+`;
+    const output = groupListBlock + header + allGroups.map(generateStepDef).join('\n\n') + '\n';
+    const stepGroupJsonCache = {};
+    allGroups.forEach(group => {
+        stepGroupJsonCache[group.name] = {
+            description: group.description,
+            steps: group.steps
+        };
+    });
+    // --- Validate existing cache before regeneration ---
+    const stepGroupCacheStr = JSON.stringify(stepGroupJsonCache, null, 2);
+    if (fs_1.default.existsSync(stepGroupJsonCachePath)) {
+        const currentCache = fs_1.default.readFileSync(stepGroupJsonCachePath, 'utf8');
+        const currentHash = sha256(currentCache);
+        const newHash = sha256(stepGroupCacheStr);
+        if (currentHash !== newHash) {
+            console.warn('⚠️ Detected changes in stepGroup_cache.json — file appears to have been modified. It will be regenerated.');
+        }
+    }
+    fs_1.default.mkdirSync(path_1.default.dirname(stepGroupJsonCachePath), { recursive: true });
+    fs_1.default.writeFileSync(stepGroupJsonCachePath, stepGroupCacheStr, 'utf8');
+    const existingOutput = fs_1.default.existsSync(outputFilePath)
+        ? fs_1.default.readFileSync(outputFilePath, 'utf8')
+        : '';
+    if (sha256(existingOutput) === sha256(output)) {
+        console.log('⏩ No changes in generated output. Skipping file write.');
+    }
+    else {
+        fs_1.default.mkdirSync(path_1.default.dirname(outputFilePath), { recursive: true });
+        fs_1.default.writeFileSync(outputFilePath, output, 'utf8');
+        console.log(`✅ Generated ${allGroups.length} Step Group definitions to ${outputFilePath}`);
+    }
+    const updatedCache = loadCache(); // Load existing cache
+    // Update feature file mtimes
+    filesMeta.forEach(f => {
+        updatedCache[f.file] = f.mtimeMs;
+    });
+    // Add or update stepGroup_steps.ts mtime
+    const finalDefStat = fs_1.default.statSync(outputFilePath);
+    updatedCache["__stepGroupDef"] = finalDefStat.mtimeMs;
+    // Add or update stepGroup_cache.json mtime (after writing to ensure freshness)
+    const finalJsonCacheStat = fs_1.default.statSync(stepGroupJsonCachePath);
+    updatedCache["__stepGroupCache"] = finalJsonCacheStat.mtimeMs;
+    saveCache(updatedCache);
+}
+if (require.main === module) {
+    run(); // Only run if this file is the entry point (e.g., called via CLI)
+}
+function generateStepGroups(options = {}) {
+    run(options);
+}
+// Exported utility to run step group generation, with optional force
+function generateStepGroupsIfNeeded(force = false) {
+    generateStepGroups({ force });
+}
+// import fs from 'fs';
+// import path from 'path';
+// const stepGroupDir = path.resolve('test/_step_group');
+// const outputFilePath = path.resolve('test/steps/_step_group/stepGroup_steps.ts');
+// function extractStepGroups(): {
+//   groupName: string;
+//   description: string;
+//   steps: string[];
+// }[] {
+//   const groupPattern = /^@<([\w\-\.]+)\/>$/;
+//   const endGroupPattern = /^@<\/([\w\-\.]+)>$/;
+//   const stepGroupFiles = fs.readdirSync(stepGroupDir)
+//     .filter(file => /\.(steps\.feature|step\.feature|sg\.feature|steps\.sg\.feature)$/i.test(file));
+//   const stepGroups: {
+//     groupName: string;
+//     description: string;
+//     steps: string[];
+//   }[] = [];
+//   stepGroupFiles.forEach(file => {
+//     const fullPath = path.join(stepGroupDir, file);
+//     const fileContent = fs.readFileSync(fullPath, 'utf-8').trim().split('\n');
+//     let currentGroup = "";
+//     let groupDesc = "";
+//     const groupLines: string[] = [];
+//     fileContent.forEach(line => {
+//       const trimmedLine = line.trim();
+//       const startMatch = trimmedLine.match(groupPattern);
+//       const endMatch = trimmedLine.match(endGroupPattern);
+//       if (startMatch) {
+//         currentGroup = startMatch[1];
+//         groupDesc = "";
+//         return;
+//       }
+//       if (trimmedLine.startsWith('@desc:') && currentGroup) {
+//         groupDesc = trimmedLine.replace('@desc:', '').trim();
+//         return;
+//       }
+//       if (endMatch && endMatch[1] === currentGroup) {
+//         stepGroups.push({
+//           groupName: currentGroup,
+//           description: groupDesc,
+//           steps: [...groupLines]
+//         });
+//         currentGroup = "";
+//         groupDesc = "";
+//         groupLines.length = 0;
+//         return;
+//       }
+//       if (currentGroup && trimmedLine !== '') {
+//         groupLines.push(trimmedLine);
+//       }
+//     });
+//   });
+//   return stepGroups;
+// }
+// function generateStepDefinitions(stepGroups: {
+//   groupName: string;
+//   description: string;
+//   steps: string[];
+// }[]) {
+//   const lines: string[] = [];
+//   lines.push('// ************************** IMPORTANT **************************');
+//   lines.push('// This file is auto-generated by PlayQ for Step Group.');
+//   lines.push('// Do not edit it manually. File is auto-generated.');
+//   lines.push('// Any changes done directly will be lost on the next generation.');
+//   lines.push('// ***************************************************************');
+//   lines.push('');
+//   lines.push("import { Given } from '@cucumber/cucumber';");
+//   lines.push('');
+//   stepGroups.forEach(group => {
+//     lines.push(`Given('Step Group: -${group.groupName}- -${group.description}-', async function () {`);
+//     lines.push(`  console.log("Step Group: -${group.groupName}- <${group.description}>");`);
+//     lines.push('});');
+//     lines.push('');
+//   });
+//   fs.mkdirSync(path.dirname(outputFilePath), { recursive: true });
+//   fs.writeFileSync(outputFilePath, lines.join('\n'), 'utf-8');
+//   console.log(`✅ Step definitions generated: ${outputFilePath}`);
+// }
+// function run() {
+//   const stepGroups = extractStepGroups();
+//   if (stepGroups.length === 0) {
+//     console.warn('⚠️  No step groups found to generate.');
+//     return;
+//   }
+//   generateStepDefinitions(stepGroups);
+// }
+// run();

package/dist/global.d.ts

@@ -0,0 +1,15 @@
+import * as vars from './helper/bundle/vars';
+import { webFixture } from './helper/fixtures/webFixture';
+import { logFixture } from './helper/fixtures/logFixture';
+import * as utils from './helper/util/utils';
+import { faker } from './helper/faker/customFaker';
+import { webLocResolver } from './helper/fixtures/webLocFixture';
+import * as comm from './helper/actions/commActions';
+import * as web from './helper/actions/webActions';
+import * as api from './helper/actions/apiActions';
+import { dataTest } from './helper/util/test-data/dataTest';
+declare const addons: any;
+declare const engines: any;
+declare const config: any;
+declare let loc: any;
+export { vars, webLocResolver, webFixture, logFixture, utils, faker, comm, web, api, dataTest, addons, engines, config, loc };

package/dist/global.js

@@ -0,0 +1,185 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loc = exports.config = exports.engines = exports.addons = exports.dataTest = exports.api = exports.web = exports.comm = exports.faker = exports.utils = exports.logFixture = exports.webFixture = exports.webLocResolver = exports.vars = void 0;
+const vars = __importStar(require("./helper/bundle/vars"));
+exports.vars = vars;
+const webFixture_1 = require("./helper/fixtures/webFixture");
+Object.defineProperty(exports, "webFixture", { enumerable: true, get: function () { return webFixture_1.webFixture; } });
+const logFixture_1 = require("./helper/fixtures/logFixture");
+Object.defineProperty(exports, "logFixture", { enumerable: true, get: function () { return logFixture_1.logFixture; } });
+const utils = __importStar(require("./helper/util/utils"));
+exports.utils = utils;
+const customFaker_1 = require("./helper/faker/customFaker");
+Object.defineProperty(exports, "faker", { enumerable: true, get: function () { return customFaker_1.faker; } });
+const webLocFixture_1 = require("./helper/fixtures/webLocFixture");
+Object.defineProperty(exports, "webLocResolver", { enumerable: true, get: function () { return webLocFixture_1.webLocResolver; } });
+const locAggregate_1 = require("./helper/fixtures/locAggregate");
+const comm = __importStar(require("./helper/actions/commActions"));
+exports.comm = comm;
+const web = __importStar(require("./helper/actions/webActions"));
+exports.web = web;
+const api = __importStar(require("./helper/actions/apiActions"));
+exports.api = api;
+const dataTest_1 = require("./helper/util/test-data/dataTest");
+Object.defineProperty(exports, "dataTest", { enumerable: true, get: function () { return dataTest_1.dataTest; } });
+const addons = (() => {
+    const root = process.env.PLAYQ_PROJECT_ROOT || process.cwd();
+    const tryReq = (id) => { try {
+        return require(id);
+    }
+    catch {
+        return undefined;
+    } };
+    // Prefer absolute path in new layout, then new alias; no legacy fallbacks
+    return (tryReq(require('path').join(root, 'playq', 'addons')) ||
+        tryReq('@project/addons') ||
+        undefined);
+})();
+exports.addons = addons;
+const engines = (() => {
+    const root = process.env.PLAYQ_PROJECT_ROOT || process.cwd();
+    const tryReq = (id) => { try {
+        return require(id);
+    }
+    catch {
+        return undefined;
+    } };
+    const pathMod = require('path');
+    // Start with index exports to bring in lazy wrappers (patternIq, smartAi)
+    const merged = {};
+    const idxAbs = tryReq(pathMod.join(root, 'playq', 'engines'));
+    if (idxAbs)
+        Object.assign(merged, idxAbs);
+    const idxAlias = tryReq('@project/engines');
+    if (idxAlias)
+        Object.assign(merged, idxAlias);
+    // Supplement with direct engines if missing
+    const directPattern = [
+        pathMod.join(root, 'playq', 'engines', 'patternIq', 'patternIqEngine'),
+        '@project/engines/patternIq/patternIqEngine',
+    ];
+    for (const id of directPattern) {
+        if (!merged.patternIq) {
+            const mod = tryReq(id);
+            if (mod)
+                merged.patternIq = mod.patternIq || mod.default || mod;
+        }
+    }
+    const directSmart = [
+        pathMod.join(root, 'playq', 'engines', 'smartAi', 'smartAiEngine'),
+        '@project/engines/smartAi/smartAiEngine',
+    ];
+    for (const id of directSmart) {
+        if (!merged.smartAi) {
+            const mod = tryReq(id);
+            if (mod)
+                merged.smartAi = mod.smartAi || mod.default || mod;
+        }
+    }
+    return merged;
+})();
+exports.engines = engines;
+const config = (() => {
+    const pathMod = require('path');
+    const root = process.env.PLAYQ_PROJECT_ROOT || process.cwd();
+    const configBase = pathMod.join(root, 'resources', 'config');
+    let resolvedPath = '';
+    let configObj = {};
+    try {
+        // // Try .js first (for built/production), then .ts (for ts-node/dev)
+        // if (require('fs').existsSync(configBase + '.js')) {
+        //     resolvedPath = configBase + '.js';
+        // } else if (require('fs').existsSync(configBase + '.ts')) {
+        //     resolvedPath = configBase + '.ts';
+        // }
+        resolvedPath = configBase + '.ts';
+        if (resolvedPath) {
+            configObj = require(resolvedPath).config || {};
+        }
+    }
+    catch {
+        configObj = {};
+    }
+    return configObj;
+})();
+exports.config = config;
+const testType = process.env.TEST_TYPE;
+const allowedTypes = ['ui', 'api', 'mobile'];
+globalThis.runType = allowedTypes.includes(testType)
+    ? testType
+    : 'ui';
+globalThis.vars = vars;
+globalThis.webLocResolver = webLocFixture_1.webLocResolver;
+globalThis.uiFixture = webFixture_1.webFixture;
+globalThis.logFixture = logFixture_1.logFixture;
+globalThis.utils = utils;
+globalThis.faker = customFaker_1.faker;
+globalThis.comm = comm;
+globalThis.web = web;
+globalThis.api = api;
+globalThis.dataTest = dataTest_1.dataTest;
+// Build and expose 'loc' namespace; prefer folder auto-discovery to avoid requiring an index file
+(() => {
+    try {
+        // First: dynamic aggregator scanning the project folder for *.loc.(ts|js)
+        const locNs = (0, locAggregate_1.getLocNamespace)();
+        if (locNs && Object.keys(locNs).length > 0) {
+            globalThis.loc = locNs;
+            return;
+        }
+    }
+    catch { }
+    try {
+        // Fallback: attempt to load the consumer's loc namespace via tsconfig-paths alias
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const mod = require('@resources/locators');
+        const locNs = mod.default && typeof mod.default === 'object' ? { ...mod.default, ...mod } : mod;
+        globalThis.loc = locNs;
+    }
+    catch (e) {
+        console.warn('⚠️ Unable to initialize loc namespace (no folder matches or alias module):', (e === null || e === void 0 ? void 0 : e.message) || e);
+    }
+})();
+globalThis.addons = addons;
+globalThis.engines = engines;
+// Export a stable 'loc' binding for consumers: import { loc } from '@playq/core'
+let loc;
+try {
+    exports.loc = loc = globalThis.loc || (0, locAggregate_1.getLocNamespace)() || {};
+}
+catch {
+    exports.loc = loc = {};
+}

package/dist/helper/actions/api/apiRequestActions.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Api: Call api -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ *
+ * Calls a predefined API action using configuration from a resource file, supporting dynamic variable replacement,
+ * custom headers, body, parameters, authentication, and assertion of expected status codes.
+ *
+ * This function is designed for hybrid Playwright/Cucumber test frameworks, enabling enterprise-grade API testing
+ * with robust error handling and flexible options.
+ *
+ * @param action - The API action name (corresponds to a file in `resources/api/{action}.api.ts`).
+ * @param config - The configuration key within the API module (e.g., "success", "errorCase").
+ * @param baseUrl - The base URL for the API endpoint.
+ * @param options - Optional. Additional options as a JSON string or object. Supports:
+ *   - `maxUrlRedirects`: Maximum number of redirects (default: from config or 5).
+ *   - `maxTimeout`: Request timeout in milliseconds (default: from config or 10000).
+ *   - `auth`: Axios authentication object.
+ *   - Any other Axios request config options.
+ *
+ * @throws Error if the API config is not found or if the response status does not match `expectedStatus` in config.
+ *
+ * @example
+ * // Example API config file: resources/api/user.api.ts
+ * export const api = {
+ *   getUser: {
+ *     path: "/users/{userId}",
+ *     method: "GET",
+ *     headers: { "Authorization": "Bearer ${token}" },
+ *     expectedStatus: "200"
+ *   }
+ * };
+ *
+ * // Usage in test:
+ * await callApi(
+ *   "user",
+ *   "getUser",
+ *   "https://api.example.com",
+ *   { userId: "123", token: "abc123" }
+ * );
+ *
+ * @example
+ * // With options as a JSON string:
+ * await callApi(
+ *   "user",
+ *   "getUser",
+ *   "https://api.example.com",
+ *   '{"userId":"123","token":"abc123","maxTimeout":5000}'
+ * );
+ *
+ * @example
+ * // With custom authentication:
+ * await callApi(
+ *   "user",
+ *   "getUser",
+ *   "https://api.example.com",
+ *   { auth: { username: "admin", password: "secret" } }
+ * );
+ */
+export declare function callApi(action: string, config: string, baseUrl: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Api: Get -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ *
+ * Sends a GET-style request using an API config. Alias of `callApi`.
+ *
+ * @param action - API action name.
+ * @param config - Config key within the action module.
+ * @param baseUrl - Base URL for the request.
+ * @param options - Additional options forwarded to `callApi`.
+ */
+export declare function get(action: string, config: string, baseUrl: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Api: Post -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ *
+ * Sends a POST-style request using an API config. Alias of `callApi`.
+ *
+ * @param action - API action name.
+ * @param config - Config key within the action module.
+ * @param baseUrl - Base URL for the request.
+ * @param options - Additional options forwarded to `callApi`.
+ */
+export declare function post(action: string, config: string, baseUrl: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Api: Request -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ *
+ * Sends a request (generic wrapper). Alias of `callApi`.
+ *
+ * @param action - API action name.
+ * @param config - Config key within the action module.
+ * @param baseUrl - Base URL for the request.
+ * @param options - Additional options forwarded to `callApi`.
+ */
+export declare function request(action: string, config: string, baseUrl: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Api: Put -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ * Sends a PUT-style request using an API config. Alias of callApi.
+ */
+export declare function put(action: string, config: string, baseUrl: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Api: Patch -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ * Sends a PATCH-style request using an API config. Alias of callApi.
+ */
+export declare function patch(action: string, config: string, baseUrl: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Api: Delete -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ * Sends a DELETE-style request using an API config. Alias of callApi.
+ */
+export declare function del(action: string, config: string, baseUrl: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Api: Send request -method: {param} -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ *
+ * Sends an HTTP request using the specified method and API config.
+ * @param method - HTTP method (GET, POST, PUT, PATCH, DELETE, etc.)
+ * @param action - API action name.
+ * @param config - Config key within the action module.
+ * @param baseUrl - Base URL for the request.
+ * @param options - Additional options forwarded to callApi.
+ */
+export declare function sendRequest(method: string, action: string, config: string, baseUrl: string, options?: string | Record<string, any>): Promise<void>;