/**
 * Agentic QE v3 - Requirements Validation Domain Plugin
 * Integrates the requirements validation domain into the kernel
 */
import { DomainName, DomainEvent, Result } from '../../shared/types/index.js';
import { EventBus, MemoryBackend, AgentCoordinator } from '../../kernel/interfaces.js';
import { BaseDomainPlugin } from '../domain-interface.js';
import { IRequirementsValidationService, ITestabilityScoringService, IBDDGenerationService, Requirement, ValidationError, ValidationCriteria, AmbiguityReport, DependencyGraph, TestabilityScore, BDDScenario, RequirementAnalysis, TestArtifacts, SprintValidation } from './interfaces.js';
import { RequirementsValidationCoordinator, CoordinatorConfig, WorkflowStatus } from './coordinator.js';
import { RequirementsValidatorConfig } from './services/requirements-validator.js';
import { BDDScenarioWriterConfig } from './services/bdd-scenario-writer.js';
import { TestabilityScorerConfig } from './services/testability-scorer.js';
export interface RequirementsValidationPluginConfig {
    coordinator?: Partial<CoordinatorConfig>;
    validator?: Partial<RequirementsValidatorConfig>;
    bddWriter?: Partial<BDDScenarioWriterConfig>;
    testabilityScorer?: Partial<TestabilityScorerConfig>;
}
/**
 * Public API for the requirements validation domain
 */
export interface RequirementsValidationAPI {
    validate(requirement: Requirement): Promise<Result<ValidationError[]>>;
    validateAgainstCriteria(requirement: Requirement, criteria: ValidationCriteria): Promise<Result<ValidationError[]>>;
    detectAmbiguity(requirement: Requirement): Promise<Result<AmbiguityReport>>;
    analyzeDependencies(requirements: Requirement[]): Promise<Result<DependencyGraph>>;
    scoreRequirement(requirement: Requirement): Promise<Result<TestabilityScore>>;
    scoreRequirements(requirements: Requirement[]): Promise<Result<Map<string, TestabilityScore>>>;
    suggestImprovements(requirement: Requirement, score: TestabilityScore): Promise<Result<string[]>>;
    meetsThreshold(score: TestabilityScore, threshold: number): boolean;
    generateScenarios(requirement: Requirement): Promise<Result<BDDScenario[]>>;
    generateScenariosWithExamples(requirement: Requirement, exampleCount: number): Promise<Result<BDDScenario[]>>;
    toGherkin(scenarios: BDDScenario[]): string;
    parseGherkin(gherkinText: string): Result<BDDScenario[]>;
    analyzeRequirement(requirementId: string): Promise<Result<RequirementAnalysis>>;
    generateTestArtifacts(requirementId: string): Promise<Result<TestArtifacts>>;
    validateSprintRequirements(requirementIds: string[]): Promise<Result<SprintValidation>>;
}
/**
 * Extended API with internal access
 */
export interface RequirementsValidationExtendedAPI extends RequirementsValidationAPI {
    /** Get the internal coordinator */
    getCoordinator(): RequirementsValidationCoordinator;
    /** Get the validator service */
    getValidator(): IRequirementsValidationService;
    /** Get the BDD writer service */
    getBDDWriter(): IBDDGenerationService;
    /** Get the testability scorer service */
    getTestabilityScorer(): ITestabilityScoringService;
    /** Get active workflows */
    getActiveWorkflows(): WorkflowStatus[];
}
/**
 * Requirements Validation Domain Plugin
 * Provides pre-development requirements analysis capabilities
 */
export declare class RequirementsValidationPlugin extends BaseDomainPlugin {
    private readonly agentCoordinator;
    private coordinator;
    private validator;
    private bddWriter;
    private testabilityScorer;
    private readonly pluginConfig;
    constructor(eventBus: EventBus, memory: MemoryBackend, agentCoordinator: AgentCoordinator, config?: RequirementsValidationPluginConfig);
    get name(): DomainName;
    get version(): string;
    get dependencies(): DomainName[];
    /**
     * Get the domain's public API
     */
    getAPI<T>(): T;
    protected onInitialize(): Promise<void>;
    protected onDispose(): Promise<void>;
    protected subscribeToEvents(): void;
    protected onEvent(event: DomainEvent): Promise<void>;
    private validate;
    private validateAgainstCriteria;
    private detectAmbiguity;
    private analyzeDependencies;
    private scoreRequirement;
    private scoreRequirements;
    private suggestImprovements;
    private meetsThreshold;
    private generateScenarios;
    private generateScenariosWithExamples;
    private toGherkin;
    private parseGherkin;
    private analyzeRequirement;
    private generateTestArtifacts;
    private validateSprintRequirements;
    private handleTestGenerated;
    private handleImpactAnalysis;
    private ensureInitialized;
    private handleError;
    private trackSuccessfulOperation;
    private trackFailedOperation;
}
/**
 * Factory function to create a RequirementsValidationPlugin
 */
export declare function createRequirementsValidationPlugin(eventBus: EventBus, memory: MemoryBackend, agentCoordinator: AgentCoordinator, config?: RequirementsValidationPluginConfig): RequirementsValidationPlugin;
//# sourceMappingURL=plugin.d.ts.map