/**
 * Agentic QE v3 - Test Generation Service
 * Implements ITestGenerationService for AI-powered test generation
 *
 * Uses @faker-js/faker for realistic test data generation
 * Uses TypeScript AST parser for code analysis
 */
import { Result } from '../../../shared/types';
import { MemoryBackend } from '../../../kernel/interfaces';
import { GenerateTestsRequest, GeneratedTests, GeneratedTest, TDDRequest, TDDResult, PropertyTestRequest, PropertyTests, TestDataRequest, TestData } from '../interfaces';
/**
 * Interface for the test generation service
 */
export interface ITestGenerationService {
    generateTests(request: GenerateTestsRequest): Promise<Result<GeneratedTests, Error>>;
    generateForCoverageGap(file: string, uncoveredLines: number[], framework: string): Promise<Result<GeneratedTest[], Error>>;
    generateTDDTests(request: TDDRequest): Promise<Result<TDDResult, Error>>;
    generatePropertyTests(request: PropertyTestRequest): Promise<Result<PropertyTests, Error>>;
    generateTestData(request: TestDataRequest): Promise<Result<TestData, Error>>;
}
/**
 * Configuration for the test generator
 */
export interface TestGeneratorConfig {
    defaultFramework: 'jest' | 'vitest' | 'mocha' | 'pytest';
    maxTestsPerFile: number;
    coverageTargetDefault: number;
    enableAIGeneration: boolean;
}
/**
 * Test Generation Service Implementation
 * Uses heuristic analysis and AST parsing to generate test cases from source code
 * Supports TDD workflow, property-based testing, and pattern-aware generation
 */
export declare class TestGeneratorService implements ITestGenerationService {
    private readonly memory;
    private readonly config;
    constructor(memory: MemoryBackend, config?: Partial<TestGeneratorConfig>);
    /**
     * Generate tests for given source files
     */
    generateTests(request: GenerateTestsRequest): Promise<Result<GeneratedTests, Error>>;
    /**
     * Generate tests specifically targeting coverage gaps
     */
    generateForCoverageGap(file: string, uncoveredLines: number[], framework: string): Promise<Result<GeneratedTest[], Error>>;
    /**
     * Generate tests following TDD workflow
     */
    generateTDDTests(request: TDDRequest): Promise<Result<TDDResult, Error>>;
    /**
     * Generate property-based tests
     */
    generatePropertyTests(request: PropertyTestRequest): Promise<Result<PropertyTests, Error>>;
    /**
     * Generate test data based on schema
     */
    generateTestData(request: TestDataRequest): Promise<Result<TestData, Error>>;
    private generateTestsForFile;
    /**
     * Analyze source code using TypeScript AST
     */
    private analyzeSourceCode;
    /**
     * Extract function information from AST
     */
    private extractFunctionInfo;
    /**
     * Extract arrow function information from AST
     */
    private extractArrowFunctionInfo;
    /**
     * Extract class information from AST
     */
    private extractClassInfo;
    /**
     * Extract parameters from a function
     */
    private extractParameters;
    /**
     * Calculate cyclomatic complexity of a node
     */
    private calculateComplexity;
    /**
     * Generate real test code based on AST analysis
     */
    private generateRealTestCode;
    /**
     * Generate real Jest/Vitest test code
     */
    private generateRealJestVitestTest;
    /**
     * Generate tests for a function
     */
    private generateFunctionTests;
    /**
     * Generate test cases for a function
     */
    private generateTestCasesForFunction;
    /**
     * Generate tests for a class
     */
    private generateClassTests;
    /**
     * Generate tests for a class method
     */
    private generateMethodTests;
    /**
     * Generate a test value for a parameter
     */
    private generateTestValue;
    /**
     * Generate real Mocha test code
     */
    private generateRealMochaTest;
    /**
     * Generate Mocha tests for a function
     */
    private generateMochaFunctionTests;
    /**
     * Generate Mocha tests for a class
     */
    private generateMochaClassTests;
    /**
     * Generate real Pytest test code
     */
    private generateRealPytestTest;
    /**
     * Generate Pytest tests for a function
     */
    private generatePytestFunctionTests;
    /**
     * Generate Pytest tests for a class
     */
    private generatePytestClassTests;
    /**
     * Generate a Python test value for a parameter
     */
    private generatePythonTestValue;
    private findApplicablePatterns;
    private generateStubTestCode;
    private generateJestVitestTest;
    /**
     * Generate basic operations test based on patterns
     */
    private generateBasicOpsTest;
    /**
     * Generate edge case test based on patterns
     */
    private generateEdgeCaseTest;
    /**
     * Generate error handling test based on patterns
     */
    private generateErrorHandlingTest;
    private generateMochaTest;
    private generatePytestTest;
    private generateRedPhaseTest;
    /**
     * Generate specific assertions from behavior description
     * Uses NLP-style extraction to infer test values and assertions
     */
    private generateAssertionsFromBehavior;
    /**
     * Extract contextual information from behavior description
     */
    private extractBehaviorContext;
    /**
     * Build function call with appropriate arguments based on context
     */
    private buildFunctionCall;
    private generateGreenPhaseCode;
    /**
     * Infer implementation details from behavior description using heuristics
     * Analyzes the behavior text to determine return type, parameters, and minimal implementation
     */
    private inferImplementationFromBehavior;
    private generateRefactoringSuggestions;
    private generatePropertyTestCode;
    /**
     * Analyze property description to determine generators and assertions
     */
    private analyzePropertyForTestGeneration;
    /**
     * Infer the appropriate fast-check generator from constraints
     */
    private inferGeneratorFromConstraints;
    /**
     * Get a simple generator for a type name
     */
    private getSimpleGenerator;
    /**
     * Generate parameter names from generator list
     */
    private generatePropertyParams;
    /**
     * Generate argument list for function call
     */
    private generatePropertyArgs;
    private inferGenerators;
    private getGeneratorForType;
    private collectArbitraries;
    private generateRecordFromSchema;
    private generateValueForField;
    private generateValueForType;
    private generateStringValue;
    private generateNumberValue;
    private generateAddress;
    private inferValueFromFieldName;
    private callFakerMethod;
    private linkRelatedRecords;
    private generateTestForLines;
    /**
     * Generate actual coverage test code for specific lines
     */
    private generateCoverageTestCode;
    private groupConsecutiveLines;
    private getTestFilePath;
    private extractModuleName;
    private getImportPath;
    private countAssertions;
    private estimateCoverage;
    private camelCase;
    private pascalCase;
    private storeGenerationMetadata;
}
//# sourceMappingURL=test-generator.d.ts.map