@testsmith/perfornium 0.6.4 → 0.6.6

package/dist/core/execution/json-payload-processor.d.ts

@@ -0,0 +1,7 @@
+import { RESTStep, VUContext } from '../../config';
+export declare class JSONPayloadProcessor {
+    private templateProcessor;
+    processJsonFile(step: RESTStep, context: VUContext): RESTStep;
+    applyOverrides(obj: any, overrides: Record<string, any>, context: VUContext): any;
+    setNestedValue(obj: any, path: string, value: any): void;
+}

package/dist/core/execution/json-payload-processor.js

@@ -0,0 +1,140 @@
+"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.JSONPayloadProcessor = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const template_1 = require("../../utils/template");
+class JSONPayloadProcessor {
+    constructor() {
+        this.templateProcessor = new template_1.TemplateProcessor();
+    }
+    processJsonFile(step, context) {
+        if (!step.jsonFile) {
+            return step;
+        }
+        // Resolve file path relative to CWD
+        const filePath = path.resolve(process.cwd(), step.jsonFile);
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`JSON payload file not found: ${step.jsonFile}`);
+        }
+        // Load and parse JSON file
+        let payload;
+        try {
+            const fileContent = fs.readFileSync(filePath, 'utf-8');
+            payload = JSON.parse(fileContent);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse JSON file ${step.jsonFile}: ${error.message}`);
+        }
+        // Apply overrides if specified
+        if (step.overrides) {
+            payload = this.applyOverrides(payload, step.overrides, context);
+        }
+        // Return new step with json property set (removing jsonFile and overrides)
+        const { jsonFile, overrides, ...restOfStep } = step;
+        return {
+            ...restOfStep,
+            json: payload
+        };
+    }
+    applyOverrides(obj, overrides, context) {
+        // Deep clone the object to avoid mutating the original
+        const result = JSON.parse(JSON.stringify(obj));
+        const contextData = {
+            __VU: context.vu_id,
+            __ITER: context.iteration,
+            vu_id: context.vu_id,
+            iteration: context.iteration,
+            variables: context.variables || {},
+            extracted_data: context.extracted_data || {},
+            ...context.variables,
+            ...context.extracted_data
+        };
+        for (const [path, value] of Object.entries(overrides)) {
+            // Process template expressions in override values
+            let processedValue = value;
+            if (typeof value === 'string') {
+                processedValue = this.templateProcessor.process(value, contextData);
+                // Try to parse as JSON if it looks like a number, boolean, or object
+                if (processedValue === 'true')
+                    processedValue = true;
+                else if (processedValue === 'false')
+                    processedValue = false;
+                else if (!isNaN(Number(processedValue)) && processedValue !== '') {
+                    processedValue = Number(processedValue);
+                }
+            }
+            this.setNestedValue(result, path, processedValue);
+        }
+        return result;
+    }
+    setNestedValue(obj, path, value) {
+        const keys = path.split('.');
+        let current = obj;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const key = keys[i];
+            // Handle array indices like 'items[0]'
+            const arrayMatch = key.match(/^(.+)\[(\d+)]$/);
+            if (arrayMatch) {
+                const [, prop, index] = arrayMatch;
+                if (!current[prop])
+                    current[prop] = [];
+                if (!current[prop][parseInt(index)])
+                    current[prop][parseInt(index)] = {};
+                current = current[prop][parseInt(index)];
+            }
+            else {
+                if (!current[key] || typeof current[key] !== 'object') {
+                    current[key] = {};
+                }
+                current = current[key];
+            }
+        }
+        const lastKey = keys[keys.length - 1];
+        // Handle array index in last key
+        const arrayMatch = lastKey.match(/^(.+)\[(\d+)]$/);
+        if (arrayMatch) {
+            const [, prop, index] = arrayMatch;
+            if (!current[prop])
+                current[prop] = [];
+            current[prop][parseInt(index)] = value;
+        }
+        else {
+            current[lastKey] = value;
+        }
+    }
+}
+exports.JSONPayloadProcessor = JSONPayloadProcessor;

package/dist/core/factories/index.d.ts

@@ -0,0 +1,2 @@
+export { ProtocolHandlerFactory } from './protocol-handler-factory';
+export { OutputHandlerFactory } from './output-handler-factory';

package/dist/core/factories/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputHandlerFactory = exports.ProtocolHandlerFactory = void 0;
+var protocol_handler_factory_1 = require("./protocol-handler-factory");
+Object.defineProperty(exports, "ProtocolHandlerFactory", { enumerable: true, get: function () { return protocol_handler_factory_1.ProtocolHandlerFactory; } });
+var output_handler_factory_1 = require("./output-handler-factory");
+Object.defineProperty(exports, "OutputHandlerFactory", { enumerable: true, get: function () { return output_handler_factory_1.OutputHandlerFactory; } });

package/dist/core/factories/output-handler-factory.d.ts

@@ -0,0 +1,10 @@
+import { OutputConfig } from '../../config';
+import { OutputHandler } from '../../outputs/base';
+export declare class OutputHandlerFactory {
+    private testName;
+    constructor(testName: string);
+    createOutputs(outputConfigs?: OutputConfig[]): Promise<OutputHandler[]>;
+    private createOutput;
+    private processTemplateFilePath;
+    static finalizeOutputs(outputs: OutputHandler[], summary: any): Promise<void>;
+}

package/dist/core/factories/output-handler-factory.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputHandlerFactory = void 0;
+const csv_1 = require("../../outputs/csv");
+const json_1 = require("../../outputs/json");
+const influxdb_1 = require("../../outputs/influxdb");
+const graphite_1 = require("../../outputs/graphite");
+const webhook_1 = require("../../outputs/webhook");
+const file_manager_1 = require("../../utils/file-manager");
+const logger_1 = require("../../utils/logger");
+class OutputHandlerFactory {
+    constructor(testName) {
+        this.testName = testName;
+    }
+    async createOutputs(outputConfigs) {
+        if (!outputConfigs)
+            return [];
+        const outputs = [];
+        for (const outputConfig of outputConfigs) {
+            // Skip disabled outputs
+            if (outputConfig.enabled === false) {
+                continue;
+            }
+            try {
+                const output = await this.createOutput(outputConfig);
+                if (output) {
+                    await output.initialize();
+                    outputs.push(output);
+                    logger_1.logger.debug(`${outputConfig.type} output initialized`);
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn(`Failed to initialize ${outputConfig.type} output:`, error);
+            }
+        }
+        return outputs;
+    }
+    async createOutput(config) {
+        // Process timestamp templates in file paths
+        const processedFilePath = this.processTemplateFilePath(config.file);
+        switch (config.type) {
+            case 'csv':
+                return new csv_1.CSVOutput(processedFilePath);
+            case 'json':
+                return new json_1.JSONOutput(processedFilePath);
+            case 'influxdb':
+                return new influxdb_1.InfluxDBOutput(config.url, config.database, config.tags);
+            case 'graphite': {
+                const [host, port] = (config.url || 'localhost:2003').split(':');
+                return new graphite_1.GraphiteOutput(host, parseInt(port || '2003'), 'perfornium');
+            }
+            case 'webhook':
+                return new webhook_1.WebhookOutput(config.url, config.headers || {}, 'json', config.template);
+            default:
+                logger_1.logger.warn(`Unsupported output type: ${config.type}`);
+                return null;
+        }
+    }
+    processTemplateFilePath(filePath) {
+        if (!filePath) {
+            return `results/${this.testName}-{{timestamp}}.csv`;
+        }
+        // If no timestamp placeholder exists, automatically add one before the extension
+        let processedPath = filePath;
+        if (!filePath.includes('{{timestamp}}')) {
+            const lastDot = filePath.lastIndexOf('.');
+            if (lastDot > 0) {
+                const name = filePath.substring(0, lastDot);
+                const ext = filePath.substring(lastDot);
+                processedPath = `${name}-{{timestamp}}${ext}`;
+            }
+            else {
+                processedPath = `${filePath}-{{timestamp}}`;
+            }
+        }
+        // Use FileManager to process timestamp templates
+        return file_manager_1.FileManager.processFilePath(processedPath);
+    }
+    static async finalizeOutputs(outputs, summary) {
+        for (const output of outputs) {
+            try {
+                await output.writeSummary(summary);
+                await output.finalize();
+            }
+            catch (error) {
+                logger_1.logger.warn('Output finalization failed:', error);
+            }
+        }
+    }
+}
+exports.OutputHandlerFactory = OutputHandlerFactory;

package/dist/core/factories/protocol-handler-factory.d.ts

@@ -0,0 +1,12 @@
+import { TestConfiguration } from '../../config';
+import { ProtocolHandler } from '../../protocols/base';
+import { MetricsCollector } from '../../metrics/collector';
+export declare class ProtocolHandlerFactory {
+    private config;
+    private metricsCollector?;
+    constructor(config: TestConfiguration, metricsCollector?: MetricsCollector);
+    createHandlers(): Promise<Map<string, ProtocolHandler>>;
+    private getRequiredProtocols;
+    private findWSDLUrl;
+    static cleanupHandlers(handlers: Map<string, ProtocolHandler>): Promise<void>;
+}

package/dist/core/factories/protocol-handler-factory.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtocolHandlerFactory = void 0;
+const handler_1 = require("../../protocols/rest/handler");
+const handler_2 = require("../../protocols/soap/handler");
+const handler_3 = require("../../protocols/web/handler");
+const logger_1 = require("../../utils/logger");
+class ProtocolHandlerFactory {
+    constructor(config, metricsCollector) {
+        this.config = config;
+        this.metricsCollector = metricsCollector;
+    }
+    async createHandlers() {
+        const handlers = new Map();
+        const protocolsNeeded = this.getRequiredProtocols();
+        const debugConfig = this.config.debug || this.config.global?.debug;
+        // Initialize REST handler if needed
+        if (protocolsNeeded.has('rest')) {
+            const handler = new handler_1.RESTHandler(this.config.global?.base_url, this.config.global?.headers || {}, this.config.global?.timeout, debugConfig);
+            handlers.set('rest', handler);
+            logger_1.logger.debug('REST handler initialized');
+        }
+        // Initialize SOAP handler if needed
+        if (protocolsNeeded.has('soap')) {
+            const wsdlUrl = this.findWSDLUrl();
+            if (wsdlUrl) {
+                const handler = new handler_2.SOAPHandler(wsdlUrl);
+                await handler.initialize();
+                handlers.set('soap', handler);
+                logger_1.logger.debug('SOAP handler initialized');
+            }
+        }
+        // Initialize Web handler if needed
+        if (protocolsNeeded.has('web')) {
+            const browserConfig = this.config.global?.web || this.config.global?.browser || {};
+            const webConfig = {
+                type: browserConfig.type || 'chromium',
+                headless: browserConfig.headless ?? true,
+                base_url: browserConfig.base_url || this.config.global?.base_url,
+                viewport: browserConfig.viewport,
+                slow_mo: browserConfig.slow_mo,
+                highlight: browserConfig.highlight,
+                clear_storage: browserConfig.clear_storage,
+                screenshot_on_failure: browserConfig.screenshot_on_failure,
+                network_capture: browserConfig.network_capture
+            };
+            // Pass network call callback to record calls in InfluxDB
+            const networkCallCallback = this.metricsCollector
+                ? (call) => this.metricsCollector.recordNetworkCall(call)
+                : undefined;
+            const handler = new handler_3.WebHandler(webConfig, networkCallCallback);
+            await handler.initialize();
+            handlers.set('web', handler);
+            logger_1.logger.debug('Web handler initialized');
+        }
+        return handlers;
+    }
+    getRequiredProtocols() {
+        const protocols = new Set();
+        for (const scenario of this.config.scenarios) {
+            for (const step of scenario.steps) {
+                protocols.add(step.type || 'rest');
+            }
+        }
+        return protocols;
+    }
+    findWSDLUrl() {
+        // First check global config
+        if (this.config.global?.wsdl_url) {
+            return this.config.global.wsdl_url;
+        }
+        // Fallback: check individual steps (for backward compatibility)
+        for (const scenario of this.config.scenarios) {
+            for (const step of scenario.steps) {
+                if (step.type === 'soap' && 'wsdl' in step && step.wsdl) {
+                    return step.wsdl;
+                }
+            }
+        }
+        return null;
+    }
+    static async cleanupHandlers(handlers) {
+        logger_1.logger.debug('Cleaning up handlers...');
+        for (const [name, handler] of handlers) {
+            try {
+                if (handler.cleanup) {
+                    await handler.cleanup();
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn(`Error cleaning up ${name} handler:`, error);
+            }
+        }
+    }
+}
+exports.ProtocolHandlerFactory = ProtocolHandlerFactory;

package/dist/core/index.d.ts

@@ -1,7 +1,8 @@
 export { TestRunner } from './test-runner';
 export { VirtualUser } from './virtual-user';
 export { StepExecutor } from './step-executor';
-export { CSVDataProvider } from './csv-data-provider';
-export type { CSVDataRow } from './csv-data-provider';
 export { RendezvousManager } from './rendezvous';
 export type { RendezvousConfig, RendezvousResult, RendezvousStats } from './rendezvous';
+export { DataProvider, DataManager, DataRow, DataResult, DataOptions, DataContext } from './data';
+export { DataProvider as CSVDataProvider } from './data';
+export type { DataRow as CSVDataRow } from './data';

package/dist/core/index.js

@@ -1,13 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RendezvousManager = exports.CSVDataProvider = exports.StepExecutor = exports.VirtualUser = exports.TestRunner = void 0;
+exports.CSVDataProvider = exports.DataManager = exports.DataProvider = exports.RendezvousManager = exports.StepExecutor = exports.VirtualUser = exports.TestRunner = void 0;
 var test_runner_1 = require("./test-runner");
 Object.defineProperty(exports, "TestRunner", { enumerable: true, get: function () { return test_runner_1.TestRunner; } });
 var virtual_user_1 = require("./virtual-user");
 Object.defineProperty(exports, "VirtualUser", { enumerable: true, get: function () { return virtual_user_1.VirtualUser; } });
 var step_executor_1 = require("./step-executor");
 Object.defineProperty(exports, "StepExecutor", { enumerable: true, get: function () { return step_executor_1.StepExecutor; } });
-var csv_data_provider_1 = require("./csv-data-provider");
-Object.defineProperty(exports, "CSVDataProvider", { enumerable: true, get: function () { return csv_data_provider_1.CSVDataProvider; } });
 var rendezvous_1 = require("./rendezvous");
 Object.defineProperty(exports, "RendezvousManager", { enumerable: true, get: function () { return rendezvous_1.RendezvousManager; } });
+// Data exports
+var data_1 = require("./data");
+Object.defineProperty(exports, "DataProvider", { enumerable: true, get: function () { return data_1.DataProvider; } });
+Object.defineProperty(exports, "DataManager", { enumerable: true, get: function () { return data_1.DataManager; } });
+// Backward compatibility aliases
+var data_2 = require("./data");
+Object.defineProperty(exports, "CSVDataProvider", { enumerable: true, get: function () { return data_2.DataProvider; } });

package/dist/core/reporting/dashboard-reporter.d.ts

@@ -0,0 +1,17 @@
+import { MetricsCollector } from '../../metrics/collector';
+import { VirtualUser } from '../virtual-user';
+export interface DashboardReporterConfig {
+    testId: string;
+    testName: string;
+}
+export declare class DashboardReporter {
+    private testId;
+    private testName;
+    private dashboardInterval;
+    private lastReportedResultIndex;
+    private isRunning;
+    constructor(config: DashboardReporterConfig);
+    start(metrics: MetricsCollector, getActiveVUs: () => VirtualUser[], isRunningChecker: () => boolean): void;
+    stop(): void;
+    private outputProgress;
+}

package/dist/core/reporting/dashboard-reporter.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardReporter = void 0;
+const dashboard_1 = require("../../dashboard");
+class DashboardReporter {
+    constructor(config) {
+        this.dashboardInterval = null;
+        this.lastReportedResultIndex = 0;
+        this.isRunning = false;
+        this.testId = config.testId;
+        this.testName = config.testName;
+    }
+    start(metrics, getActiveVUs, isRunningChecker) {
+        this.isRunning = true;
+        this.lastReportedResultIndex = 0;
+        const dashboard = (0, dashboard_1.getDashboard)();
+        // If running standalone (no dashboard singleton), output progress to stdout for dashboard parsing
+        const outputProgress = !dashboard && process.env.PERFORNIUM_PROGRESS !== '0';
+        if (dashboard) {
+            // Report initial state to in-process dashboard
+            dashboard.reportLiveUpdate(this.testId, {
+                id: this.testId,
+                name: this.testName,
+                startTime: new Date(),
+                status: 'running',
+                metrics: {
+                    requests: 0,
+                    errors: 0,
+                    avgResponseTime: 0,
+                    currentVUs: 0
+                }
+            });
+        }
+        // Track last request count to detect activity
+        let lastRequestCount = 0;
+        // Report updates every 500ms
+        this.dashboardInterval = setInterval(() => {
+            if (!isRunningChecker())
+                return;
+            const summary = metrics.getSummary();
+            const currentVUs = getActiveVUs().filter(vu => vu.isRunning()).length;
+            const currentRequests = summary.total_requests || 0;
+            // Skip reporting if VUs are 0 and no new requests (test is winding down)
+            const hasActivity = currentVUs > 0 || currentRequests > lastRequestCount;
+            lastRequestCount = currentRequests;
+            if (dashboard) {
+                dashboard.reportLiveUpdate(this.testId, {
+                    metrics: {
+                        requests: currentRequests,
+                        errors: summary.failed_requests || 0,
+                        avgResponseTime: summary.avg_response_time || 0,
+                        currentVUs
+                    }
+                });
+            }
+            // Output machine-readable progress for dashboard parsing (only when there's activity)
+            if (outputProgress && hasActivity) {
+                this.outputProgress(metrics, summary, currentVUs);
+            }
+        }, 500);
+    }
+    stop() {
+        this.isRunning = false;
+        if (this.dashboardInterval) {
+            clearInterval(this.dashboardInterval);
+            this.dashboardInterval = null;
+        }
+        const dashboard = (0, dashboard_1.getDashboard)();
+        if (dashboard) {
+            dashboard.reportTestComplete(this.testId);
+        }
+    }
+    outputProgress(metrics, summary, currentVUs) {
+        const currentRequests = summary.total_requests || 0;
+        const rps = summary.requests_per_second || 0;
+        const p50 = summary.percentiles?.[50] || 0;
+        const p90 = summary.percentiles?.[90] || 0;
+        const p95 = summary.percentiles?.[95] || 0;
+        const p99 = summary.percentiles?.[99] || 0;
+        const successRate = summary.success_rate || 0;
+        // Main progress line with percentiles
+        console.log(`[PROGRESS] VUs: ${currentVUs} | Requests: ${currentRequests} | Errors: ${summary.failed_requests || 0} | Avg RT: ${(summary.avg_response_time || 0).toFixed(0)}ms | RPS: ${rps.toFixed(1)} | P50: ${p50.toFixed(0)}ms | P90: ${p90.toFixed(0)}ms | P95: ${p95.toFixed(0)}ms | P99: ${p99.toFixed(0)}ms | Success: ${successRate.toFixed(1)}%`);
+        // Output step statistics if available
+        if (summary.step_statistics && summary.step_statistics.length > 0) {
+            const stepData = summary.step_statistics.map((s) => ({
+                n: s.step_name,
+                s: s.scenario,
+                r: s.total_requests,
+                e: s.failed_requests,
+                a: Math.round(s.avg_response_time),
+                p50: Math.round(s.percentiles?.[50] || 0),
+                p95: Math.round(s.percentiles?.[95] || 0),
+                p99: Math.round(s.percentiles?.[99] || 0),
+                sr: Math.round(s.success_rate * 10) / 10
+            }));
+            console.log(`[STEPS] ${JSON.stringify(stepData)}`);
+        }
+        // Output individual response times (last 50 new results)
+        const allResults = metrics.getResults();
+        if (allResults.length > this.lastReportedResultIndex) {
+            const newResults = allResults.slice(this.lastReportedResultIndex, this.lastReportedResultIndex + 50);
+            const rtData = newResults.map(r => ({
+                t: r.timestamp,
+                v: Math.round(r.duration),
+                s: r.success ? 1 : 0,
+                n: r.step_name || r.action || 'unknown'
+            }));
+            if (rtData.length > 0) {
+                console.log(`[RT] ${JSON.stringify(rtData)}`);
+            }
+            this.lastReportedResultIndex = Math.min(allResults.length, this.lastReportedResultIndex + 50);
+        }
+        // Output top 10 errors if any
+        if (summary.error_details && summary.error_details.length > 0) {
+            const topErrors = summary.error_details.slice(0, 10).map((e) => ({
+                scenario: e.scenario,
+                action: e.action,
+                status: e.status,
+                error: e.error?.substring(0, 200),
+                url: e.request_url,
+                count: e.count
+            }));
+            console.log(`[ERRORS] ${JSON.stringify(topErrors)}`);
+        }
+    }
+}
+exports.DashboardReporter = DashboardReporter;

package/dist/core/reporting/index.d.ts

@@ -0,0 +1 @@
+export { DashboardReporter, DashboardReporterConfig } from './dashboard-reporter';

package/dist/core/reporting/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardReporter = void 0;
+var dashboard_reporter_1 = require("./dashboard-reporter");
+Object.defineProperty(exports, "DashboardReporter", { enumerable: true, get: function () { return dashboard_reporter_1.DashboardReporter; } });

package/dist/core/step-executor.d.ts

@@ -5,26 +5,17 @@ export declare class StepExecutor {
     private handlers;
     private templateProcessor;
     private testName;
+    private checkEvaluator;
+    private dataExtractor;
+    private jsonPayloadProcessor;
     constructor(handlers: Map<string, ProtocolHandler>, testName?: string);
     executeStep(step: Step, context: VUContext, scenarioName: string): Promise<TestResult>;
+    private createErrorResult;
     executeStepInternal(step: Step, context: VUContext, scenarioName: string, startTime: number): Promise<TestResult>;
+    private createSkippedResult;
+    private buildTestResult;
     private shouldRecordStep;
     private executeRESTStep;
-    /**
-     * Load JSON payload from file and apply overrides
-     * Supports dot notation for nested paths in overrides
-     */
-    private processJsonFile;
-    /**
-     * Apply overrides to a JSON object using dot notation for nested paths
-     * Override values are processed through the template processor
-     */
-    private applyOverrides;
-    /**
-     * Set a value at a nested path using dot notation
-     * Example: setNestedValue(obj, 'user.profile.name', 'John')
-     */
-    private setNestedValue;
     private executeSOAPStep;
     private executeWebStep;
     private executeCustomStep;
@@ -34,9 +25,4 @@ export declare class StepExecutor {
     private executeScript;
     private evaluateCondition;
     private processTemplate;
-    private runChecks;
-    private checkCustom;
-    private extractData;
-    private extractCustom;
-    private getJsonPath;
 }