import type { NeighborhoodFunction, ObjectiveFunction } from '../../search/types';
import type { InitializationOperator } from '../../core/operators/InitializationOperator';
import type { EvaluationOperator } from '../../core/operators/EvaluationOperator';
import type { SelectionOperator } from '../../core/operators/SelectionOperator';
import type { CrossoverOperator } from '../../core/operators/CrossoverOperator';
import type { MutationOperator } from '../../core/operators/MutationOperator';
import type { ReplacementOperator } from '../../core/operators/ReplacementOperator';
import type { TerminationOperator } from '../../core/operators/TerminationOperator';
export interface Individual<T> {
    genome: T;
    fitness: number;
}
export interface MemeticOptions<T> {
    populationSize: number;
    generations: number;
    crossoverRate: number;
    mutationRate: number;
    localSearchRate: number;
    initializationOperator: InitializationOperator<T>;
    evaluationOperator: EvaluationOperator<T>;
    selectionOperator: SelectionOperator<Individual<T>>;
    crossoverOperator: CrossoverOperator<T>;
    mutationOperator: MutationOperator<T>;
    replacementOperator?: ReplacementOperator<Individual<T>>;
    terminationOperator?: TerminationOperator<Individual<T>>;
    objectiveFunction: ObjectiveFunction<T>;
    neighborhoodFunction: NeighborhoodFunction<T>;
    localSearchOptions?: {
        maxIterations?: number;
        maximize?: boolean;
        costFunction?: (solution: T) => number | Promise<number>;
        maximizeCost?: boolean;
    };
    individualFactory: () => T;
}
export declare class MemeticAlgorithm<T> {
    private population;
    private config;
    private localSearcher;
    private bestIndividual;
    constructor(config: MemeticOptions<T>);
    initializePopulation(): Promise<void>;
    evolve(): Promise<Individual<T>>;
    getBestIndividual(): Individual<T>;
    private updateBest;
    getPopulation(): Individual<T>[];
}