import type { ASTNode, ExecutionContext, CommandNode, EventHandlerNode } from '../types/base-types';
import type { ExecutionResult, ExecutionSignal } from '../types/result';
import type { RuntimeHooks } from '../types/hooks';
import { HookRegistry } from '../types/hooks';
import { BaseExpressionEvaluator } from '../core/base-expression-evaluator';
import { CommandRegistryV2 as CommandRegistry } from './command-adapter';
import { CleanupRegistry } from './cleanup-registry';
import { RegistryIntegration, type RegistryIntegrationOptions } from '../registry/runtime-integration';
export interface RuntimeBaseOptions {
    registry: CommandRegistry;
    enableAsyncCommands?: boolean;
    commandTimeout?: number;
    enableErrorReporting?: boolean;
    enableResultPattern?: boolean;
    expressionEvaluator: BaseExpressionEvaluator;
    hooks?: RuntimeHooks;
    enableAutoCleanup?: boolean;
    registryIntegration?: RegistryIntegrationOptions | boolean;
}
export declare class RuntimeBase {
    protected options: RuntimeBaseOptions;
    protected registry: CommandRegistry;
    protected expressionEvaluator: BaseExpressionEvaluator;
    behaviorRegistry: Map<string, any>;
    behaviorAPI: any;
    protected globalVariables: Map<string, any>;
    protected hookRegistry: HookRegistry;
    protected cleanupRegistry: CleanupRegistry;
    private autoCleanupObserver;
    protected registryIntegration: RegistryIntegration | null;
    constructor(options: RuntimeBaseOptions);
    private setupAutoCleanup;
    registerHooks(name: string, hooks: RuntimeHooks): void;
    unregisterHooks(name: string): boolean;
    getRegisteredHooks(): string[];
    cleanup(element: Element): number;
    cleanupTree(element: Element): number;
    getCleanupStats(): ReturnType<CleanupRegistry['getStats']>;
    destroy(): void;
    execute(node: ASTNode, context: ExecutionContext): Promise<unknown>;
    protected processCommand(node: CommandNode, context: ExecutionContext): Promise<unknown>;
    protected toSignal(error: unknown): ExecutionSignal | null;
    protected processCommandWithResult(node: CommandNode, context: ExecutionContext): Promise<ExecutionResult<unknown>>;
    protected executeCommandSequenceWithResult(commands: ASTNode[], context: ExecutionContext): Promise<ExecutionResult<unknown>>;
    protected evaluateExpression(node: ASTNode, context: ExecutionContext): Promise<unknown>;
    protected evaluateExpressionWithResult(node: ASTNode, context: ExecutionContext): Promise<ExecutionResult<unknown>>;
    protected executeCommandFromPattern(commandName: string, selector: string, context: ExecutionContext): Promise<unknown>;
    protected executeProgram(node: any, context: ExecutionContext): Promise<unknown>;
    protected executeBlock(node: any, context: ExecutionContext): Promise<void>;
    protected executeCommandSequence(node: {
        commands: ASTNode[];
    }, context: ExecutionContext): Promise<unknown>;
    protected executeObjectLiteral(node: {
        properties: Array<{
            key: ASTNode;
            value: ASTNode;
        }>;
    }, context: ExecutionContext): Promise<Record<string, unknown>>;
    protected enhanceContext(baseContext: ExecutionContext): ExecutionContext;
    protected executeBehaviorDefinition(node: any, _context: ExecutionContext): Promise<void>;
    protected installBehaviorOnElement(behaviorName: string, element: HTMLElement, parameters: Record<string, any>): Promise<void>;
    protected executeEventHandler(node: EventHandlerNode, context: ExecutionContext): Promise<void>;
    protected setupMutationObserver(targets: HTMLElement[], attr: string, commands: ASTNode[], context: ExecutionContext): void;
    protected setupChangeObserver(watchTarget: ASTNode, commands: ASTNode[], context: ExecutionContext): Promise<void>;
    protected queryElements(selector: string, context: ExecutionContext): HTMLElement[];
    protected isElement(obj: unknown): obj is HTMLElement;
}
//# sourceMappingURL=runtime-base.d.ts.map