export declare const DEFAULT_EDGE_RELAYS: string[];
/**
 * Fallback relays for regional availability
 */
export declare const REGIONAL_FALLBACK_RELAYS: Record<string, string[]>;
/**
 * Metrics for relay discovery and WASM loading
 */
export interface DiscoveryMetrics {
    wasmLoadAttempts: number;
    wasmLoadSuccesses: number;
    wasmLoadFailures: number;
    wasmVerificationSuccesses: number;
    wasmVerificationFailures: number;
    relaysDiscovered: number;
    fallbacksUsed: number;
    lastLoadTime: number | null;
    lastLoadDuration: number | null;
    lastError: string | null;
}
/** Response from /api/relay/status */
export interface RelayStatus {
    peer_id: string;
    connections: number;
    max_connections: number;
    load: number;
    mode: string;
    version: string;
    uptime_seconds: number;
}
/** Relay probe result enriched with latency measurement */
export interface RelayProbeResult {
    multiaddr: string;
    status: RelayStatus | null;
    latencyMs: number;
    probeTime: number;
    error: string | null;
}
/**
 * Convert a libp2p multiaddr to an HTTP(S) URL for the relay status endpoint.
 *
 * - /dns4/example.com/tcp/443/wss/p2p/... → https://example.com/api/relay/status
 * - /ip4/1.2.3.4/tcp/8080/ws/p2p/...     → http://1.2.3.4:8080/api/relay/status
 *
 * Returns null if the multiaddr cannot be converted (e.g., QUIC-only).
 */
export declare function multiaddrToStatusURL(ma: string): string | null;
/**
 * Get current discovery metrics
 */
export declare function getDiscoveryMetrics(): Readonly<DiscoveryMetrics>;
/**
 * Reset discovery metrics (useful for testing)
 */
export declare function resetDiscoveryMetrics(): void;
/**
 * Load edge relays from the encrypted WASM module
 */
export declare function loadEdgeRelays(): Promise<string[]>;
/**
 * Get bootstrap relay addresses
 * This is the main entry point for SDNNode initialization
 */
export declare function getBootstrapRelays(): Promise<string[]>;
/**
 * Check if the WASM module was verified
 */
export declare function isWasmVerified(): boolean;
/**
 * Get relays for a specific region (fallback)
 */
export declare function getRegionalRelays(region?: string): string[];
/**
 * Get all fallback relays (default + regional)
 */
export declare function getAllFallbackRelays(): string[];
/**
 * Edge relay discovery class for dynamic relay management
 */
export declare class EdgeDiscovery {
    private knownRelays;
    private failedRelays;
    private refreshInterval;
    private maxFailures;
    private probeResults;
    private probeInterval;
    private probeTimeoutMs;
    private probeStalenessMs;
    constructor(initialRelays?: string[]);
    /**
     * Get all known relay addresses
     */
    getRelays(): string[];
    /**
     * Add a new relay address
     */
    addRelay(addr: string): void;
    /**
     * Remove a relay address
     */
    removeRelay(addr: string): void;
    /**
     * Check if a relay is known
     */
    hasRelay(addr: string): boolean;
    /**
     * Mark a relay as failed (tracks failures for reliability scoring)
     */
    markFailed(addr: string): void;
    /**
     * Mark a relay as successful (resets failure count)
     */
    markSuccess(addr: string): void;
    /**
     * Probe a single relay's /api/relay/status endpoint.
     * Measures latency and caches the result.
     */
    probeRelay(addr: string): Promise<RelayProbeResult>;
    /**
     * Probe all known relays concurrently.
     */
    probeAllRelays(): Promise<Map<string, RelayProbeResult>>;
    /**
     * Start periodic relay probing for load balancing.
     */
    startProbing(intervalMs?: number): void;
    /**
     * Stop periodic relay probing.
     */
    stopProbing(): void;
    /**
     * Get cached probe result for a relay.
     */
    getProbeResult(addr: string): RelayProbeResult | undefined;
    /**
     * Get the best relays scored by load, latency, and failure history.
     *
     * Score (lower is better):
     *   score = (load * 50) + (normalizedLatency * 30) + (failureScore * 20)
     *
     * When no probe data exists, falls back to failure-count-only sorting.
     */
    getBestRelays(count?: number): string[];
    /**
     * Ensure we have minimum number of relays by adding fallbacks
     */
    ensureMinimumRelays(minimum?: number): void;
    /**
     * Start periodic refresh from WASM
     */
    startRefresh(intervalMs?: number): void;
    /**
     * Stop periodic refresh
     */
    stopRefresh(): void;
    /**
     * Get a circuit relay address for a target peer.
     * Picks randomly from the top 3 scored relays for load-aware jitter.
     */
    getCircuitAddress(targetPeerId: string): string | null;
}
//# sourceMappingURL=edge-discovery.d.ts.map