diff --git a/webrtc/MediaStream-tests.ts b/webrtc/MediaStream-tests.ts
index 4dcde91fe7..14c2fab7c7 100644
--- a/webrtc/MediaStream-tests.ts
+++ b/webrtc/MediaStream-tests.ts
@@ -6,27 +6,27 @@ var mediaTrackConstraintArray: MediaTrackConstraint[] = [];
 var mediaTrackConstraints: MediaTrackConstraints = { mandatory: mediaTrackConstraintSet, optional: mediaTrackConstraintArray }
 
 navigator.getUserMedia(mediaStreamConstraints,
-	stream => {
-		console.log('label:' + stream.label);
-		console.log('ended:' + stream.ended);
-		stream.onended = (event:Event) => console.log('Stream ended');
-		var objectUrl = URL.createObjectURL(stream);
-		var wkObjectUrl = webkitURL.createObjectURL(stream);
-	},
-	error => {
-		console.log('Error message: ' + error.message);
-		console.log('Error name: ' + error.name);
-	});
+  stream => {
+    console.log('label:' + stream.label);
+    console.log('ended:' + stream.ended);
+    stream.onended = (event:Event) => console.log('Stream ended');
+    var objectUrl = URL.createObjectURL(stream);
+    var wkObjectUrl = webkitURL.createObjectURL(stream);
+  },
+  error => {
+    console.log('Error message: ' + error.message);
+    console.log('Error name: ' + error.name);
+  });
 
 navigator.webkitGetUserMedia(mediaStreamConstraints,
-	stream => {
-		console.log('label:' + stream.label);
-		console.log('ended:' + stream.ended);
-		stream.onended = (event:Event) => console.log('Stream ended');
-		var objectUrl = URL.createObjectURL(stream);
-		var wkObjectUrl = webkitURL.createObjectURL(stream);
-	},
-	error => {
-		console.log('Error message: ' + error.message);
-		console.log('Error name: ' + error.name);
-	});
+  stream => {
+    console.log('label:' + stream.label);
+    console.log('ended:' + stream.ended);
+    stream.onended = (event:Event) => console.log('Stream ended');
+    var objectUrl = URL.createObjectURL(stream);
+    var wkObjectUrl = webkitURL.createObjectURL(stream);
+  },
+  error => {
+    console.log('Error message: ' + error.message);
+    console.log('Error name: ' + error.name);
+  });
diff --git a/webrtc/MediaStream.d.ts b/webrtc/MediaStream.d.ts
index 12e0a253aa..e159dff294 100644
--- a/webrtc/MediaStream.d.ts
+++ b/webrtc/MediaStream.d.ts
@@ -6,158 +6,158 @@
 // Taken from http://dev.w3.org/2011/webrtc/editor/getusermedia.html
 
 interface MediaStreamConstraints {
-	audio: any;
-	video: any;
+  audio: any;
+  video: any;
 }
 declare var MediaStreamConstraints: {
-	prototype: MediaStreamConstraints;
-	new (): MediaStreamConstraints;
+  prototype: MediaStreamConstraints;
+  new (): MediaStreamConstraints;
 }
 
 interface MediaTrackConstraints {
-	mandatory: MediaTrackConstraintSet;
-	optional: MediaTrackConstraint[];
+  mandatory: MediaTrackConstraintSet;
+  optional: MediaTrackConstraint[];
 }
 declare var MediaTrackConstraints: {
-	prototype: MediaTrackConstraints;
-	new (): MediaTrackConstraints;
+  prototype: MediaTrackConstraints;
+  new (): MediaTrackConstraints;
 }
 
 // ks - Not defined in the source doc.
 interface MediaTrackConstraintSet {
 }
 declare var MediaTrackConstraintSet: {
-	prototype: MediaTrackConstraintSet;
-	new (): MediaTrackConstraintSet;
+  prototype: MediaTrackConstraintSet;
+  new (): MediaTrackConstraintSet;
 }
 
 // ks - Not defined in the source doc.
 interface MediaTrackConstraint {
 }
 declare var MediaTrackConstraint: {
-	prototype: MediaTrackConstraint;
-	new (): MediaTrackConstraints;
+  prototype: MediaTrackConstraint;
+  new (): MediaTrackConstraints;
 }
 
 interface Navigator {
-	getUserMedia(constraints: MediaStreamConstraints,
-							 successCallback: (stream: any) => void,
-							 errorCallback: (error: Error) => void) : void;
-	webkitGetUserMedia(constraints: MediaStreamConstraints,
-										 successCallback: (stream: any) => void,
-										 errorCallback: (error: Error) => void): void;
+  getUserMedia(constraints: MediaStreamConstraints,
+               successCallback: (stream: any) => void,
+               errorCallback: (error: Error) => void) : void;
+  webkitGetUserMedia(constraints: MediaStreamConstraints,
+                     successCallback: (stream: any) => void,
+                     errorCallback: (error: Error) => void): void;
 }
 
 interface EventHandler { (event: Event): void; }
 
 interface NavigatorUserMediaSuccessCallback {
-	(stream: LocalMediaStream): void;
+  (stream: LocalMediaStream): void;
 }
 
 interface NavigatorUserMediaError {
-	PERMISSION_DENIED: number; // = 1;
-	code: number;
+  PERMISSION_DENIED: number; // = 1;
+  code: number;
 }
 declare var NavigatorUserMediaError: {
-	prototype: NavigatorUserMediaError;
-	new (): NavigatorUserMediaError;
-	PERMISSION_DENIED: number; // = 1;
+  prototype: NavigatorUserMediaError;
+  new (): NavigatorUserMediaError;
+  PERMISSION_DENIED: number; // = 1;
 }
 
 interface NavigatorUserMediaErrorCallback {
-	(error: NavigatorUserMediaError): void;
+  (error: NavigatorUserMediaError): void;
 }
 
 interface MediaStreamTrackList {
-	length: number;
-	item: MediaStreamTrack;
-	add(track: MediaStreamTrack): void;
-	remove(track: MediaStreamTrack): void;
-	onaddtrack: (event: Event) => void;
-	onremovetrack: (event: Event) => void;
+  length: number;
+  item: MediaStreamTrack;
+  add(track: MediaStreamTrack): void;
+  remove(track: MediaStreamTrack): void;
+  onaddtrack: (event: Event) => void;
+  onremovetrack: (event: Event) => void;
 }
 declare var MediaStreamTrackList: {
-	prototype: MediaStreamTrackList;
-	new (): MediaStreamTrackList;
+  prototype: MediaStreamTrackList;
+  new (): MediaStreamTrackList;
 }
 declare var webkitMediaStreamTrackList: {
-	prototype: MediaStreamTrackList;
-	new (): MediaStreamTrackList;
+  prototype: MediaStreamTrackList;
+  new (): MediaStreamTrackList;
 }
 
 interface MediaStream {
-	label: string;
-	id: string;
-	getAudioTracks(): MediaStreamTrackList;
-	getVideoTracks(): MediaStreamTrackList;
-	ended: boolean;
-	onended: (event: Event) => void;
+  label: string;
+  id: string;
+  getAudioTracks(): MediaStreamTrackList;
+  getVideoTracks(): MediaStreamTrackList;
+  ended: boolean;
+  onended: (event: Event) => void;
 }
 declare var MediaStream: {
-	prototype: MediaStream;
-	new (): MediaStream;
-	new (trackContainers: MediaStream[]): MediaStream;
-	new (trackContainers: MediaStreamTrackList[]): MediaStream;
-	new (trackContainers: MediaStreamTrack[]): MediaStream;
+  prototype: MediaStream;
+  new (): MediaStream;
+  new (trackContainers: MediaStream[]): MediaStream;
+  new (trackContainers: MediaStreamTrackList[]): MediaStream;
+  new (trackContainers: MediaStreamTrack[]): MediaStream;
 }
 declare var webkitMediaStream: {
-	prototype: MediaStream;
-	new (): MediaStream;
-	new (trackContainers: MediaStream[]): MediaStream;
-	new (trackContainers: MediaStreamTrackList[]): MediaStream;
-	new (trackContainers: MediaStreamTrack[]): MediaStream;
+  prototype: MediaStream;
+  new (): MediaStream;
+  new (trackContainers: MediaStream[]): MediaStream;
+  new (trackContainers: MediaStreamTrackList[]): MediaStream;
+  new (trackContainers: MediaStreamTrack[]): MediaStream;
 }
 
 // an - not defined in source doc.
 interface SourceInfo {
-	label: string;
-	id: string;
-	kind: string;
-	facing: string;
+  label: string;
+  id: string;
+  kind: string;
+  facing: string;
 }
 declare var SourceInfo: {
-	prototype: SourceInfo;
+  prototype: SourceInfo;
 }
 
 interface LocalMediaStream extends MediaStream {
-	stop(): void;
+  stop(): void;
 }
 
 interface MediaStreamTrack {
-	kind: string;
-	label: string;
-	enabled: boolean;
-	LIVE: number; // = 0;
-	MUTED: number; // = 1;
-	ENDED: number; // = 2;
-	readyState: number;
-	onmute: (event: Event) => void;
-	onunmute: (event: Event) => void;
-	onended: (event: Event) => void;
+  kind: string;
+  label: string;
+  enabled: boolean;
+  LIVE: number; // = 0;
+  MUTED: number; // = 1;
+  ENDED: number; // = 2;
+  readyState: number;
+  onmute: (event: Event) => void;
+  onunmute: (event: Event) => void;
+  onended: (event: Event) => void;
 }
 declare var MediaStreamTrack: {
-	prototype: MediaStreamTrack;
-	new (): MediaStreamTrack;
-	LIVE: number; // = 0;
-	MUTED: number; // = 1;
-	ENDED: number; // = 2;
-	getSources: (callback: (sources: SourceInfo[]) => void) => void;
+  prototype: MediaStreamTrack;
+  new (): MediaStreamTrack;
+  LIVE: number; // = 0;
+  MUTED: number; // = 1;
+  ENDED: number; // = 2;
+  getSources: (callback: (sources: SourceInfo[]) => void) => void;
 }
 
 interface streamURL extends URL {
-	createObjectURL(stream: MediaStream): string;
+  createObjectURL(stream: MediaStream): string;
 }
 //declare var URL: {
-//	prototype: MediaStreamTrack;
-//	new (): URL;
-//	createObjectURL(stream: MediaStream): string;
+//  prototype: MediaStreamTrack;
+//  new (): URL;
+//  createObjectURL(stream: MediaStream): string;
 //}
 
 interface WebkitURL extends streamURL {
 }
 declare var webkitURL: {
-	prototype: WebkitURL;
-	new (): streamURL;
-	createObjectURL(stream: MediaStream): string;
+  prototype: WebkitURL;
+  new (): streamURL;
+  createObjectURL(stream: MediaStream): string;
 }
 
diff --git a/webrtc/RTCPeerConnection-tests.ts b/webrtc/RTCPeerConnection-tests.ts
index d85728c5cd..3b35efad50 100644
--- a/webrtc/RTCPeerConnection-tests.ts
+++ b/webrtc/RTCPeerConnection-tests.ts
@@ -7,13 +7,13 @@ var constraints: MediaConstraints = { mandatory: { OfferToReceiveAudio: true, Of
 var peerConnection: RTCPeerConnection = new RTCPeerConnection(config, constraints);
 
 navigator.getUserMedia({ audio: true, video: true },
-	stream => {
-		peerConnection.addStream(stream);
-	},
-	error => {
-		console.log('Error message: ' + error.message);
-		console.log('Error name: ' + error.name);
-	});
+  stream => {
+    peerConnection.addStream(stream);
+  },
+  error => {
+    console.log('Error message: ' + error.message);
+    console.log('Error name: ' + error.name);
+  });
 
 peerConnection.onaddstream = ev => console.log(ev.type);
 peerConnection.ondatachannel = ev => console.log(ev.type);
@@ -25,25 +25,25 @@ peerConnection.onremovestream = ev => console.log(ev.type);
 peerConnection.onstatechange = ev => console.log(ev.type);
 
 peerConnection.createOffer(
-	offer => {
-		peerConnection.setLocalDescription(offer,
-			() => console.log("set local description"),
-			error => console.log("Error setting local description: " + error));
-	},
-	error => console.log("Error creating offer: " + error));
+  offer => {
+    peerConnection.setLocalDescription(offer,
+      () => console.log("set local description"),
+      error => console.log("Error setting local description: " + error));
+  },
+  error => console.log("Error creating offer: " + error));
 
 var type: string = RTCSdpType[RTCSdpType.offer];
 var offer: RTCSessionDescriptionInit = { type: type, sdp: "some sdp" };
 var sessionDescription = new RTCSessionDescription(offer);
 
 peerConnection.setRemoteDescription(sessionDescription, () => {
-	peerConnection.createAnswer(
-		answer => {
-			peerConnection.setLocalDescription(answer,
-				() => console.log('Set local description'),
-			error => console.log("Error setting local description from created answer: " + error + "; answer.sdp=" + answer.sdp));
-		},
-	error => console.log("Error creating answer: " + error));
+  peerConnection.createAnswer(
+    answer => {
+      peerConnection.setLocalDescription(answer,
+        () => console.log('Set local description'),
+      error => console.log("Error setting local description from created answer: " + error + "; answer.sdp=" + answer.sdp));
+    },
+  error => console.log("Error creating answer: " + error));
 },
 error => console.log('Error setting remote description: ' + error + "; offer.sdp=" + offer.sdp));
 
diff --git a/webrtc/RTCPeerConnection.d.ts b/webrtc/RTCPeerConnection.d.ts
index e123b69bd2..bc2c6205da 100644
--- a/webrtc/RTCPeerConnection.d.ts
+++ b/webrtc/RTCPeerConnection.d.ts
@@ -21,78 +21,78 @@
 // https://typescript.codeplex.com/workitem/1364
 
 interface RTCConfiguration {
-	iceServers: RTCIceServer[];
+  iceServers: RTCIceServer[];
 }
 declare var RTCConfiguration: {
-	prototype: RTCConfiguration;
-	new (): RTCConfiguration;
+  prototype: RTCConfiguration;
+  new (): RTCConfiguration;
 }
 
 interface RTCIceServer {
-	url: string;
-	credential?: string;
+  url: string;
+  credential?: string;
 }
 declare var RTCIceServer: {
-	prototype: RTCIceServer;
-	new (): RTCIceServer;
+  prototype: RTCIceServer;
+  new (): RTCIceServer;
 }
 
 // moz (Firefox) specific prefixes.
 interface mozRTCPeerConnection extends RTCPeerConnection {
 }
 declare var mozRTCPeerConnection: {
-	prototype: mozRTCPeerConnection;
-	new (settings: RTCPeerConnectionConfig,
-			 constraints?:MediaConstraints): mozRTCPeerConnection;
+  prototype: mozRTCPeerConnection;
+  new (settings: RTCPeerConnectionConfig,
+       constraints?:MediaConstraints): mozRTCPeerConnection;
 }
 // webkit (Chrome) specific prefixes.
 interface webkitRTCPeerConnection extends RTCPeerConnection {
 }
 declare var webkitRTCPeerConnection: {
-	prototype: webkitRTCPeerConnection;
-	new (settings: RTCPeerConnectionConfig,
-			 constraints?:MediaConstraints): webkitRTCPeerConnection;
+  prototype: webkitRTCPeerConnection;
+  new (settings: RTCPeerConnectionConfig,
+       constraints?:MediaConstraints): webkitRTCPeerConnection;
 }
 
 // For Chrome, look at the code here:
 // https://code.google.com/p/chromium/codesearch#chromium/src/third_party/libjingle/source/talk/app/webrtc/webrtcsession.cc&sq=package:chromium&dr=C&l=63
 interface OptionalMediaConstraint {
-	// When true, will use DTLS/SCTP data channels
-	DtlsSrtpKeyAgreement?: boolean;
-	// When true will use Rtp-based data channels (depreicated)
-	RtpDataChannels?: boolean;
+  // When true, will use DTLS/SCTP data channels
+  DtlsSrtpKeyAgreement?: boolean;
+  // When true will use Rtp-based data channels (depreicated)
+  RtpDataChannels?: boolean;
 }
 
 // ks 12/20/12 - There's more here that doesn't seem to be documented very well yet.
 // http://www.w3.org/TR/2013/WD-webrtc-20130910/
 interface MediaConstraints {
-	mandatory?: MediaOfferConstraints;
-	optional?: OptionalMediaConstraint[]
+  mandatory?: MediaOfferConstraints;
+  optional?: OptionalMediaConstraint[]
 }
 
 interface MediaOfferConstraints {
-	OfferToReceiveAudio: boolean;
-	OfferToReceiveVideo: boolean;
+  OfferToReceiveAudio: boolean;
+  OfferToReceiveVideo: boolean;
 }
 
 interface RTCSessionDescriptionInit {
-	type: string;  // RTCSdpType; See TODO(1)
-	sdp: string;
+  type: string;  // RTCSdpType; See TODO(1)
+  sdp: string;
 }
 
 interface RTCSessionDescription {
-	type?: string;  // RTCSdpType; See TODO(1)
-	sdp?: string;
+  type?: string;  // RTCSdpType; See TODO(1)
+  sdp?: string;
 }
 declare var RTCSessionDescription: {
-	prototype: RTCSessionDescription;
-	new (descriptionInitDict?: RTCSessionDescriptionInit): RTCSessionDescription;
-	// TODO: Add serializer.
-	// See: http://dev.w3.org/2011/webrtc/editor/webrtc.html#idl-def-RTCSdpType)
+  prototype: RTCSessionDescription;
+  new (descriptionInitDict?: RTCSessionDescriptionInit): RTCSessionDescription;
+  // TODO: Add serializer.
+  // See: http://dev.w3.org/2011/webrtc/editor/webrtc.html#idl-def-RTCSdpType)
 }
 
 interface RTCDataChannelInit {
-	ordered             ?: boolean; // messages must be sent in-order.
+  ordered             ?: boolean; // messages must be sent in-order.
   maxPacketLifeTime   ?: number;  // unsigned short
   maxRetransmits      ?: number;  // unsigned short
   protocol            ?: string;  // default = ''
@@ -109,89 +109,89 @@ declare enum RTCSdpType {
 }
 
 interface RTCMessageEvent {
-	// http://dev.w3.org/2011/webrtc/editor/webrtc.html#event-datachannel-message
-	// At present, this can be an: ArrayBuffer, a string, or a Blob.
-	// See TODO(2)
-	data: any;
+  // http://dev.w3.org/2011/webrtc/editor/webrtc.html#event-datachannel-message
+  // At present, this can be an: ArrayBuffer, a string, or a Blob.
+  // See TODO(2)
+  data: any;
 }
 
 // TODO(1)
 declare enum RTCDataChannelState {
-	// http://dev.w3.org/2011/webrtc/editor/webrtc.html#idl-def-RTCDataChannelState
-	'connecting',
-	'open',
-	'closing',
-	'closed'
+  // http://dev.w3.org/2011/webrtc/editor/webrtc.html#idl-def-RTCDataChannelState
+  'connecting',
+  'open',
+  'closing',
+  'closed'
 }
 
 interface RTCDataChannel extends EventTarget {
-	label: string;
-	reliable: boolean;
-	readyState: string; // RTCDataChannelState; see TODO(1)
-	bufferedAmount: number;
-	binaryType: string;
+  label: string;
+  reliable: boolean;
+  readyState: string; // RTCDataChannelState; see TODO(1)
+  bufferedAmount: number;
+  binaryType: string;
 
-	onopen: (event: Event) => void;
-	onerror: (event: Event) => void;
-	onclose: (event: Event) => void;
-	onmessage: (event: RTCMessageEvent) => void;
+  onopen: (event: Event) => void;
+  onerror: (event: Event) => void;
+  onclose: (event: Event) => void;
+  onmessage: (event: RTCMessageEvent) => void;
 
-	close(): void;
+  close(): void;
 
-	send(data: string): void ;
-	send(data: ArrayBuffer): void;
-	send(data: ArrayBufferView): void;
-	send(data: Blob): void;
+  send(data: string): void ;
+  send(data: ArrayBuffer): void;
+  send(data: ArrayBufferView): void;
+  send(data: Blob): void;
 }
 declare var RTCDataChannel: {
-	prototype: RTCDataChannel;
-	new (): RTCDataChannel;
+  prototype: RTCDataChannel;
+  new (): RTCDataChannel;
 }
 
 interface RTCDataChannelEvent extends Event {
-	channel: RTCDataChannel;
+  channel: RTCDataChannel;
 }
 declare var RTCDataChannelEvent: {
-	prototype: RTCDataChannelEvent;
-	new (eventInitDict: RTCDataChannelEventInit): RTCDataChannelEvent;
+  prototype: RTCDataChannelEvent;
+  new (eventInitDict: RTCDataChannelEventInit): RTCDataChannelEvent;
 }
 
 interface RTCIceCandidateEvent extends Event {
-	candidate: RTCIceCandidate;
+  candidate: RTCIceCandidate;
 }
 
 interface RTCMediaStreamEvent extends Event {
-	stream: MediaStream;
+  stream: MediaStream;
 }
 
 interface EventInit {
 }
 
 interface RTCDataChannelEventInit extends EventInit {
-	channel: RTCDataChannel;
+  channel: RTCDataChannel;
 }
 
 interface RTCVoidCallback {
-	(): void;
+  (): void;
 }
 interface RTCSessionDescriptionCallback {
-	(sdp: RTCSessionDescription): void;
+  (sdp: RTCSessionDescription): void;
 }
 interface RTCPeerConnectionErrorCallback {
-	(errorInformation: DOMError): void;
+  (errorInformation: DOMError): void;
 }
 
 // TODO(1)
 declare enum RTCIceGatheringState {
-	// http://dev.w3.org/2011/webrtc/editor/webrtc.html#rtcicegatheringstate-enum
-	'new',
-	'gathering',
-	'complete'
+  // http://dev.w3.org/2011/webrtc/editor/webrtc.html#rtcicegatheringstate-enum
+  'new',
+  'gathering',
+  'complete'
 }
 
 // TODO(1)
 declare enum RTCIceConnectionState {
-	// http://dev.w3.org/2011/webrtc/editor/webrtc.html#idl-def-RTCIceConnectionState
+  // http://dev.w3.org/2011/webrtc/editor/webrtc.html#idl-def-RTCIceConnectionState
   'new',
   'checking',
   'connected',
@@ -213,84 +213,84 @@ declare enum RTCSignalingState {
 }
 
 interface RTCPeerConnection {
-	createOffer(successCallback: RTCSessionDescriptionCallback,
-							failureCallback?: RTCPeerConnectionErrorCallback,
-							constraints?: MediaConstraints): void;
-	createAnswer(successCallback: RTCSessionDescriptionCallback,
-							 failureCallback?: RTCPeerConnectionErrorCallback,
-							 constraints?: MediaConstraints): void;
-	setLocalDescription(description: RTCSessionDescription,
-											successCallback?: RTCVoidCallback,
-											failureCallback?: RTCPeerConnectionErrorCallback): void;
-	localDescription: RTCSessionDescription;
-	setRemoteDescription(description: RTCSessionDescription,
-		 									 successCallback?: RTCVoidCallback,
-		 									 failureCallback?: RTCPeerConnectionErrorCallback): void;
-	remoteDescription: RTCSessionDescription;
-	signalingState: string; // RTCSignalingState; see TODO(1)
-	updateIce(configuration?: RTCConfiguration,
-						constraints?: MediaConstraints): void;
-	addIceCandidate(candidate: RTCIceCandidate): void;
-	iceGatheringState: string;  // RTCIceGatheringState; see TODO(1)
-	iceConnectionState: string;  // RTCIceConnectionState; see TODO(1)
-	getLocalStreams(): MediaStream[];
-	getRemoteStreams(): MediaStream[];
-	createDataChannel(label?: string,
-										dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
-	ondatachannel: (event: Event) => void;
-	addStream(stream: MediaStream, constraints?: MediaConstraints): void;
-	removeStream(stream: MediaStream): void;
-	close(): void;
-	onnegotiationneeded: (event: Event) => void;
-	onconnecting: (event: Event) => void;
-	onopen: (event: Event) => void;
-	onaddstream: (event: RTCMediaStreamEvent) => void;
-	onremovestream: (event: RTCMediaStreamEvent) => void;
-	onstatechange: (event: Event) => void;
-	onicechange: (event: Event) => void;
-	onicecandidate: (event: RTCIceCandidateEvent) => void;
-	onidentityresult: (event: Event) => void;
-	onsignalingstatechange: (event: Event) => void;
+  createOffer(successCallback: RTCSessionDescriptionCallback,
+              failureCallback?: RTCPeerConnectionErrorCallback,
+              constraints?: MediaConstraints): void;
+  createAnswer(successCallback: RTCSessionDescriptionCallback,
+               failureCallback?: RTCPeerConnectionErrorCallback,
+               constraints?: MediaConstraints): void;
+  setLocalDescription(description: RTCSessionDescription,
+                      successCallback?: RTCVoidCallback,
+                      failureCallback?: RTCPeerConnectionErrorCallback): void;
+  localDescription: RTCSessionDescription;
+  setRemoteDescription(description: RTCSessionDescription,
+                        successCallback?: RTCVoidCallback,
+                        failureCallback?: RTCPeerConnectionErrorCallback): void;
+  remoteDescription: RTCSessionDescription;
+  signalingState: string; // RTCSignalingState; see TODO(1)
+  updateIce(configuration?: RTCConfiguration,
+            constraints?: MediaConstraints): void;
+  addIceCandidate(candidate: RTCIceCandidate): void;
+  iceGatheringState: string;  // RTCIceGatheringState; see TODO(1)
+  iceConnectionState: string;  // RTCIceConnectionState; see TODO(1)
+  getLocalStreams(): MediaStream[];
+  getRemoteStreams(): MediaStream[];
+  createDataChannel(label?: string,
+                    dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
+  ondatachannel: (event: Event) => void;
+  addStream(stream: MediaStream, constraints?: MediaConstraints): void;
+  removeStream(stream: MediaStream): void;
+  close(): void;
+  onnegotiationneeded: (event: Event) => void;
+  onconnecting: (event: Event) => void;
+  onopen: (event: Event) => void;
+  onaddstream: (event: RTCMediaStreamEvent) => void;
+  onremovestream: (event: RTCMediaStreamEvent) => void;
+  onstatechange: (event: Event) => void;
+  onicechange: (event: Event) => void;
+  onicecandidate: (event: RTCIceCandidateEvent) => void;
+  onidentityresult: (event: Event) => void;
+  onsignalingstatechange: (event: Event) => void;
 }
 declare var RTCPeerConnection: {
-	prototype: RTCPeerConnection;
-	new (configuration: RTCConfiguration,
-			 constraints?: MediaConstraints): RTCPeerConnection;
+  prototype: RTCPeerConnection;
+  new (configuration: RTCConfiguration,
+       constraints?: MediaConstraints): RTCPeerConnection;
 }
 
 interface RTCIceCandidate {
-	candidate?: string;
-	sdpMid?: string;
-	sdpMLineIndex?: number;
+  candidate?: string;
+  sdpMid?: string;
+  sdpMLineIndex?: number;
 }
 declare var RTCIceCandidate: {
-	prototype: RTCIceCandidate;
-	new (candidateInitDict?: RTCIceCandidate): RTCIceCandidate;
+  prototype: RTCIceCandidate;
+  new (candidateInitDict?: RTCIceCandidate): RTCIceCandidate;
 }
 
 interface RTCIceCandidateInit {
-	candidate: string;
-	sdpMid: string;
-	sdpMLineIndex: number;
+  candidate: string;
+  sdpMid: string;
+  sdpMLineIndex: number;
 }
 declare var RTCIceCandidateInit:{
-	prototype: RTCIceCandidateInit;
-	new (): RTCIceCandidateInit;
+  prototype: RTCIceCandidateInit;
+  new (): RTCIceCandidateInit;
 }
 
 interface PeerConnectionIceEvent {
-	peer: RTCPeerConnection;
-	candidate: RTCIceCandidate;
+  peer: RTCPeerConnection;
+  candidate: RTCIceCandidate;
 }
 declare var PeerConnectionIceEvent: {
-	prototype: PeerConnectionIceEvent;
-	new (): PeerConnectionIceEvent;
+  prototype: PeerConnectionIceEvent;
+  new (): PeerConnectionIceEvent;
 }
 
 interface RTCPeerConnectionConfig {
-	iceServers: RTCIceServer[];
+  iceServers: RTCIceServer[];
 }
 declare var RTCPeerConnectionConfig: {
-	prototype: RTCPeerConnectionConfig;
-	new (): RTCPeerConnectionConfig;
+  prototype: RTCPeerConnectionConfig;
+  new (): RTCPeerConnectionConfig;
 }