diff --git a/webrtc/MediaStream.d.ts b/webrtc/MediaStream.d.ts
index 54de34e38..6db34de94 100644
--- a/webrtc/MediaStream.d.ts
+++ b/webrtc/MediaStream.d.ts
@@ -5,161 +5,183 @@
 
 // Taken from http://dev.w3.org/2011/webrtc/editor/getusermedia.html
 
+/// <reference path="../es6-promise/es6-promise.d.ts" />
+
+interface ConstrainBooleanParameters {
+    exact: boolean;
+    ideal: boolean;
+}
+
+interface NumberRange {
+    max: number;
+    min: number;
+}
+
+interface ConstrainNumberRange extends NumberRange {
+    exact: number;
+    ideal: number;
+}
+
+interface ConstrainStringParameters {
+    exact: string | string[];
+    ideal: string | string[];
+}
+
 interface MediaStreamConstraints {
-  audio: any;
-  video: any;
+    video?: boolean | MediaTrackConstraints;
+    audio?: boolean | MediaTrackConstraints;
 }
-declare var MediaStreamConstraints: {
-  prototype: MediaStreamConstraints;
-  new (): MediaStreamConstraints;
-};
 
 interface MediaTrackConstraints {
-  mandatory: MediaTrackConstraintSet;
-  optional: MediaTrackConstraint[];
+    advanced: MediaTrackConstraintSet[];
+}
+
+declare module W3C {
+    type LongRange = NumberRange;
+    type DoubleRange = NumberRange;
+    type ConstrainBoolean = boolean | ConstrainBooleanParameters;
+    type ConstrainNumber = number | ConstrainNumberRange;
+    type ConstrainLong = ConstrainNumber;
+    type ConstrainDouble = ConstrainNumber;
+    type ConstrainString = string | string[] | ConstrainStringParameters;
 }
-declare var MediaTrackConstraints: {
-  prototype: MediaTrackConstraints;
-  new (): MediaTrackConstraints;
-};
 
-// ks - Not defined in the source doc.
 interface MediaTrackConstraintSet {
+    width: W3C.ConstrainLong;
+    height: W3C.ConstrainLong;
+    aspectRatio: W3C.ConstrainDouble;
+    frameRate: W3C.ConstrainDouble;
+    facingMode: W3C.ConstrainString;
+    volume: W3C.ConstrainDouble;
+    sampleRate: W3C.ConstrainLong;
+    sampleSize: W3C.ConstrainLong;
+    echoCancellation: W3C.ConstrainBoolean;
+    latency: W3C.ConstrainDouble;
+    deviceId: W3C.ConstrainString;
+    groupId: W3C.ConstrainString;
 }
-declare var MediaTrackConstraintSet: {
-  prototype: MediaTrackConstraintSet;
-  new (): MediaTrackConstraintSet;
-};
 
-// ks - Not defined in the source doc.
-interface MediaTrackConstraint {
+interface MediaTrackSupportedConstraints {
+    width: boolean;
+    height: boolean;
+    aspectRatio: boolean;
+    frameRate: boolean;
+    facingMode: boolean;
+    volume: boolean;
+    sampleRate: boolean;
+    sampleSize: boolean;
+    echoCancellation: boolean;
+    latency: boolean;
+    deviceId: boolean;
+    groupId: boolean;
+}
+
+interface MediaStream extends EventTarget {
+    id: string;
+    active: boolean;
+    
+    onactive: EventListener;
+    oninactive: EventListener;
+    onaddtrack: (event: MediaStreamTrackEvent) => any;
+    onremovetrack: (event: MediaStreamTrackEvent) => any;
+    
+    clone(): MediaStream;
+    stop(): void;
+    
+    getAudioTracks(): MediaStreamTrack[];
+    getVideoTracks(): MediaStreamTrack[];
+    getTracks(): MediaStreamTrack[];
+    
+    getTrackById(trackId: string): MediaStreamTrack;
+    
+    addTrack(track: MediaStreamTrack): void;
+    removeTrack(track: MediaStreamTrack): void;
+}
+
+interface MediaStreamTrackEvent extends Event {
+    track: MediaStreamTrack;
+}
+
+interface MediaStreamTrack extends EventTarget {
+    id: string;
+    kind: string;
+    label: string;
+    enabled: boolean;
+    muted: boolean;
+    remote: boolean;
+    readyState: string;
+    
+    onmute: EventListener;
+    onunmute: EventListener;
+    onended: EventListener;
+    onoverconstrained: EventListener;
+    
+    clone(): MediaStreamTrack;
+    
+    stop(): void;
+    
+    getCapabilities(): MediaTrackCapabilities;
+    getConstraints(): MediaTrackConstraints;
+    getSettings(): MediaTrackSettings;
+    applyConstraints(constraints: MediaTrackConstraints): Promise<void>;
+}
+
+interface MediaTrackCapabilities {
+    width: number | W3C.LongRange;
+    height: number | W3C.LongRange;
+    aspectRatio: number | W3C.DoubleRange;
+    frameRate: number | W3C.DoubleRange;
+    facingMode: string;
+    volume: number | W3C.DoubleRange;
+    sampleRate: number | W3C.LongRange;
+    sampleSize: number | W3C.LongRange;
+    echoCancellation: boolean[];
+    latency: number | W3C.DoubleRange;
+    deviceId: string;
+    groupId: string;
+}
+
+interface MediaTrackSettings {
+    width: number;
+    height: number;
+    aspectRatio: number;
+    frameRate: number;
+    facingMode: string;
+    volume: number;
+    sampleRate: number;
+    sampleSize: number;
+    echoCancellation: boolean;
+    latency: number;
+    deviceId: string;
+    groupId: string;
+}
+
+interface MediaStreamError {
+    name: string;
+    message: string;
+    constraintName: string;
+}
+
+interface NavigatorGetUserMedia {
+    (constraints: MediaStreamConstraints,
+     successCallback: (stream: MediaStream) => void,
+     errorCallback: (error: MediaStreamError) => void): void;
 }
-declare var MediaTrackConstraint: {
-  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;
-  mozGetUserMedia(constraints: MediaStreamConstraints,
-                  successCallback: (stream: any) => void,
-                  errorCallback: (error: Error) => void): void;
+    getUserMedia: NavigatorGetUserMedia;
+    
+    webkitGetUserMedia: NavigatorGetUserMedia;
+    
+    mozGetUserMedia: NavigatorGetUserMedia;
+    
+    msGetUserMedia: NavigatorGetUserMedia;
+    
+    mediaDevices: MediaDevices;
 }
 
-interface EventHandler { (event: Event): void; }
-
-interface NavigatorUserMediaSuccessCallback {
-  (stream: LocalMediaStream): void;
+interface MediaDevices {
+    getSupportedConstraints(): MediaTrackSupportedConstraints;
+    
+    getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream>;
 }
-
-interface NavigatorUserMediaError {
-  PERMISSION_DENIED: number; // = 1;
-  code: number;
-}
-declare var NavigatorUserMediaError: {
-  prototype: NavigatorUserMediaError;
-  new (): NavigatorUserMediaError;
-  PERMISSION_DENIED: number; // = 1;
-};
-
-interface NavigatorUserMediaErrorCallback {
-  (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;
-}
-declare var MediaStreamTrackList: {
-  prototype: MediaStreamTrackList;
-  new (): MediaStreamTrackList;
-};
-declare var webkitMediaStreamTrackList: {
-  prototype: MediaStreamTrackList;
-  new (): MediaStreamTrackList;
-};
-
-interface MediaStream extends EventTarget{
-  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;
-};
-declare var webkitMediaStream: {
-  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;
-}
-declare var SourceInfo: {
-  prototype: SourceInfo;
-};
-
-interface LocalMediaStream extends MediaStream {
-  stop(): void;
-}
-
-interface MediaStreamTrack extends EventTarget{
-  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;
-};
-
-interface streamURL extends URL {
-  createObjectURL(stream: MediaStream): string;
-}
-//declare var URL: {
-//  prototype: MediaStreamTrack;
-//  new (): URL;
-//  createObjectURL(stream: MediaStream): string;
-//}
-
-interface WebkitURL extends streamURL {
-}
-declare var webkitURL: {
-  prototype: WebkitURL;
-  new (): streamURL;
-  createObjectURL(stream: MediaStream): string;
-};