import { TaskRequest, TaskResponse } from '../types/performer';
import { IWorker } from '../worker/iWorker';
import { ValidationStage, TaskMetrics } from './taskContext';
import { ILogger } from '../utils/logger';
/**
 * Serialization strategy interface
 */
export interface SerializationStrategy {
    /** Strategy name */
    name: string;
    /** Serialize data to bytes */
    serialize(data: any): Uint8Array;
    /** Deserialize bytes to data */
    deserialize<T = any>(bytes: Uint8Array): T;
    /** Validate if bytes can be deserialized */
    canDeserialize(bytes: Uint8Array): boolean;
}
/**
 * JSON serialization strategy
 */
export declare class JsonSerializationStrategy implements SerializationStrategy {
    name: string;
    serialize(data: any): Uint8Array;
    deserialize<T = any>(bytes: Uint8Array): T;
    canDeserialize(bytes: Uint8Array): boolean;
}
/**
 * Raw bytes serialization strategy
 */
export declare class RawSerializationStrategy implements SerializationStrategy {
    name: string;
    serialize(data: any): Uint8Array;
    deserialize<T = any>(bytes: Uint8Array): T;
    canDeserialize(bytes: Uint8Array): boolean;
}
/**
 * Number serialization strategy (64-bit big-endian)
 */
export declare class NumberSerializationStrategy implements SerializationStrategy {
    name: string;
    serialize(data: any): Uint8Array;
    deserialize<T = any>(bytes: Uint8Array): T;
    canDeserialize(bytes: Uint8Array): boolean;
}
/**
 * Task processing configuration
 */
export interface TaskProcessorConfig {
    /** Default timeout in milliseconds */
    timeout?: number;
    /** Enable metrics collection */
    enableMetrics?: boolean;
    /** Custom validation stages */
    validationStages?: ValidationStage[];
    /** Default serialization strategy */
    defaultSerialization?: SerializationStrategy;
    /** Available serialization strategies */
    serializationStrategies?: Map<string, SerializationStrategy>;
}
/**
 * Enhanced task processor with pipeline support
 */
export declare class TaskProcessor {
    private worker;
    private logger;
    private config;
    private pipeline;
    private metrics;
    constructor(worker: IWorker, logger: ILogger, config?: TaskProcessorConfig);
    /**
     * Process a task with full pipeline support
     */
    processTask(request: TaskRequest): Promise<TaskResponse>;
    /**
     * Execute the worker task with enhanced error handling
     */
    private executeWorkerTask;
    /**
     * Validate task response
     */
    private validateResponse;
    /**
     * Set up the processing pipeline
     */
    private setupPipeline;
    /**
     * Validate task request
     */
    private validateTaskRequest;
    /**
     * Record successful task completion metrics
     */
    private recordTaskCompletion;
    /**
     * Record task failure metrics
     */
    private recordTaskFailure;
    /**
     * Get serialization strategy by name
     */
    getSerializationStrategy(name: string): SerializationStrategy | undefined;
    /**
     * Add custom serialization strategy
     */
    addSerializationStrategy(strategy: SerializationStrategy): void;
    /**
     * Get task execution metrics
     */
    getMetrics(): TaskMetrics[];
    /**
     * Clear accumulated metrics
     */
    clearMetrics(): void;
}
//# sourceMappingURL=taskProcessor.d.ts.map