import { Step, StepExecutionContext } from '../types';
import { StepExecutor, StepExecutionResult, TransformStep, TransformOperation } from './types';
import { Logger } from '../util/logger';
import { SafeExpressionEvaluator } from '../expression-evaluator/safe-evaluator';
import { ReferenceResolver } from '../reference-resolver';
import { PolicyResolver } from '../util/policy-resolver';
/**
 * Core transform executor that handles all transformation operations
 */
export declare class TransformExecutor {
    private expressionEvaluator;
    private referenceResolver;
    private context;
    private logger;
    constructor(expressionEvaluator: SafeExpressionEvaluator, referenceResolver: ReferenceResolver, context: Record<string, any>, logger: Logger);
    execute(operations: TransformOperation[], input: string | any[], step?: Step, signal?: AbortSignal): Promise<any>;
    private executeOperation;
    private executeMap;
    private executeFilter;
    private executeReduce;
    private executeFlatten;
    private executeSort;
    private executeUnique;
    private executeGroup;
    private executeJoin;
    private validateArray;
}
/**
 * Step executor that handles transform steps
 */
export declare class TransformStepExecutor implements StepExecutor {
    private logger;
    private transformExecutor;
    private policyResolver;
    constructor(expressionEvaluator: SafeExpressionEvaluator, referenceResolver: ReferenceResolver, context: Record<string, any>, logger: Logger, policyResolver: PolicyResolver);
    canExecute(step: Step): step is TransformStep;
    execute(step: Step, context: StepExecutionContext, extraContext?: Record<string, any>, signal?: AbortSignal): Promise<StepExecutionResult>;
}