import { TypedEventEmitter } from 'main-event';
import { HopMessage, StopMessage } from '../pb/index.js';
import type { CircuitRelayServerComponents, CircuitRelayServerInit, CircuitRelayService, RelayReservation } from '../index.js';
import type { Reservation } from '../pb/index.js';
import type { Connection, Stream, PeerId, Startable, AbortOptions } from '@libp2p/interface';
import type { PeerMap } from '@libp2p/peer-collections';
import type { ProtobufStream } from '@libp2p/utils';
export interface HopProtocolOptions {
    connection: Connection;
    request: HopMessage;
    stream: ProtobufStream<Stream>;
}
export interface StopOptions {
    connection: Connection;
    request: StopMessage;
}
export interface RelayServerEvents {
    'relay:reservation': CustomEvent<RelayReservation>;
    'relay:advert:success': CustomEvent<unknown>;
    'relay:advert:error': CustomEvent<Error>;
}
export declare class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements Startable, CircuitRelayService {
    private readonly components;
    private readonly reservationStore;
    private started;
    private readonly hopTimeout;
    private readonly shutdownController;
    private readonly maxInboundHopStreams?;
    private readonly maxOutboundHopStreams?;
    private readonly maxOutboundStopStreams;
    private readonly log;
    /**
     * Creates an instance of Relay
     */
    constructor(components: CircuitRelayServerComponents, init?: CircuitRelayServerInit);
    readonly [Symbol.toStringTag] = "@libp2p/circuit-relay-v2-server";
    isStarted(): boolean;
    /**
     * Start Relay service
     */
    start(): Promise<void>;
    /**
     * Stop Relay service
     */
    stop(): Promise<void>;
    onHop(stream: Stream, connection: Connection): Promise<void>;
    handleHopProtocol({ stream, request, connection }: HopProtocolOptions, options: AbortOptions): Promise<void>;
    handleReserve({ stream, connection }: HopProtocolOptions, options: AbortOptions): Promise<void>;
    makeReservation(remotePeer: PeerId, expire: bigint): Promise<Reservation>;
    handleConnect({ stream, request, connection }: HopProtocolOptions, options: AbortOptions): Promise<void>;
    /**
     * Send a STOP request to the target peer that the dialing peer wants to contact
     */
    stopHop({ connection, request }: StopOptions, options: AbortOptions): Promise<Stream | undefined>;
    get reservations(): PeerMap<RelayReservation>;
}
//# sourceMappingURL=index.d.ts.map