import type { ContextMetadata, EvaluationResult } from '../types/context-types';
import type { ValidationResult, EvaluationType } from '../types/base-types';
import type { LLMDocumentation } from '../types/command-types';
export declare const InitInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
    [x: string]: unknown;
}>;
export declare const InitOutputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
    [x: string]: unknown;
}>;
export type InitInput = any;
export type InitOutput = any;
export interface InitRegistration {
    id: string;
    element: HTMLElement;
    selector?: string;
    commands: any[];
    timing: {
        immediate: boolean;
        delay: number;
        defer: boolean;
    };
    lifecycle: {
        runOnce: boolean;
        resetOnRemoval: boolean;
        propagateToChildren: boolean;
    };
    execution: {
        parallel: boolean;
        stopOnError: boolean;
        timeout: number;
    };
    state: 'pending' | 'running' | 'completed' | 'error';
    createdAt: number;
    processedAt?: number;
    executionCount: number;
    lastError?: Error;
}
export interface InitExecution {
    id: string;
    registrationId: string;
    element: HTMLElement;
    commands: any[];
    startTime: number;
    endTime?: number;
    duration?: number;
    success: boolean;
    error?: Error;
    result?: any;
}
export interface InitLifecycleEvent {
    type: 'element-added' | 'element-removed' | 'dom-ready' | 'init-start' | 'init-complete' | 'init-error';
    element?: HTMLElement;
    registration?: InitRegistration;
    timestamp: number;
    data?: any;
}
export declare class TypedInitFeatureImplementation {
    readonly name = "initFeature";
    readonly category: "Frontend";
    readonly description = "Type-safe element initialization feature with lifecycle management, error handling, and performance optimization";
    readonly inputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
        [x: string]: unknown;
    }>;
    readonly outputType: EvaluationType;
    private evaluationHistory;
    private registrations;
    private elementRegistrations;
    private executionHistory;
    private lifecycleEvents;
    private errorHistory;
    private processedElements;
    private domObserver?;
    readonly metadata: ContextMetadata;
    readonly documentation: LLMDocumentation;
    initialize(input: InitInput): Promise<EvaluationResult<InitOutput>>;
    validate(input: unknown): ValidationResult;
    private initializeConfig;
    private registerElement;
    private processRegistration;
    private createExecutionContext;
    private executeCommandsSequential;
    private executeCommandsParallel;
    private executeCommand;
    private setupDOMObserver;
    private handleElementAdded;
    private handleElementRemoved;
    private emitLifecycleEvent;
    private isValidSelector;
    private createElementRegistrar;
    private createElementUnregistrar;
    private createElementProcessor;
    private createAllElementsProcessor;
    private createRegistrationChecker;
    private createProcessingChecker;
    private createRegistrationGetter;
    private createRegisteredElementsLister;
    private createCommandExecutor;
    private createParallelExecutor;
    private createRetryExecutor;
    private createExecutionHistoryGetter;
    private createHistoryClearer;
    private createElementAddedHandler;
    private createElementRemovedHandler;
    private createDOMReadyHandler;
    private createSystemResetter;
    private createErrorHandler;
    private createErrorHistoryGetter;
    private createErrorClearer;
    private createErrorHandlerSetter;
    dispose(): void;
    private trackPerformance;
    getPerformanceMetrics(): {
        totalInitializations: number;
        successRate: number;
        averageDuration: number;
        lastEvaluationTime: number;
        evaluationHistory: {
            input: InitInput;
            output?: InitOutput;
            success: boolean;
            duration: number;
            timestamp: number;
        }[];
        totalRegistrations: number;
        totalExecutions: number;
        totalErrors: number;
        processedElementsCount: number;
        lifecycleEventsCount: number;
    };
}
export declare function createInitFeature(): TypedInitFeatureImplementation;
export declare function createInit(target: HTMLElement | string, commands: any[], options?: Partial<InitInput>): Promise<EvaluationResult<InitOutput>>;
export declare const enhancedInitImplementation: TypedInitFeatureImplementation;
export { TypedInitFeatureImplementation as InitFeature };
//# sourceMappingURL=init.d.ts.map