import { RateLimiter } from '../../infrastructure/http/RateLimiter';
import { Logger } from '../../infrastructure/logging/Logger';
import type { DomainResponse, IPResponse, ASNResponse, NameserverResponse, EntityResponse, AvailabilityResult, ExplainResult, SearchResult } from '../../shared/types';
import type { RDAPClientOptions } from '../../shared/types/options';
import { BatchProcessor } from '../services/BatchProcessor';
import type { BatchQueryRequest, StreamBatchOptions } from '../services/BatchProcessor';
import type { QueryTypeLiteral, BatchQueryResult } from '../../shared/types/generics';
import { MiddlewareManager } from '../hooks/MiddlewareHooks';
import type { MiddlewareOptions } from '../hooks/MiddlewareHooks';
export declare class RDAPClient {
    private readonly options;
    private readonly cache;
    private readonly fetcher;
    private readonly ssrfProtection;
    private readonly bootstrap;
    private readonly normalizer;
    private readonly piiRedactor;
    private readonly orchestrator;
    private readonly rateLimiter;
    private readonly batchProcessor;
    private readonly connectionPool;
    private readonly metricsCollector;
    private readonly logger;
    private readonly middlewareManager;
    private readonly queryDeduplicator;
    private readonly debugEnabled;
    private readonly debugLogger?;
    private readonly nativeBackend;
    constructor(options?: RDAPClientOptions);
    domain(domain: string): Promise<DomainResponse>;
    ip(ip: string): Promise<IPResponse>;
    asn(asn: string | number): Promise<ASNResponse>;
    nameserver(nameserver: string): Promise<NameserverResponse>;
    entity(handle: string, serverUrl: string): Promise<EntityResponse>;
    checkAvailability(domain: string): Promise<AvailabilityResult>;
    checkAvailabilityBatch(domains: string[]): Promise<Map<string, AvailabilityResult>>;
    searchDomains(pattern: string, serverUrl?: string): Promise<SearchResult<DomainResponse>>;
    searchEntities(pattern: string, serverUrl?: string): Promise<SearchResult<EntityResponse>>;
    explain(query: string): Promise<ExplainResult>;
    private pingTelemetry;
    private fetchWithRetry;
    private normalizeOptions;
    validate(): Promise<{
        valid: boolean;
        errors: string[];
        warnings: string[];
    }>;
    clearCache(): Promise<void>;
    getStats(): Promise<{
        cache: {
            size: number;
            enabled: boolean;
            ttl: number;
        };
        bootstrap: {
            size: number;
            types: string[];
        };
    }>;
    getConfig(): Required<RDAPClientOptions>;
    getRateLimiter(): RateLimiter;
    getBatchProcessor(): BatchProcessor;
    streamBatch<T extends QueryTypeLiteral>(requests: BatchQueryRequest<T>[], options?: StreamBatchOptions): AsyncGenerator<BatchQueryResult<T>, void, unknown>;
    getMetrics(since?: number): import("../../infrastructure/monitoring/MetricsCollector").MetricsSummary;
    getConnectionPoolStats(): {
        totalConnections: number;
        activeConnections: number;
        idleConnections: number;
        hosts: number;
    };
    use(hooks: Partial<MiddlewareOptions>): this;
    getMiddlewareManager(): MiddlewareManager;
    getDeduplicatorStats(): {
        enabled: boolean;
        inflight: number;
        windowMs: number;
    };
    getCircuitBreakerStats(): Record<string, {
        state: string;
    }>;
    getLogger(): Logger;
    getLogs(count?: number): import("../../infrastructure/logging/Logger").LogEntry[];
    clearAll(): Promise<void>;
    destroy(): void;
}
//# sourceMappingURL=RDAPClient.d.ts.map