import { PeerEvents, PeerOptions, TypedEmitter } from './types';
export default class Peer {
    private peer;
    private readonly streamLocal;
    private readonly channels;
    private readonly channelsPending;
    private readonly emitter;
    private polite;
    private isActive;
    private makingOffer;
    private ignoreOffer;
    private readonly options;
    /** Create a peer instance */
    constructor(options?: PeerOptions);
    /** Initialize the peer */
    init(): RTCPeerConnection;
    /** Start the RTCPeerConnection signalling */
    start({ polite }?: {
        polite?: boolean | undefined;
    }): void;
    /** Process a RTCSessionDescriptionInit on peer */
    signal(description: RTCSessionDescriptionInit): Promise<void>;
    /** Add RTCIceCandidate to peer */
    addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
    /** Send data to connected peer using an RTCDataChannel */
    send(data: string | Blob | ArrayBuffer | ArrayBufferView, label?: string): boolean;
    /** Add RTCDataChannel to peer */
    addDataChannel(label?: string, options?: RTCDataChannelInit): void;
    /** Get RTCDataChannel added to peer */
    getDataChannel(label?: string): RTCDataChannel | undefined;
    private createDataChannels;
    private addDataChannelEvents;
    /** Close peer if active */
    destroy(): void;
    /** Return the ICEConnectionState of the peer */
    status(): RTCIceConnectionState;
    /** Return true if the peer is connected */
    isConnected(): boolean;
    /** Return true if the peer is closed */
    isClosed(): boolean;
    /** Return the RTCPeerConnection */
    get(): RTCPeerConnection;
    /** Return the local stream */
    getStreamLocal(): MediaStream;
    private error;
    private syncStreams;
    private syncChannels;
    /** Add stream to peer */
    addStream(stream: MediaStream, replace?: boolean, stopTracks?: boolean): void;
    /** Remove stream from peer */
    removeStream(stream: MediaStream, stopTracks?: boolean): void;
    /** Add track to peer */
    addTrack(track: MediaStreamTrack): void;
    /** Remove track on peer */
    removeTrack(track: MediaStreamTrack, stopTrack?: boolean): void;
    /** Remove tracks on peer */
    removeTracks(tracks: MediaStreamTrack[], stopTracks?: boolean): void;
    /** Replace track with another track on peer */
    replaceTrack(track: MediaStreamTrack, newTrack: MediaStreamTrack, stopOldTrack?: boolean): Promise<void>;
    on<E extends keyof PeerEvents>(event: E, listener: PeerEvents[E]): TypedEmitter<PeerEvents>;
    off<E extends keyof PeerEvents>(event: E, listener: PeerEvents[E]): TypedEmitter<PeerEvents>;
    offAll<E extends keyof PeerEvents>(event?: E): TypedEmitter<PeerEvents>;
    private emit;
    static getUserMedia(constraints?: MediaStreamConstraints): Promise<MediaStream>;
    /** Check if the current browser environment fully supports all required WebRTC features */
    static checkBrowserSupport(): {
        supported: boolean;
        details: {
            [key: string]: boolean;
        };
    };
    /** Get information about the current browser's WebRTC implementation */
    static getBrowserDetails(): {
        browser: string;
        version: number;
        isUnifiedPlan: boolean;
    };
}