import Emitter from './Util/Emitter';
import { P2PConfig } from './Util/Types';
import Util from './Util/Util';
import P2PLoader from '../../npawPlugin/src/balancer/Loaders/P2PLoader';
/**
 * @class
 * @description Communication class that manages communication with a websocket tracker and gets peer candidates.
 * @extends Emitter
 * @exports P2PManager
 */
export default class P2PManager extends Emitter {
    static Util: typeof Util;
    static Constants: {
        trackerInterval: number;
        trackerCommunicationWait: number;
        trackerRetryJoinTime: number;
        Token: string;
        Default: {
            AnnouncePeers: number;
            MaxAnnouncePeers: number;
        };
        iceServers: {
            iceServers: {
                urls: string[];
            }[];
        };
        AnnounceEvents: {
            Offer: string;
            Offers: string;
            Candidates: string;
            Answer: string;
            Join: string;
            Config: string;
        };
        WSCommEvents: {
            Connected: string;
            Data: string;
            Error: string;
            Closed: string;
            Warning: string;
        };
        WebRtcEvents: {
            Peer: string;
            PeerUpdate: string;
            Update: string;
            Error: string;
            Warning: string;
        };
        PeerEvents: {
            Connect: string;
            Error: string;
            Close: string;
            Signal: string;
        };
    };
    private _hashId;
    private readonly _peerId;
    private readonly _config;
    private _tracker?;
    private _peerList;
    private _sentOffers;
    private _myOffers;
    private _pendingCandidatesByOfferId;
    private _pendingCandidatesByPeerId;
    private isOfferProcessStarted;
    private _loader;
    private _destroyed;
    private _peerConnectionErrors;
    private _maxPeerErrorsConnectionToBan;
    private _offerLoopIntervalMs;
    private _offerTimeoutMs;
    private _discoveryStartedAt;
    private _firstOfferReceived;
    /**
     * @constructs P2PManager
     * @param {string} hashId ID of the content as string, to be hashed.
     * @param {P2PConfig} config Configuration JSON, including the tracker URL, iceServers...
     * @param {string?} peerId Optional, ID of the peer/user, if not set a random one will be generated.
     * @public
     */
    constructor(loader: P2PLoader, hashId: string, config: P2PConfig, peerId?: string);
    getId(): string;
    /**
     * Starts the communication with the websocket tracker
     * @public
     */
    start(): void;
    /**
     * Ends the communication with the websocket tracker
     * @public
     */
    stop(): void;
    /**
     * Destroys the tracker reference and stops the communication
     * @public
     */
    destroy(): void;
    rejoin(hashId: string, switchSwarm?: boolean): void;
    setRendition(rendition?: string): void;
    setSwarmIdInput(input?: string): void;
    /**
     * L2: canonical swarm identity used in the tracker Join payload
     * (`canonical_swarm_id` + `canonical_swarm_source`). Android/iOS send this
     * when the P2PManifestRegistry resolves a SwarmIdentity, so the tracker
     * can surface lineage in the dashboard (HLS_MASTER / DASH_MPD / VIDEO_ID /
     * URL_FALLBACK). Both fields cleared when id/source are empty/undefined.
     */
    setCanonicalSwarmIdentity(canonicalId?: string, source?: string): void;
    setResource(resource: string): void;
    setConfigName(configName?: string): void;
    /**
     * Sends a message to the tracker if available
     * @param {trackerMessage} message JSON object with the data to be sent to the tracker.
     * @private
     */
    private _sendWsMessage;
    private _requiresRendition;
    private _isMessageCompatible;
    private _isMessageForCurrentSwarm;
    private _clearPeerState;
    /**
     * Generates an array of offers to be used/sent to the tracker so we can get answers to connect to peers
     * @private
     */
    private _generateAndSendOfferList;
    /**
     * Creates a peer to offer it, or to send it as answer.
     * @param {string} id ID of the peer to be created.
     * @param {boolean} initiator By defult true, if it has to generate the offer. If not generates the answer.
     * @returns {Peer.Instance} Peer object waiting for events/responses
     * @private
     */
    private _createPeer;
    /**
     * Callback for data events from the tracker
     * It manages all the events used: Offer, Candidates, Answer, Join
     * @param {callbackData} e event callback data
     * @private
     */
    private _dataReceived;
    /**
     * Handles tracker join event
     * @param {joinResponse} e event callback data
     * @private
     */
    private _handleJoin;
    private _handleConfig;
    /**
     * Handles tracker answer event
     * @param {answerData} e event callback data
     * @private
     */
    private _handleAnswer;
    /**
     * Handles tracker candidates event
     * @param {candidatesData} e event callback data
     * @private
     */
    private _handleCandidates;
    private _applyIceCandidates;
    private _bufferPendingCandidates;
    private _drainPendingCandidates;
    private _shouldKeepExistingPeer;
    /**
     * Handles tracker offer event
     * @param {offerData} e event callback data
     * @private
     */
    private _handleOffer;
    private static parseCandidate;
    test(): void;
}