/**
 * @packageDocumentation
 *
 * The `circuitRelayTransport` allows libp2p to dial and listen on [Circuit Relay](https://libp2p.io/docs/circuit-relay/)
 * addresses.
 *
 * @example Use as a transport
 *
 * Configuring a transport will let you dial other circuit relay addresses.
 *
 * ```typescript
 * import { createLibp2p } from 'libp2p'
 * import { circuitRelayTransport } from '@libp2p/circuit-relay-v2'
 *
 * const node = await createLibp2p({
 *   transports: [
 *     circuitRelayTransport()
 *   ]
 * })
 * ```
 *
 * The `circuitRelayServer` function allows libp2p to function as a [Circuit Relay](https://libp2p.io/docs/circuit-relay/)
 * server.  This will not work in browsers.
 *
 * @example Use as a server
 *
 * Configuring a server will let you function as a network relay for other
 * nodes.
 *
 * ```typescript
 * import { createLibp2p } from 'libp2p'
 * import { circuitRelayServer } from '@libp2p/circuit-relay-v2'
 *
 * const node = await createLibp2p({
 *   services: {
 *     circuitRelay: circuitRelayServer()
 *   }
 * })
 * ```
 */
import { TypedEventEmitter } from 'main-event';
import type { Limit } from './pb/index.js';
import type { ComponentLogger, ConnectionGater, Libp2pEvents, Metrics, PeerId, PeerStore, PrivateKey, TopologyFilter, Transport, TypedEventTarget, Upgrader } from '@libp2p/interface';
import type { AddressManager, ConnectionManager, RandomWalk, Registrar, TransportManager } from '@libp2p/interface-internal';
import type { PeerMap } from '@libp2p/peer-collections';
import type { Multiaddr } from '@multiformats/multiaddr';
import type { RetimeableAbortSignal } from 'retimeable-signal';
export type { Limit };
export interface RelayReservation {
    /**
     * When this reservation expires
     */
    expiry: Date;
    /**
     * The address of the relay client
     */
    addr: Multiaddr;
    /**
     * How much data can be transferred over each relayed connection and for how
     * long before the underlying stream is reset
     */
    limit?: Limit;
    /**
     * This signal will fire it's "abort" event when the reservation expires
     */
    signal: RetimeableAbortSignal;
}
export interface CircuitRelayServiceEvents {
    'relay:reservation': CustomEvent<RelayReservation>;
    'relay:advert:success': CustomEvent<unknown>;
    'relay:advert:error': CustomEvent<Error>;
}
export interface CircuitRelayService extends TypedEventEmitter<CircuitRelayServiceEvents> {
    reservations: PeerMap<RelayReservation>;
}
export { RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from './constants.js';
export interface ServerReservationStoreInit {
    /**
     * maximum number of reservations allowed
     *
     * @default 15
     */
    maxReservations?: number;
    /**
     * interval after which stale reservations are cleared
     *
     * @default 300000
     */
    reservationClearInterval?: number;
    /**
     * apply default relay limits to a new reservation
     *
     * @default true
     */
    applyDefaultLimit?: boolean;
    /**
     * reservation ttl
     *
     * @default 7200000
     */
    reservationTtl?: number;
    /**
     * The maximum time a relayed connection can be open for
     */
    defaultDurationLimit?: number;
    /**
     * The maximum amount of data allowed to be transferred over a relayed connection
     */
    defaultDataLimit?: bigint;
}
export interface CircuitRelayServerComponents {
    registrar: Registrar;
    peerStore: PeerStore;
    addressManager: AddressManager;
    peerId: PeerId;
    privateKey: PrivateKey;
    connectionManager: ConnectionManager;
    connectionGater: ConnectionGater;
    logger: ComponentLogger;
    metrics?: Metrics;
}
export interface CircuitRelayServerInit {
    /**
     * Incoming hop requests must complete within this time in ms otherwise
     * the stream will be reset
     *
     * @default 30000
     */
    hopTimeout?: number;
    /**
     * Configuration of reservations
     */
    reservations?: ServerReservationStoreInit;
    /**
     * The maximum number of simultaneous HOP inbound streams that can be open at once
     */
    maxInboundHopStreams?: number;
    /**
     * The maximum number of simultaneous HOP outbound streams that can be open at once
     */
    maxOutboundHopStreams?: number;
    /**
     * The maximum number of simultaneous STOP outbound streams that can be open at
     * once.
     *
     * @default 300
     */
    maxOutboundStopStreams?: number;
}
export declare function circuitRelayServer(init?: CircuitRelayServerInit): (components: CircuitRelayServerComponents) => CircuitRelayService;
export interface RelayDiscoveryEvents {
    'relay:discover': CustomEvent<PeerId>;
}
export interface TransportReservationStoreComponents {
    peerId: PeerId;
    connectionManager: ConnectionManager;
    peerStore: PeerStore;
    events: TypedEventTarget<Libp2pEvents>;
    logger: ComponentLogger;
    metrics?: Metrics;
}
export interface TransportReservationStoreInit {
    /**
     * Multiple relays may be discovered simultaneously - to prevent listening
     * on too many relays, this value controls how many to attempt to reserve a
     * slot on at once. If set to more than one, we may end up listening on
     * more relays than the `maxReservations` value, but on networks with poor
     * connectivity the user may wish to attempt to reserve on multiple relays
     * simultaneously.
     *
     * @default 1
     */
    reservationConcurrency?: number;
    /**
     * Limit the number of potential relays we will dial
     *
     * @default 100
     */
    maxReservationQueueLength?: number;
    /**
     * When creating a reservation it must complete within this number of ms
     *
     * @default 5000
     */
    reservationCompletionTimeout?: number;
}
export interface RelayDiscoveryComponents {
    peerStore: PeerStore;
    connectionManager: ConnectionManager;
    transportManager: TransportManager;
    registrar: Registrar;
    logger: ComponentLogger;
    randomWalk: RandomWalk;
    events: TypedEventTarget<Libp2pEvents>;
}
export interface RelayDiscoveryInit {
    filter?: TopologyFilter;
}
export interface CircuitRelayTransportComponents extends RelayDiscoveryComponents {
    peerId: PeerId;
    upgrader: Upgrader;
    addressManager: AddressManager;
    connectionGater: ConnectionGater;
}
/**
 * RelayConfig configures the circuit v2 relay transport.
 */
export interface CircuitRelayTransportInit extends TransportReservationStoreInit {
    /**
     * An optional filter used to prevent duplicate attempts to reserve relay
     * slots on the same peer
     */
    discoveryFilter?: TopologyFilter;
    /**
     * The maximum number of simultaneous STOP inbound streams that can be open at
     * once - each inbound relayed connection uses a STOP stream
     *
     * @default 300
     */
    maxInboundStopStreams?: number;
    /**
     * The maximum number of simultaneous STOP outbound streams that can be open
     * at once. If this transport is used along with the relay server these
     * settings should be set to the same value
     *
     * @default 300
     */
    maxOutboundStopStreams?: number;
    /**
     * When creating a reservation it must complete within this number of ms
     *
     * @default 10_000
     */
    reservationCompletionTimeout?: number;
}
export declare function circuitRelayTransport(init?: CircuitRelayTransportInit): (components: CircuitRelayTransportComponents) => Transport;
//# sourceMappingURL=index.d.ts.map