interface Event {};
    interface EventHandler {};
    interface EventTarget {};
    interface MediaStreamTrack {};
  

    // https://w3c.github.io/mediacapture-image

    [Constructor(MediaStreamTrack videoTrack)]
    interface ImageCapture {
       Promise              takePhoto(optional PhotoSettings photoSettings);
       Promise getPhotoCapabilities();

       Promise       grabFrame();

       readonly attribute MediaStreamTrack track;
    };

    interface PhotoCapabilities {
      readonly attribute RedEyeReduction            redEyeReduction;
      readonly attribute MediaSettingsRange         imageHeight;
      readonly attribute MediaSettingsRange         imageWidth;
      readonly attribute FrozenArray fillLightMode;
    };

    dictionary PhotoSettings {
      FillLightMode   fillLightMode;
      double          imageHeight;
      double          imageWidth;
      boolean         redEyeReduction;
    };

    interface MediaSettingsRange {
        readonly attribute double max;
        readonly attribute double min;
        readonly attribute double step;
    };

    enum RedEyeReduction {
      "never",
      "always",
      "controllable",
    };

    enum FillLightMode {
      "auto",
      "off",
      "flash",
    };

    // Partial dictionaries are unsupported, see
    // https://github.com/w3c/testharness.js/issues/84

    partial dictionary MediaTrackSupportedConstraints {
      boolean whiteBalanceMode = true;
      boolean exposureMode = true;
      boolean focusMode = true;
      boolean pointsOfInterest = true;

      boolean exposureCompensation = true;
      boolean colorTemperature = true;
      boolean iso = true;

      boolean brightness = true;
      boolean contrast = true;
      boolean saturation = true;
      boolean sharpness = true;
      boolean zoom = true;
      boolean torch = true;
    };

    partial dictionary MediaTrackCapabilities {
      sequence  whiteBalanceMode;
      sequence  exposureMode;
      sequence  focusMode;

      MediaSettingsRange   exposureCompensation;
      MediaSettingsRange   colorTemperature;
      MediaSettingsRange   iso;

      MediaSettingsRange   brightness;
      MediaSettingsRange   contrast;
      MediaSettingsRange   saturation;
      MediaSettingsRange   sharpness;

      MediaSettingsRange   zoom;

      boolean              torch;
    };

    partial dictionary MediaTrackConstraintSet {
      ConstrainDOMString whiteBalanceMode;
      ConstrainDOMString exposureMode;
      ConstrainDOMString focusMode;
      ConstrainPoint2D   pointsOfInterest;

      ConstrainDouble    exposureCompensation;
      ConstrainDouble    colorTemperature;
      ConstrainDouble    iso;

      ConstrainDouble    brightness;
      ConstrainDouble    contrast;
      ConstrainDouble    saturation;
      ConstrainDouble    sharpness;

      ConstrainDouble    zoom;

      ConstrainBoolean   torch;
    };

    partial dictionary MediaTrackSettings {
      DOMString         whiteBalanceMode;
      DOMString         exposureMode;
      DOMString         focusMode;
      sequence pointsOfInterest;

      double            exposureCompensation;
      double            colorTemperature;
      double            iso;

      double            brightness;
      double            contrast;
      double            saturation;
      double            sharpness;

      double            zoom;

      boolean           torch;
    };

    dictionary ConstrainPoint2DParameters {
      sequence exact;
      sequence ideal;
    };

    typedef (sequence or ConstrainPoint2DParameters) ConstrainPoint2D;

    enum MeteringMode {
      "none",
      "manual",
      "single-shot",
      "continuous"
    };

    dictionary Point2D {
      double x = 0.0;
      double y = 0.0;
    };