import { AcmeCertificateManager } from './acme/AcmeCertificateManager';
import { ClusterCertificateManager } from './acme/ClusterCertificateManager';
import { type P2PSignalingClient, type RawTcpP2PConnectSocket, type RawTcpP2PSleep } from './reachability';
export interface EdgeNodeP2PAcceptEvent {
    sessionId: string;
    nodeId: string;
    clientId: string;
    localCandidateCount: number;
    remoteCandidateCount: number;
    nodeAddress: CandidateAddressEvidence;
    clientAddress: CandidateAddressEvidence;
    acceptedAt: string;
}
type CandidateAddressEvidence = 'explicit-host' | 'explicit-address' | 'signal-observed' | 'candidate-url' | 'port-only';
export interface EdgeNodeAgentOptions {
    signalEndpoint: string;
    nodeId: string;
    nodeToken: string;
    baseUrl?: string;
    directCandidates?: string | string[];
    pods?: string[];
    includeSystemMetrics?: boolean;
    enableNetworkDetection?: boolean;
    metadata?: Record<string, unknown>;
    intervalMs?: number;
    onHeartbeatResponse?: (data: unknown) => void;
    acme?: {
        mode?: 'local' | 'cluster';
        email?: string;
        domains?: string[];
        directoryUrl?: string;
        accountKeyPath?: string;
        certificateKeyPath: string;
        certificatePath: string;
        fullChainPath?: string;
        renewBeforeDays?: number;
        propagationDelayMs?: number;
        postDeployCommand?: string[];
    };
    frp?: {
        binaryPath: string;
        configPath: string;
        workingDirectory?: string;
        logPrefix?: string;
        autoRestart?: boolean;
    };
    p2p?: {
        enabled?: boolean | string;
        targetBaseUrl: string | URL;
        /**
         * Address this node advertises as its LAN route. Defaults to `targetBaseUrl`,
         * and must be set when the forwarding target is a loopback-only listener that
         * other devices on the LAN cannot reach.
         */
        lanBaseUrl?: string | URL;
        label?: string;
        host?: string;
        address?: string;
        signaling?: P2PSignalingClient;
        acceptIntervalMs?: number | string;
        connectTimeoutMs?: number | string;
        winnerSelectionWindowMs?: number | string;
        localAddress?: string;
        sleepMs?: RawTcpP2PSleep;
        connectSocket?: RawTcpP2PConnectSocket;
        onP2PAccept?: (event: EdgeNodeP2PAcceptEvent) => void;
    };
}
export declare class EdgeNodeAgent {
    private readonly logger;
    private heartbeat?;
    private frpManager?;
    private localCertificate?;
    private clusterCertificate?;
    private networkDetector?;
    private cachedNetworkInfo?;
    private lastNetworkDetection;
    private p2pAcceptInterval?;
    private p2pAcceptRunning;
    private p2pAcceptGeneration;
    private readonly p2pAcceptedSessionIds;
    private readonly p2pSocketHandles;
    private readonly networkDetectionIntervalMs;
    start(options: EdgeNodeAgentOptions): Promise<void>;
    stop(): void;
    getCertificateRuntime(): AcmeCertificateManager | ClusterCertificateManager | undefined;
    private startP2PAcceptLoop;
    private acceptP2PConnectionOnce;
    private skipAcceptedP2PSessions;
    private resolveP2PApiBaseUrl;
    private recordWithContent;
    private collectSystemMetrics;
    private buildHeartbeatMetadata;
    private buildLanHeartbeatRoutes;
    private buildLanHeartbeatRoute;
    private buildP2PHeartbeatRoute;
    private mergeHeartbeatRoutes;
    private normalizePositiveInteger;
    private normalizeNonNegativeInteger;
    private normalizeBoolean;
    private resolveLanGatewayEndpoint;
    private defaultPortForProtocol;
    private privateNonLoopbackIpv4;
    private privateNonLoopbackIpv6;
    private handleHeartbeatResponse;
    private issueCertificateLocally;
    private ensureClusterCertificate;
    private runPostDeploy;
    private buildTunnelHeartbeatPayload;
    /**
     * 获取网络信息（带缓存，每分钟刷新一次）
     */
    private getNetworkInfo;
}
export {};