import { type Socket } from 'node:net';
import type { AccessRoute, P2PCandidateRole, P2PSession, P2PTransportCandidate } from './types';
import type { P2PSignalingClient } from './P2PSignalingClient';
import type { P2PDataPlaneHandler } from './P2PDataPlane';
import { type TcpP2PDataPlaneSocketHandle, type TcpP2PDataPlaneTransport, type TcpHolePunchPlan, type TcpHolePunchPlanOptions } from './TcpP2PDataPlaneTransport';
export declare const RAW_TCP_HOLE_PUNCH_TRANSPORT: "raw-tcp-hole-punch";
export declare const RAW_TCP_HOLE_PUNCH_CAPABILITY: "tcp-punch";
export interface CreateRawTcpHolePunchCandidatesOptions {
    role: P2PCandidateRole;
    sourceId: string;
    host?: string;
    address?: string;
    createdAt?: Date;
    priority?: number;
    plan?: TcpHolePunchPlan;
    planOptions?: TcpHolePunchPlanOptions;
    candidateIdPrefix?: string;
}
export interface SignaledRawTcpP2PSessionOptions {
    signaling: P2PSignalingClient;
    clientId: string;
    host?: string;
    address?: string;
    capabilities?: string[];
    priority?: number;
    createdAt?: Date;
    plan?: TcpHolePunchPlan;
    planOptions?: TcpHolePunchPlanOptions;
    candidateIdPrefix?: string;
}
export interface SignaledRawTcpP2PSession {
    session: P2PSession;
    plan: TcpHolePunchPlan;
    localCandidates: P2PTransportCandidate[];
    rawTcpRoute?: AccessRoute;
}
export interface AnswerPendingRawTcpP2PSessionsOnceOptions {
    signaling: P2PSignalingClient;
    sourceId: string;
    host?: string;
    address?: string;
    priority?: number;
    createdAt?: Date;
    candidateIdPrefix?: string;
}
export interface WaitForRawTcpRemoteCandidatesOptions {
    signaling: P2PSignalingClient;
    sessionIdOrUrl: string;
    localRole: P2PCandidateRole;
    localSourceId: string;
    bucket?: number;
    pollIntervalMs?: number;
    timeoutMs?: number;
}
export interface ConnectRawTcpP2PTransportOptions {
    localCandidates: P2PTransportCandidate[];
    remoteCandidates: P2PTransportCandidate[];
    connectTimeoutMs?: number;
    timeoutMs?: number;
    winnerSelectionWindowMs?: number;
    localAddress?: string;
    nowMs?: () => number;
    sleepMs?: RawTcpP2PSleep;
    connectSocket?: RawTcpP2PConnectSocket;
}
export interface RawTcpP2PConnectAttempt {
    local: P2PTransportCandidate;
    remote: P2PTransportCandidate;
    remoteHost: string;
    remotePort: number;
    localAddress?: string;
    localPort?: number;
    rendezvousTimeMs: number;
    timeoutMs: number;
    signal?: AbortSignal;
}
export type RawTcpP2PConnectSocket = (attempt: RawTcpP2PConnectAttempt) => Promise<Socket>;
export type RawTcpP2PSleep = (ms: number, signal?: AbortSignal) => Promise<void>;
export interface NodeRawTcpP2PConnectSocketEventBase {
    attempt: RawTcpP2PConnectAttempt;
    error?: Error;
    remainingMs?: number;
    retryDelayMs?: number;
    socket?: Socket;
}
export type NodeRawTcpP2PConnectSocketEvent = (NodeRawTcpP2PConnectSocketEventBase & {
    type: 'attempt';
    remainingMs: number;
}) | (NodeRawTcpP2PConnectSocketEventBase & {
    type: 'retry';
    error: Error;
    remainingMs: number;
    retryDelayMs: number;
}) | (NodeRawTcpP2PConnectSocketEventBase & {
    type: 'success';
    socket: Socket;
}) | (NodeRawTcpP2PConnectSocketEventBase & {
    type: 'timeout';
    error: Error;
}) | (NodeRawTcpP2PConnectSocketEventBase & {
    type: 'aborted';
    error?: Error;
});
export interface CreateNodeRawTcpP2PConnectSocketOptions {
    retryIntervalMs?: number;
    onEvent?: (event: NodeRawTcpP2PConnectSocketEvent) => void;
}
export interface ConnectSignaledRawTcpP2PTransportOptions extends SignaledRawTcpP2PSessionOptions {
    connectTimeoutMs?: number;
    timeoutMs?: number;
    winnerSelectionWindowMs?: number;
    localAddress?: string;
    nowMs?: () => number;
    sleepMs?: RawTcpP2PSleep;
    connectSocket?: RawTcpP2PConnectSocket;
    pollIntervalMs?: number;
    waitTimeoutMs?: number;
}
export interface ConnectedSignaledRawTcpP2PTransport extends SignaledRawTcpP2PSession {
    remoteCandidates: P2PTransportCandidate[];
    transport: TcpP2PDataPlaneTransport;
}
export interface AcceptSignaledRawTcpP2PConnectionOnceOptions extends AnswerPendingRawTcpP2PSessionsOnceOptions {
    handler: P2PDataPlaneHandler;
    connectTimeoutMs?: number;
    winnerSelectionWindowMs?: number;
    localAddress?: string;
    nowMs?: () => number;
    sleepMs?: RawTcpP2PSleep;
    connectSocket?: RawTcpP2PConnectSocket;
}
export interface AcceptedSignaledRawTcpP2PConnection {
    session: P2PSession;
    plan: TcpHolePunchPlan;
    localCandidates: P2PTransportCandidate[];
    remoteCandidates: P2PTransportCandidate[];
    socketHandle: TcpP2PDataPlaneSocketHandle;
}
export declare function createNodeRawTcpP2PConnectSocket(options?: CreateNodeRawTcpP2PConnectSocketOptions): RawTcpP2PConnectSocket;
export declare function createRawTcpHolePunchCandidates(options: CreateRawTcpHolePunchCandidatesOptions): P2PTransportCandidate[];
export declare function createSignaledRawTcpP2PSession(options: SignaledRawTcpP2PSessionOptions): Promise<SignaledRawTcpP2PSession>;
export declare function answerPendingRawTcpP2PSessionsOnce(options: AnswerPendingRawTcpP2PSessionsOnceOptions): Promise<P2PSession[]>;
export declare function acceptSignaledRawTcpP2PConnectionOnce(options: AcceptSignaledRawTcpP2PConnectionOnceOptions): Promise<AcceptedSignaledRawTcpP2PConnection | undefined>;
export declare function waitForRawTcpRemoteCandidates(options: WaitForRawTcpRemoteCandidatesOptions): Promise<P2PTransportCandidate[]>;
export declare function connectSignaledRawTcpP2PTransport(options: ConnectSignaledRawTcpP2PTransportOptions): Promise<ConnectedSignaledRawTcpP2PTransport>;
export declare function connectRawTcpP2PTransport(options: ConnectRawTcpP2PTransportOptions): Promise<TcpP2PDataPlaneTransport>;
export declare function filterRawTcpRemoteCandidates(candidates: P2PTransportCandidate[], localRole: P2PCandidateRole, localSourceId: string, bucket?: number): P2PTransportCandidate[];
export declare function selectRawTcpP2PRoute(routes: AccessRoute[]): AccessRoute | undefined;
export declare function isRawTcpHolePunchCandidate(candidate: P2PTransportCandidate): boolean;