@scaleflex/widget-webcam 0.0.1

package/lib/index.js

@@ -0,0 +1,527 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { Plugin } from '@scaleflex/widget-core';
+import Explorer from '@scaleflex/widget-explorer';
+import Translator from '@scaleflex/widget-utils/lib/Translator';
+import getFileTypeExtension from '@scaleflex/widget-utils/lib/getFileTypeExtension';
+import mimeTypes from '@scaleflex/widget-utils/lib/mimeTypes';
+import canvasToBlob from '@scaleflex/widget-utils/lib/canvasToBlob';
+import { PLUGINS_IDS } from '@scaleflex/widget-utils/lib/constants';
+import { CameraIcon } from '@scaleflex/widget-icons/lib';
+import supportsMediaRecorder from './supportsMediaRecorder';
+import CameraScreen from './CameraScreen';
+import PermissionsScreen from './PermissionsScreen';
+import defaultLocale from './defaultLocale';
+import webcamReducer, { webcamCommonStateUpdated } from './common.slice';
+// TODO: find a way to show version of the current plugin
+// why solution below isn't good?
+// first import doesn't work with webpack 5 as it was deprecated
+// second import fixes webpack 5 issue as it was mentioned in their docs
+// but it exposes our package.json to the client and it is mentioned as security rist in mutiple places
+// https://github.com/axelpale/genversion
+// https://stackoverflow.com/questions/64993118/error-should-not-import-the-named-export-version-imported-as-version
+// https://stackoverflow.com/questions/9153571/is-there-a-way-to-get-version-from-package-json-in-nodejs-code/10855054#10855054
+// import { version } from '../package.json'
+// import packageInfo from '../package.json'
+
+/**
+ * Normalize a MIME type or file extension into a MIME type.
+ *
+ * @param {string} fileType - MIME type or a file extension prefixed with `.`.
+ * @returns {string|undefined} The MIME type or `undefined` if the fileType is an extension and is not known.
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+function toMimeType(fileType) {
+  if (fileType[0] === '.') {
+    return mimeTypes[fileType.slice(1)];
+  }
+  return fileType;
+}
+
+/**
+ * Is this MIME type a video?
+ *
+ * @param {string} mimeType - MIME type.
+ * @returns {boolean}
+ */
+function isVideoMimeType(mimeType) {
+  return /^video\/[^*]+$/.test(mimeType);
+}
+
+/**
+ * Is this MIME type an image?
+ *
+ * @param {string} mimeType - MIME type.
+ * @returns {boolean}
+ */
+function isImageMimeType(mimeType) {
+  return /^image\/[^*]+$/.test(mimeType);
+}
+
+/**
+ * Setup getUserMedia, with polyfill for older browsers
+ * Adapted from: https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia
+ */
+function getMediaDevices() {
+  if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
+    return navigator.mediaDevices;
+  }
+  var _getUserMedia = navigator.mozGetUserMedia || navigator.webkitGetUserMedia;
+  if (!_getUserMedia) {
+    return null;
+  }
+  return {
+    getUserMedia: function getUserMedia(opts) {
+      return new Promise(function (resolve, reject) {
+        _getUserMedia.call(navigator, opts, resolve, reject);
+      });
+    }
+  };
+}
+/**
+ * Webcam
+ */
+var Webcam = /*#__PURE__*/function (_Plugin) {
+  // static VERSION = packageInfo.version
+
+  function Webcam(filerobot) {
+    var _this;
+    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, Webcam);
+    _this = _callSuper(this, Webcam, [filerobot, opts]);
+    _defineProperty(_this, "_clearRecordingTimer", function () {
+      if (_this.opts.showRecordingLength) {
+        // Stop the recordingLengthTimer if we are showing the recording length.
+        clearInterval(_this.recordingLengthTimer);
+        _this.setPluginCommonState({
+          recordingLengthSeconds: 0
+        });
+      }
+    });
+    _this.mediaDevices = getMediaDevices();
+    _this.supportsUserMedia = !!_this.mediaDevices;
+    _this.protocol = location.protocol.match(/https/i) ? 'https' : 'http';
+    _this.id = PLUGINS_IDS.WEBCAM;
+    _this.title = _this.opts.title || 'Camera';
+    _this.type = 'acquirer';
+    _this.icon = CameraIcon;
+    _this.defaultLocale = {
+      strings: defaultLocale
+    };
+
+    // set default options
+    var defaultOptions = {
+      onBeforeSnapshot: function onBeforeSnapshot() {
+        return Promise.resolve();
+      },
+      countdown: false,
+      modes: ['video-audio', 'video-only', 'audio-only', 'picture'],
+      mirror: true,
+      facingMode: 'user',
+      preferredImageMimeType: 'image/jpeg',
+      preferredVideoMimeType: null,
+      showRecordingLength: true,
+      isRecordIconHidden: false
+    };
+    _this.opts = _objectSpread(_objectSpread({}, defaultOptions), opts);
+    _this.i18nInit();
+    _this.install = _this.install.bind(_this);
+    _this.render = _this.render.bind(_this);
+
+    // Camera controls
+    _this._start = _this._start.bind(_this);
+    _this._stop = _this._stop.bind(_this);
+    _this._takeSnapshot = _this._takeSnapshot.bind(_this);
+    _this._startRecording = _this._startRecording.bind(_this);
+    _this._stopRecording = _this._stopRecording.bind(_this);
+    _this._oneTwoThreeSmile = _this._oneTwoThreeSmile.bind(_this);
+    _this._focus = _this._focus.bind(_this);
+    _this.webcamActive = false;
+    if (_this.opts.countdown) {
+      _this.opts.onBeforeSnapshot = _this._oneTwoThreeSmile;
+    }
+    return _this;
+  }
+  _inherits(Webcam, _Plugin);
+  return _createClass(Webcam, [{
+    key: "i18nInit",
+    value: function i18nInit() {
+      this.translator = new Translator([this.defaultLocale, this.filerobot.locale, this.opts.locale]);
+      this.i18n = this.translator.translate.bind(this.translator);
+      this.i18nArray = this.translator.translateArray.bind(this.translator);
+    }
+  }, {
+    key: "setPluginCommonState",
+    value: function setPluginCommonState(update) {
+      return this.dispatch(webcamCommonStateUpdated(update));
+    }
+  }, {
+    key: "getPluginReducer",
+    value: function getPluginReducer() {
+      return webcamReducer;
+    }
+  }, {
+    key: "hasCameraCheck",
+    value: function hasCameraCheck() {
+      if (!this.mediaDevices) {
+        return Promise.resolve(false);
+      }
+      return this.mediaDevices.enumerateDevices().then(function (devices) {
+        return devices.some(function (device) {
+          return device.kind === 'videoinput';
+        });
+      });
+    }
+  }, {
+    key: "getConstraints",
+    value: function getConstraints() {
+      var acceptsAudio = this.opts.modes.indexOf('video-audio') !== -1 || this.opts.modes.indexOf('audio-only') !== -1;
+      var acceptsVideo = this.opts.modes.indexOf('video-audio') !== -1 || this.opts.modes.indexOf('video-only') !== -1 || this.opts.modes.indexOf('picture') !== -1;
+      return {
+        audio: acceptsAudio,
+        video: acceptsVideo ? {
+          facingMode: this.opts.facingMode
+        } : false
+      };
+    }
+  }, {
+    key: "_start",
+    value: function _start() {
+      var _this2 = this;
+      if (!this.supportsUserMedia) {
+        return Promise.reject(new Error('Webcam access not supported'));
+      }
+      this.webcamActive = true;
+      var constraints = this.getConstraints();
+      this.hasCameraCheck().then(function (hasCamera) {
+        _this2.setPluginCommonState({
+          hasCamera: hasCamera
+        });
+
+        // ask user for access to their camera
+        return _this2.mediaDevices.getUserMedia(constraints).then(function (stream) {
+          _this2.stream = stream;
+          _this2.setPluginCommonState({
+            cameraReady: true
+          });
+        })["catch"](function (err) {
+          _this2.setPluginCommonState({
+            cameraError: err
+          });
+        });
+      });
+    }
+
+    /**
+     * @returns {object}
+     */
+  }, {
+    key: "_getMediaRecorderOptions",
+    value: function _getMediaRecorderOptions() {
+      var options = {};
+
+      // Try to use the `opts.preferredVideoMimeType` or one of the `allowedFileTypes` for the recording.
+      // If the browser doesn't support it, we'll fall back to the browser default instead.
+      // Safari doesn't have the `isTypeSupported` API.
+      if (MediaRecorder.isTypeSupported) {
+        var restrictions = this.filerobot.opts.restrictions;
+        var preferredVideoMimeTypes = [];
+        if (this.opts.preferredVideoMimeType) {
+          preferredVideoMimeTypes = [this.opts.preferredVideoMimeType];
+        } else if (restrictions.allowedFileTypes) {
+          preferredVideoMimeTypes = restrictions.allowedFileTypes.map(toMimeType).filter(isVideoMimeType);
+        }
+        var acceptableMimeTypes = preferredVideoMimeTypes.filter(function (candidateType) {
+          return MediaRecorder.isTypeSupported(candidateType) && getFileTypeExtension(candidateType);
+        });
+        if (acceptableMimeTypes.length > 0) {
+          options.mimeType = acceptableMimeTypes[0];
+        }
+      }
+      return options;
+    }
+  }, {
+    key: "_startRecording",
+    value: function _startRecording() {
+      var _this3 = this;
+      if (!this.stream) {
+        this.filerobot.info(this.i18n('webcamWaitFewSecsAndTryInfo'));
+        return;
+      }
+      this.recorder = new MediaRecorder(this.stream, this._getMediaRecorderOptions());
+      this.recordingChunks = [];
+      var stoppingBecauseOfMaxSize = false;
+      this.recorder.addEventListener('dataavailable', function (event) {
+        _this3.recordingChunks.push(event.data);
+        var restrictions = _this3.filerobot.opts.restrictions;
+        if (_this3.recordingChunks.length > 1 && restrictions.maxFileSize != null && !stoppingBecauseOfMaxSize) {
+          var totalSize = _this3.recordingChunks.reduce(function (acc, chunk) {
+            return acc + chunk.size;
+          }, 0);
+          // Exclude the initial chunk from the average size calculation because it is likely to be a very small outlier
+          var averageChunkSize = (totalSize - _this3.recordingChunks[0].size) / (_this3.recordingChunks.length - 1);
+          var expectedEndChunkSize = averageChunkSize * 3;
+          var maxSize = Math.max(0, restrictions.maxFileSize - expectedEndChunkSize);
+          if (totalSize > maxSize) {
+            stoppingBecauseOfMaxSize = true;
+            _this3.filerobot.info(_this3.i18n('webcamRecordingStoppedMaxSizeInfo'), 'warning', 4000);
+            _this3._stopRecording();
+          }
+        }
+      });
+
+      // use a "time slice" of 500ms: ondataavailable will be called each 500ms
+      // smaller time slices mean we can more accurately check the max file size restriction
+      this.recorder.start(500);
+      if (this.opts.showRecordingLength) {
+        // Start the recordingLengthTimer if we are showing the recording length.
+        this.recordingLengthTimer = setInterval(function () {
+          var currentRecordingLength = _this3.getPluginCommonState().recordingLengthSeconds;
+          _this3.setPluginCommonState({
+            recordingLengthSeconds: currentRecordingLength + 1
+          });
+        }, 1000);
+      }
+      this.setPluginCommonState({
+        isRecording: true
+      });
+    }
+  }, {
+    key: "_stopRecording",
+    value: function _stopRecording() {
+      var _this4 = this;
+      var stopped = new Promise(function (resolve, reject) {
+        _this4.recorder.addEventListener('stop', function () {
+          resolve();
+        });
+        _this4.recorder.stop();
+        _this4._clearRecordingTimer();
+      });
+      return stopped.then(function () {
+        _this4.setPluginCommonState({
+          isRecording: false
+        });
+        return _this4.getVideo();
+      }).then(function (file) {
+        try {
+          _this4.filerobot.addFile(file);
+        } catch (err) {
+          // Logging the error, exept restrictions, which is handled in Core
+          if (!err.isRestriction) {
+            _this4.filerobot.log(err);
+          }
+        }
+      }).then(function () {
+        _this4.recordingChunks = null;
+        _this4.recorder = null;
+      }, function (error) {
+        _this4.recordingChunks = null;
+        _this4.recorder = null;
+        throw error;
+      });
+    }
+  }, {
+    key: "_stop",
+    value: function _stop() {
+      if (this.stream) {
+        this.stream.getAudioTracks().forEach(function (track) {
+          track.stop();
+        });
+        this.stream.getVideoTracks().forEach(function (track) {
+          track.stop();
+        });
+      }
+      if (this.getPluginCommonState().isRecording) {
+        this._clearRecordingTimer();
+        this.setPluginCommonState({
+          isRecording: false
+        });
+      }
+      this.webcamActive = false;
+      this.stream = null;
+    }
+  }, {
+    key: "_getVideoElement",
+    value: function _getVideoElement() {
+      return document.body.querySelector('.filerobot-Webcam-video');
+    }
+  }, {
+    key: "_oneTwoThreeSmile",
+    value: function _oneTwoThreeSmile() {
+      var _this5 = this;
+      return new Promise(function (resolve, reject) {
+        var count = _this5.opts.countdown;
+        var countDown = setInterval(function () {
+          if (!_this5.webcamActive) {
+            clearInterval(countDown);
+            _this5.captureInProgress = false;
+            return reject(new Error('Webcam is not active'));
+          }
+          if (count > 0) {
+            _this5.filerobot.info("".concat(count, "..."), 'warning', 800);
+            count--;
+          } else {
+            clearInterval(countDown);
+            _this5.filerobot.info(_this5.i18n('webcamSmileInfo'), 'success', 1500);
+            setTimeout(function () {
+              return resolve();
+            }, 1500);
+          }
+        }, 1000);
+      });
+    }
+  }, {
+    key: "_takeSnapshot",
+    value: function _takeSnapshot() {
+      var _this6 = this;
+      if (this.captureInProgress) return;
+      this.captureInProgress = true;
+      this.opts.onBeforeSnapshot()["catch"](function (err) {
+        var message = _typeof(err) === 'object' ? err.message : err;
+        _this6.filerobot.info(message, 'error', 5000);
+        return Promise.reject(new Error("onBeforeSnapshot: ".concat(message)));
+      }).then(function () {
+        return _this6._getImage();
+      }).then(function (tagFile) {
+        _this6.captureInProgress = false;
+        try {
+          _this6.filerobot.addFile(tagFile);
+        } catch (err) {
+          // Logging the error, except restrictions, which is handled in Core
+          if (!err.isRestriction) {
+            _this6.filerobot.log(err);
+          }
+        }
+      }, function (error) {
+        _this6.captureInProgress = false;
+        throw error;
+      });
+    }
+  }, {
+    key: "_getImage",
+    value: function _getImage() {
+      var _this7 = this;
+      var video = this._getVideoElement();
+      if (!video) {
+        return Promise.reject(new Error('No video element found, likely due to the Webcam tab being closed.'));
+      }
+      var width = video.videoWidth;
+      var height = video.videoHeight;
+      var canvas = document.createElement('canvas');
+      canvas.width = width;
+      canvas.height = height;
+      var ctx = canvas.getContext('2d');
+      ctx.drawImage(video, 0, 0);
+      var restrictions = this.filerobot.opts.restrictions;
+      var preferredImageMimeTypes = [];
+      if (this.opts.preferredImageMimeType) {
+        preferredImageMimeTypes = [this.opts.preferredImageMimeType];
+      } else if (restrictions.allowedFileTypes) {
+        preferredImageMimeTypes = restrictions.allowedFileTypes.map(toMimeType).filter(isImageMimeType);
+      }
+      var mimeType = preferredImageMimeTypes[0] || 'image/jpeg';
+      var ext = getFileTypeExtension(mimeType) || 'jpg';
+      var name = "cam-".concat(Date.now(), ".").concat(ext);
+      return canvasToBlob(canvas, mimeType).then(function (blob) {
+        return {
+          source: _this7.id,
+          name: name,
+          data: new Blob([blob], {
+            type: mimeType
+          }),
+          type: mimeType
+        };
+      });
+    }
+  }, {
+    key: "getVideo",
+    value: function getVideo() {
+      var mimeType = this.recordingChunks[0].type;
+      var fileExtension = getFileTypeExtension(mimeType);
+      if (!fileExtension) {
+        return Promise.reject(new Error("Could not retrieve recording: Unsupported media type \"".concat(mimeType, "\"")));
+      }
+      var name = "webcam-".concat(Date.now(), ".").concat(fileExtension);
+      var blob = new Blob(this.recordingChunks, {
+        type: mimeType
+      });
+      var file = {
+        source: this.id,
+        name: name,
+        data: new Blob([blob], {
+          type: mimeType
+        }),
+        type: mimeType
+      };
+      return Promise.resolve(file);
+    }
+  }, {
+    key: "_focus",
+    value: function _focus() {
+      var _this8 = this;
+      if (!this.opts.countdown) return;
+      setTimeout(function () {
+        _this8.filerobot.info(_this8.i18n('webcamSmileInfo'), 'success', 1500);
+      }, 1000);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      if (!this.webcamActive) {
+        this._start();
+      }
+      var webcamState = this.getPluginCommonState();
+      if (!webcamState.cameraReady || !webcamState.hasCamera) {
+        return /*#__PURE__*/_jsx(PermissionsScreen, {
+          i18n: this.i18n,
+          hasCamera: webcamState.hasCamera
+        });
+      }
+      return /*#__PURE__*/_jsx(CameraScreen, {
+        onSnapshot: this._takeSnapshot,
+        onStartRecording: this._startRecording,
+        onStopRecording: this._stopRecording,
+        onFocus: this._focus,
+        onStop: this._stop,
+        modes: this.opts.modes,
+        showRecordingLength: this.opts.showRecordingLength,
+        supportsRecording: supportsMediaRecorder(),
+        isRecording: webcamState.isRecording,
+        recordingLengthSeconds: webcamState.recordingLengthSeconds,
+        mirror: this.opts.mirror,
+        src: this.stream,
+        isRecordIconHidden: this.opts.isRecordIconHidden
+      });
+    }
+  }, {
+    key: "install",
+    value: function install() {
+      if (Explorer) {
+        this.mount(Explorer, this);
+      }
+    }
+  }, {
+    key: "uninstall",
+    value: function uninstall() {
+      if (this.stream) {
+        this._stop();
+      }
+      this.unmount();
+    }
+  }]);
+}(Plugin);
+export { Webcam as default };

package/lib/supportsMediaRecorder.js

@@ -0,0 +1,3 @@
+export default function supportsMediaRecorder() {
+  return typeof MediaRecorder === 'function' && !!MediaRecorder.prototype && typeof MediaRecorder.prototype.start === 'function';
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@scaleflex/widget-webcam",
+  "description": "Scaleflex plugin that takes photos or records videos using the device's camera.",
+  "version": "0.0.1",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "style": "dist/style.min.css",
+  "types": "types/index.d.ts",
+  "dependencies": {
+    "@scaleflex/widget-common": "^0.0.1",
+    "@scaleflex/widget-icons": "^0.0.1",
+    "@scaleflex/widget-utils": "^0.0.1"
+  },
+  "devDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "peerDependencies": {
+    "@scaleflex/widget-core": "^0.0.0",
+    "@scaleflex/widget-explorer": "^0.0.0",
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0"
+  },
+  "files": [
+    "/dist",
+    "/lib",
+    "/types"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "64ea82e745b7deda36d6794863350e6671e9010d"
+}

package/types/index.d.ts

@@ -0,0 +1,25 @@
+import Filerobot = require("@scaleflex/widget-core");
+import WebcamLocale = require("./generatedLocale");
+
+declare module Webcam {
+  export type WebcamMode =
+    | "video-audio"
+    | "video-only"
+    | "audio-only"
+    | "picture";
+
+  export interface WebcamOptions extends Filerobot.PluginOptions {
+    replaceTargetContent?: boolean;
+    target?: Filerobot.PluginTarget;
+    onBeforeSnapshot?: () => Promise<void>;
+    countdown?: number | boolean;
+    mirror?: boolean;
+    facingMode?: string;
+    modes?: WebcamMode[];
+    locale?: WebcamLocale;
+  }
+}
+
+declare class Webcam extends Filerobot.Plugin<Webcam.WebcamOptions> {}
+
+export = Webcam;