import type { ValidationResult, LLMDocumentation, EvaluationType, ExecutionContext } from '../types/base-types';
import type { ContextMetadata } from '../types/context-types';
import type { EvaluationResult } from '../types/command-types';
export declare const EnhancedOnInputSchema: import("../validation/lightweight-validators").RuntimeValidator<unknown>;
export declare const EnhancedOnOutputSchema: import("../validation/lightweight-validators").RuntimeValidator<unknown>;
export type EnhancedOnInput = any;
export type EnhancedOnOutput = any;
export interface EventListener {
    id: string;
    eventType: string;
    target: string | HTMLElement;
    commands: any[];
    context: ExecutionContext;
    options: EventListenerOptions & {
        once?: boolean;
        passive?: boolean;
        capture?: boolean;
        delegated?: boolean;
        filter?: string;
        inSelector?: string;
        every?: boolean;
        throttle?: number;
        debounce?: number;
    };
    isActive: boolean;
    isPaused: boolean;
    executionCount: number;
    lastExecutionTime: number;
    averageExecutionTime: number;
}
export interface EventExecution {
    listenerId: string;
    eventType: string;
    timestamp: number;
    event: Event;
    commands: any[];
    result?: any;
    error?: Error;
    executionTime: number;
    preventDefault: boolean;
    stopPropagation: boolean;
}
export interface EventFilter {
    id: string;
    expression: string;
    compiled: Function;
    isActive: boolean;
}
export declare class TypedOnFeatureImplementation {
    readonly name = "onFeature";
    readonly category: "Frontend";
    readonly description = "Type-safe event handling feature with advanced filtering, throttling, and execution control";
    readonly inputSchema: import("../validation/lightweight-validators").RuntimeValidator<unknown>;
    readonly outputType: EvaluationType;
    private evaluationHistory;
    private listeners;
    private executionHistory;
    private filters;
    private errorHistory;
    private throttleTimers;
    private debounceTimers;
    readonly metadata: ContextMetadata;
    readonly documentation: LLMDocumentation;
    initialize(input: EnhancedOnInput): Promise<EvaluationResult<EnhancedOnOutput>>;
    validate(input: unknown): ValidationResult;
    private initializeConfig;
    private registerEventListener;
    private attachDOMListener;
    private createDOMEventHandler;
    private executeEventHandler;
    private executeCommands;
    private executeBasicCommand;
    private isValidEventType;
    private testEventFilter;
    private testInSelectorFilter;
    private isThrottled;
    private applyDebounce;
    private createEventListener;
    private createEventUnlistener;
    private createEventTrigger;
    private createListenerGetter;
    private createListenerPauser;
    private createListenerResumer;
    private createCommandExecutor;
    private createAsyncExecutor;
    private createExecutionHistoryGetter;
    private createHistoryClearer;
    private createFilterAdder;
    private createFilterRemover;
    private createFilterTester;
    private createFilterGetter;
    private createThrottleController;
    private createDebounceController;
    private createThrottleDelaySetter;
    private createDebounceDelaySetter;
    private createErrorHandler;
    private createErrorHistoryGetter;
    private createErrorClearer;
    private createErrorHandlerSetter;
    private trackPerformance;
    getPerformanceMetrics(): {
        totalInitializations: number;
        successRate: number;
        averageDuration: number;
        lastEvaluationTime: number;
        evaluationHistory: {
            input: EnhancedOnInput;
            output?: EnhancedOnOutput;
            success: boolean;
            duration: number;
            timestamp: number;
        }[];
        totalListeners: number;
        totalExecutions: number;
        totalErrors: number;
        averageExecutionTime: number;
    };
}
export declare function createOnFeature(_eventManager?: unknown): TypedOnFeatureImplementation;
export declare function createOn(event: Partial<EnhancedOnInput['event']>, commands: any[], options?: Partial<EnhancedOnInput>): Promise<EvaluationResult<EnhancedOnOutput>>;
export declare const enhancedOnImplementation: TypedOnFeatureImplementation;
export { TypedOnFeatureImplementation as OnFeature };
//# sourceMappingURL=on.d.ts.map