# API

##  PeerConnection Class

**Constructor**

let pc = new PeerConnection(peerName[,options])
- peerName `<string>` Peer name to use for logs etc..
- options `<Object>` WebRTC Config Options
```
export interface RtcConfig {
    iceServers: (string | IceServer)[];
    proxyServer?: ProxyServer;
    bindAddress?: string;
    enableIceTcp?: boolean;
    enableIceUdpMux?: boolean;
    portRangeBegin?: number;
    portRangeEnd?: number;
    maxMessageSize?: number;
    mtu?: number;
    iceTransportPolicy?: TransportPolicy;
}

export const enum RelayType {
    TurnUdp = 'TurnUdp',
    TurnTcp = 'TurnTcp',
    TurnTls = 'TurnTls'
}

export interface IceServer {
    hostname: string;
    port: number;
    username?: string;
    password?: string;
    relayType?: RelayType;
}

export type TransportPolicy = 'all' | 'relay';

"iceServers" option is an array of stun/turn server urls
Examples;
STUN Server Example          : stun:stun.l.google.com:19302
TURN Server Example          : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT
TURN Server Example (TCP)    : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT?transport=tcp
TURN Server Example (TLS)    : turns:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT

```

**close: () => void**

Close Peer Connection

**destroy: () => void**

Close Peer Connection & Clear all callbacks

**setRemoteDescription: (sdp: string, type: DescriptionType) => void**

Set Remote Description
```
export const enum DescriptionType {
    Unspec = 'Unspec',
    Offer = 'Offer',
    Answer = 'Answer'
}
```

**addRemoteCandidate: (candidate: string, mid: string) => void**

Add remote candidate info

**createDataChannel: (label: string, config?: DataChannelInitConfig) => DataChannel**

Create new data-channel
* label `<string>` Data channel name
* config `<Object>` Data channel options
```
export interface DataChannelInitConfig {
    protocol?: string;
    negotiated?: boolean;
    id?: number;
    ordered?: boolean;
    maxPacketLifeTime?: number;
    maxRetransmits?: number;

    // Deprecated, use ordered, maxPacketLifeTime, and maxRetransmits
    reliability?: {
        type?: ReliabilityType;
        unordered?: boolean;
        rexmit?: number;
    }
}

export const enum ReliabilityType {
    Reliable = 0, Rexmit = 1, Timed = 2
}
```
**state: () => string**

Get current state

**signalingState: () => string**

Get current signaling state

**gatheringState: () => string**

Get current gathering state

**onLocalDescription: (cb: (sdp: string, type: DescriptionType) => void) => void**

Local Description Callback
```
export const enum DescriptionType {
    Unspec = 'Unspec',
    Offer = 'Offer',
    Answer = 'Answer'
}
```

**onLocalCandidate: (cb: (candidate: string, mid: string) => void) => void**

Local Candidate Callback

**onStateChange: (cb: (state: string) => void) => void**

State Change Callback

**onSignalingStateChange: (state: (sdp: string) => void) => void**

Signaling State Change Callback

**onGatheringStateChange: (state: (sdp: string) => void) => void**

Gathering State Change Callback

**onDataChannel: (cb: (dc: DataChannel) => void) => void**

New Data Channel Callback

**bytesSent: () => number**

Get bytes sent stat

**bytesReceived: () => number**

Get bytes received stat

**rtt: () => number**

Get rtt stat

**getSelectedCandidatePair: () => { local: SelectedCandidateInfo, remote: SelectedCandidateInfo }**

Get info about selected candidate pair
```
export interface SelectedCandidateInfo {
    address: string;
    port: number;
    type: string;
    transportType: string;
}
```

##  DataChannel Class

> You can create a new Datachannel instance by calling `PeerConnection.createDataChannel` function.

**close: () => void**

Close data channel

**getLabel: () => string**

Get label of data-channel

**sendMessage: (msg: string) => boolean**

Send Message as string

**sendMessageBinary: (buffer: Buffer) => boolean**

Send Message as binary

**isOpen: () => boolean**

Query data-channel

**bufferedAmount: () => number**

Get current buffered amount level

**maxMessageSize: () => number**

Get max message size of the data-channel, that could be sent

**setBufferedAmountLowThreshold: (newSize: number) => void**

Set buffer level of the `onBufferedAmountLow` callback

**onOpen: (cb: () => void) => void**

Open callback

**onClosed: (cb: () => void) => void**

Closed callback

**onError: (cb: (err: string) => void) => void**

Error callback

**onBufferedAmountLow: (cb: () => void) => void**

Buffer level low callback

**onMessage: (cb: (msg: string | Buffer) => void) => void**

New Message callback