/**
 * E2E Test Runner - Context Factory
 *
 * Creates test execution contexts with access to adapters and variables
 */
import { AdapterRegistry } from '../adapters';
import type { AdapterContext, InterpolationContext, LoadedConfig, Logger, UnifiedTestDefinition } from '../types';
/**
 * Context for a single test execution
 * Provides access to adapters, variables, and captured values
 */
export interface TestContext {
    /** Test definition being executed */
    test: UnifiedTestDefinition;
    /** Adapter registry for database and HTTP access */
    adapters: AdapterRegistry;
    /** Global and test-level variables merged */
    variables: Record<string, unknown>;
    /** Values captured during test execution */
    captured: Record<string, unknown>;
    /** Logger instance */
    logger: Logger;
    /** Base URL for HTTP requests */
    baseUrl: string;
    /** Capture a value for use in subsequent steps */
    capture: (name: string, value: unknown) => void;
    /** Get interpolation context for variable substitution */
    getInterpolationContext: () => InterpolationContext;
    /** Create adapter context for step execution */
    createAdapterContext: () => AdapterContext;
}
/**
 * Factory for creating test execution contexts
 * Manages variable scoping and captured values
 */
export declare class ContextFactory {
    private readonly config;
    private readonly adapters;
    private readonly logger;
    constructor(config: LoadedConfig, adapters: AdapterRegistry, logger: Logger);
    /**
     * Create a new test context for executing a test
     *
     * @param test - The test definition to create context for
     * @returns A new TestContext instance
     */
    createTestContext(test: UnifiedTestDefinition): TestContext;
    /**
     * Get the adapter registry
     */
    getAdapters(): AdapterRegistry;
    /**
     * Get the loaded configuration
     */
    getConfig(): LoadedConfig;
    /**
     * Get the logger instance
     */
    getLogger(): Logger;
}
/**
 * Create a new context factory
 *
 * @param config - Loaded configuration
 * @param adapters - Adapter registry
 * @param logger - Logger instance
 * @returns A new ContextFactory instance
 */
export declare function createContextFactory(config: LoadedConfig, adapters: AdapterRegistry, logger: Logger): ContextFactory;
/**
 * Create a standalone adapter context for ad-hoc operations
 * Useful for hooks or utility functions that need adapter access
 *
 * @param variables - Variables to include
 * @param captured - Captured values
 * @param baseUrl - Base URL for HTTP
 * @param logger - Logger instance
 * @returns An AdapterContext instance
 */
export declare function createStandaloneContext(variables: Record<string, unknown>, captured: Record<string, unknown>, baseUrl: string, logger: Logger): AdapterContext;
/**
 * Create a minimal context for quick operations
 * Uses empty variables and captured values
 *
 * @param baseUrl - Base URL for HTTP
 * @param logger - Logger instance
 * @returns An AdapterContext instance with empty state
 */
export declare function createMinimalContext(baseUrl: string, logger: Logger): AdapterContext;
/**
 * Merge multiple captured value objects
 *
 * @param sources - Array of captured value objects to merge
 * @returns Merged captured values
 */
export declare function mergeCapturedValues(...sources: Record<string, unknown>[]): Record<string, unknown>;
/**
 * Clone a context's captured values
 * Useful for creating snapshots
 *
 * @param captured - Captured values to clone
 * @returns Deep clone of captured values
 */
export declare function cloneCapturedValues(captured: Record<string, unknown>): Record<string, unknown>;
/**
 * Check if a context has a specific captured value
 *
 * @param captured - Captured values object
 * @param name - Name of the value to check
 * @returns True if the value exists
 */
export declare function hasCapturedValue(captured: Record<string, unknown>, name: string): boolean;
/**
 * Get a captured value with type safety
 *
 * @param captured - Captured values object
 * @param name - Name of the value to get
 * @param defaultValue - Default value if not found
 * @returns The captured value or default
 */
export declare function getCapturedValue<T>(captured: Record<string, unknown>, name: string, defaultValue?: T): T | undefined;
//# sourceMappingURL=context-factory.d.ts.map