/**
 * @nahisaho/yata-scale - Query Coordinator
 *
 * Coordinates query execution across shards
 */
import { type Result } from 'neverthrow';
import type { GraphQuery, QueryResult, QueryPlan, Entity, Relationship } from './types.js';
import { QueryError } from './errors.js';
/**
 * Query planner
 */
export declare class QueryPlanner {
    plan(query: GraphQuery, shards: string[]): QueryPlan;
    optimize(plan: QueryPlan): QueryPlan;
    private generateCacheKey;
}
/**
 * Worker pool for parallel execution
 */
export declare class WorkerPool {
    private concurrency;
    private active;
    private pending;
    constructor(concurrency: number);
    map<T, R>(items: T[], fn: (item: T) => R | Promise<R>): Promise<R[]>;
    filter<T>(items: T[], predicate: (item: T) => boolean | Promise<boolean>): Promise<T[]>;
    reduce<T, R>(items: T[], fn: (acc: R, item: T) => R | Promise<R>, initial: R): Promise<R>;
    get activeCount(): number;
    get pendingCount(): number;
    shutdown(): Promise<void>;
}
/**
 * Distributed query executor
 */
export declare class DistributedExecutor {
    private pool;
    private timeout;
    private stats;
    constructor(concurrency: number, timeout: number);
    execute(query: GraphQuery, shards: string[], executor: (shardId: string, query: GraphQuery) => Promise<{
        entities: Entity[];
        relationships: Relationship[];
    }>): Promise<Result<QueryResult, QueryError>>;
    private executeOnShards;
    private timeoutPromise;
    private mergeResults;
    getStats(): {
        totalQueries: number;
        averageLatency: number;
    };
    shutdown(): Promise<void>;
}
/**
 * Query coordinator
 */
export declare class QueryCoordinator {
    private planner;
    private executor;
    private cache;
    private cacheTtl;
    private stats;
    constructor(concurrency: number, cacheTtl: number, timeout: number);
    query(query: GraphQuery, shards: string[], executor: (shardId: string, query: GraphQuery) => Promise<{
        entities: Entity[];
        relationships: Relationship[];
    }>): Promise<Result<QueryResult, QueryError>>;
    validate(query: GraphQuery): Result<void, QueryError>;
    explain(query: GraphQuery, shards: string[]): string;
    getStats(): {
        cacheHits: number;
        cacheMisses: number;
    };
    clearCache(): void;
    shutdown(): Promise<void>;
}
//# sourceMappingURL=QueryCoordinator.d.ts.map