@scaleflex/widget-core 0.0.1

package/lib/slices/user.slice.js

@@ -0,0 +1,256 @@
+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 _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 { createSlice, isAnyOf } from '@reduxjs/toolkit';
+import checkPermissions from '@scaleflex/widget-utils/lib/checkPermissions';
+import createThunk from '@scaleflex/widget-utils/lib/createThunk';
+import { AUTH_STATE, PERMISSIONS, PLUGINS_IDS } from '@scaleflex/widget-utils/lib/constants';
+import { slicePropName as coreCommonSliceName } from './common.slice';
+
+/**
+ * The order of the code in slice file is:
+ *  1. initialState (*No* export needed)
+ *  2. automated thunks functions -- uses createThunk API-- (export needed)
+ *  3. createSlice (*No* export needed)
+ *  4. actions exports
+ *  5. selectors (export needed)
+ *  6. default reducer export
+ *
+ */
+var slicePropName = 'user';
+var sliceName = "".concat(PLUGINS_IDS.CORE, "/").concat(slicePropName);
+var sassKeyExpireDuration = 1170000; // 19.5 minutes
+
+var initialState = {
+  sassKey: '',
+  authState: AUTH_STATE.ANONYMOUS,
+  permissions: {},
+  // userCheckedPermissions
+  securityData: {},
+  info: {} // possible to be empty, most probably won't be empty in-case of login mode.
+};
+export var generateUserKey = createThunk(async function (_, thunkApi) {
+  var _userAuthInfo$key_val, _userAuthInfo$key_val2, _filerobot$getPlugin$, _filerobot$getPlugin;
+  var _thunkApi$extra = thunkApi.extra,
+    filerobot = _thunkApi$extra.filerobot,
+    apiClient = _thunkApi$extra.apiClient;
+  var url = "".concat(filerobot.opts.apiEndpointWithContainer, "/key/").concat(filerobot.opts.securityTemplateId);
+
+  // Retrieve sassKey from server through security template id
+  var userAuthInfo = await apiClient.get(url, {
+    signal: thunkApi.signal,
+    noDefaultHeaders: true
+  });
+  var userAuthState = await thunkApi.dispatch(fetchUserAuthState({
+    userSassKey: userAuthInfo.key,
+    skipDispatch: true
+  }));
+
+  // Re-generate a new sassKey before the current one expires.
+  setTimeout(function () {
+    thunkApi.dispatch(generateUserKey());
+  }, (_userAuthInfo$key_val = (_userAuthInfo$key_val2 = userAuthInfo.key_validity) === null || _userAuthInfo$key_val2 === void 0 ? void 0 : _userAuthInfo$key_val2.expire_duration) !== null && _userAuthInfo$key_val !== void 0 ? _userAuthInfo$key_val : sassKeyExpireDuration);
+  filerobot.emit('sass-key-obtained', userAuthInfo.key);
+  var _ref = (_filerobot$getPlugin$ = (_filerobot$getPlugin = filerobot.getPlugin(PLUGINS_IDS.EXPLORER)) === null || _filerobot$getPlugin === void 0 ? void 0 : _filerobot$getPlugin.opts) !== null && _filerobot$getPlugin$ !== void 0 ? _filerobot$getPlugin$ : {},
+    useAssetsPicker = _ref.useAssetsPicker;
+
+  // Removed permissions from here, as we will always check the permissions in the userAuthState request.
+  return _objectSpread(_objectSpread({}, userAuthState), {}, {
+    useAssetsPicker: useAssetsPicker,
+    sassKey: userAuthInfo.key,
+    securityData: userAuthInfo
+  });
+}, {
+  actionType: "".concat(sliceName, "/generateUserKey")
+});
+export var saveUserSassKey = createThunk(function (userSassKey, thunkApi) {
+  thunkApi.extra.filerobot.emit('sass-key-obtained', userSassKey);
+  var userSecurityData = selectUserSecurityData(thunkApi.getState());
+  return thunkApi.dispatch(userUpdated({
+    sassKey: userSassKey,
+    securityData: _objectSpread(_objectSpread({}, userSecurityData), {}, {
+      key: userSassKey
+    })
+  }));
+});
+export var fetchUserAuthState = createThunk(async function () {
+  var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    userSassKey = _ref2.userSassKey,
+    skipDispatch = _ref2.skipDispatch;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  // We will have skipDispatch: true, when we call the fetchUserAuthState from the generateUserKey thunk,
+  // as we'll wait for the generateUserKey thunk & fetchUserAuthState thunk to finish then update the user state once,
+  // otherwise the user state should have skipDispatch: false, to update the user state after finishing its request.
+  if (skipDispatch) {
+    thunkApi.skipDispatch();
+  }
+  if (!userSassKey) {
+    thunkApi.skipDispatch();
+    return thunkApi.rejectWithValue('No sass key provided.');
+  }
+  var _thunkApi$extra2 = thunkApi.extra,
+    filerobot = _thunkApi$extra2.filerobot,
+    apiClient = _thunkApi$extra2.apiClient;
+  var _await$apiClient$get = await apiClient.get("".concat(filerobot.opts.apiEndpointWithContainer, "/v4/key/info?key=").concat(userSassKey), {
+      abortSignal: thunkApi.signal,
+      noDefaultHeaders: true
+    }),
+    isValidate = _await$apiClient$get.is_validate,
+    isUserInfoIncluded = _await$apiClient$get.is_user_info_included,
+    permissions = _await$apiClient$get.permissions;
+  var userAuthState = AUTH_STATE.ANONYMOUS;
+  if (isValidate) {
+    userAuthState = isUserInfoIncluded ? AUTH_STATE.AUTH : AUTH_STATE.UNAUTH;
+  }
+  // If no skipDispatch then emit the event, as this means no request is triggered for generating the sass key and sass key is provided from opts.
+  if (!skipDispatch) {
+    filerobot.emit('sass-key-obtained', userSassKey);
+  }
+  return {
+    sassKey: userSassKey,
+    authState: userAuthState,
+    permissions: checkPermissions(Array.isArray(permissions) && permissions.length > 0 ? permissions : filerobot.opts.userPermissions || permissions || [], Object.values(PERMISSIONS), true)
+  };
+}, {
+  actionType: "".concat(sliceName, "/fetchUserAuthState"),
+  dismissGlobalAbort: true
+});
+export var userLogout = createThunk(function (_, thunkApi) {
+  var filerobot = thunkApi.extra.filerobot;
+  filerobot.emit('sass-key-obtained', undefined);
+  thunkApi.dispatch(userReset());
+});
+export var loginUserByCredentials = createThunk(async function (_ref3, thunkApi) {
+  var email = _ref3.email,
+    password = _ref3.password;
+  thunkApi.skipPendingDispatch();
+  var _thunkApi$extra3 = thunkApi.extra,
+    filerobot = _thunkApi$extra3.filerobot,
+    apiClient = _thunkApi$extra3.apiClient;
+  var token = filerobot.opts.container;
+  var response = await apiClient.postAdmin("login?token=".concat(token), {
+    data: {
+      login: {
+        email: email,
+        password: password
+      }
+    },
+    abortSignal: thunkApi.signal
+  });
+  var _ref4 = response || {},
+    userUuid = _ref4.user_uuid,
+    userEmail = _ref4.user_email,
+    sessionUuid = _ref4.session_uuid,
+    userPhotoUri = _ref4.user_photo_uri,
+    keychain = _ref4.keychain,
+    userName = _ref4.user_name;
+  // TODO: keyDuration is not supported from BE but added to be considered from their side once they add.
+  var _ref5 = (keychain === null || keychain === void 0 ? void 0 : keychain.tokens) || {},
+    userSassKey = _ref5.airstore_key,
+    permissions = _ref5.permissions;
+  if (userSassKey) {
+    filerobot.emit('sass-key-obtained', userSassKey);
+    if (filerobot.opts.sassKeyRenewerEnabled) {
+      // Send renew sass key request each hour
+      filerobot.sassKeyRenewer.subscribe();
+    }
+
+    // Expire the sass key if the duration is not 0, then the login page will show again.
+    // if (keyDuration !== 0) { // DEPRECATED! Not necessary according to new SassKeyRenewer logic
+    //   setTimeout(() => {
+    //     thunkApi.dispatch(userLogout())
+    //   }, keyDuration)
+    // }
+  } else {
+    return thunkApi.rejectWithValue(new Error('No sass key generated, please try again later.'));
+  }
+  return {
+    sassKey: userSassKey,
+    authState: AUTH_STATE.AUTH,
+    permissions: checkPermissions(Array.isArray(permissions) && permissions.length > 0 ? permissions : filerobot.opts.userPermissions || permissions || [], Object.values(PERMISSIONS), true),
+    info: {
+      uuid: userUuid,
+      email: userEmail,
+      name: userName,
+      photo_uri: userPhotoUri,
+      sessionUuid: sessionUuid
+    }
+  };
+}, {
+  actionType: "".concat(sliceName, "/loginUserByCredentials")
+});
+var userSlice = createSlice({
+  name: sliceName,
+  initialState: initialState,
+  reducers: {
+    userUpdated: function userUpdated(state, action) {
+      var newUserData = action.payload;
+      return _objectSpread(_objectSpread({}, state), newUserData);
+    },
+    userReset: function userReset(state) {
+      return _objectSpread(_objectSpread({}, state), initialState);
+    },
+    userInfoUpdated: function userInfoUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        info: _objectSpread(_objectSpread({}, state.info || {}), action.payload || {})
+      });
+    }
+  },
+  extraReducers: function extraReducers(builder) {
+    builder.addCase(generateUserKey.fulfilled, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    }).addMatcher(isAnyOf(fetchUserAuthState.fulfilled, loginUserByCredentials.fulfilled), function (state, action) {
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    });
+  }
+});
+var _userSlice$actions = userSlice.actions,
+  userUpdated = _userSlice$actions.userUpdated,
+  userInfoUpdated = _userSlice$actions.userInfoUpdated,
+  userReset = _userSlice$actions.userReset;
+export { userUpdated, userInfoUpdated, userReset };
+export var selectUser = function selectUser(state) {
+  return state[PLUGINS_IDS.CORE][slicePropName];
+};
+export var selectUserPermissions = function selectUserPermissions(state) {
+  return selectUser(state).permissions;
+};
+
+// `isDev` is used for enabling any feature requires user auth on dev. environment (in-case it is needed for some checking/improvements) and anyways it won't work from BE side as it requires the user auth.
+export var selectIsUserAuth = function selectIsUserAuth(state) {
+  var _state$PLUGINS_IDS$CO, _state$PLUGINS_IDS$CO2;
+  return ((_state$PLUGINS_IDS$CO = state[PLUGINS_IDS.CORE]) === null || _state$PLUGINS_IDS$CO === void 0 ? void 0 : (_state$PLUGINS_IDS$CO2 = _state$PLUGINS_IDS$CO[coreCommonSliceName]) === null || _state$PLUGINS_IDS$CO2 === void 0 ? void 0 : _state$PLUGINS_IDS$CO2.isDevEnv) || selectUser(state).authState === AUTH_STATE.AUTH;
+};
+export var selectUserSecurityData = function selectUserSecurityData(state) {
+  return selectUser(state).securityData;
+};
+export var selectUserSassKey = function selectUserSassKey(state) {
+  return selectUser(state).sassKey;
+};
+export var selectUserInfo = function selectUserInfo(state) {
+  return selectUser(state).info;
+};
+export var selectUserSessionUuid = function selectUserSessionUuid(state) {
+  return selectUserInfo(state).sessionUuid;
+};
+export var selectIsUserPermittedTo = function selectIsUserPermittedTo(state, permissionToCheck) {
+  var userMustAuth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var userPermissions = selectUserPermissions(state);
+  if (userMustAuth) {
+    var isUserAuth = selectIsUserAuth(state);
+    if (!isUserAuth) {
+      return false;
+    }
+  }
+  return Boolean(userPermissions[permissionToCheck]);
+};
+export var selectIsUserPermittedToShare = function selectIsUserPermittedToShare(state) {
+  return selectIsUserPermittedTo(state, PERMISSIONS.OBJECTS_SHARE_MANAGE, true);
+};
+export var selectIsUserPermittedToDisplayFile = function selectIsUserPermittedToDisplayFile(state) {
+  return selectIsUserPermittedTo(state, PERMISSIONS.DISPLAY);
+};
+export default userSlice.reducer;

package/lib/style.scss

@@ -0,0 +1,3 @@
+@import './_variables.scss';
+@import './_utils.scss';
+@import './_common.scss';

package/lib/supportsUploadProgress.js

@@ -0,0 +1,42 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+// Edge 15.x does not fire 'progress' events on uploads.
+// See https://github.com/transloadit/filerobot/issues/945
+// And https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12224510/
+export default function supportsUploadProgress(userAgent) {
+  // Allow passing in userAgent for tests
+  if (userAgent == null) {
+    userAgent = typeof navigator !== 'undefined' ? navigator.userAgent : null;
+  }
+  // Assume it works because basically everything supports progress events.
+  if (!userAgent) return true;
+  var m = /Edge\/(\d+\.\d+)/.exec(userAgent);
+  if (!m) return true;
+  var edgeVersion = m[1];
+  var _edgeVersion$split = edgeVersion.split('.'),
+    _edgeVersion$split2 = _slicedToArray(_edgeVersion$split, 2),
+    major = _edgeVersion$split2[0],
+    minor = _edgeVersion$split2[1];
+  major = parseInt(major, 10);
+  minor = parseInt(minor, 10);
+
+  // Worked before:
+  // Edge 40.15063.0.0
+  // Microsoft EdgeHTML 15.15063
+  if (major < 15 || major === 15 && minor < 15063) {
+    return true;
+  }
+
+  // Fixed in:
+  // Microsoft EdgeHTML 18.18218
+  if (major > 18 || major === 18 && minor >= 18218) {
+    return true;
+  }
+
+  // other versions don't work.
+  return false;
+}

package/lib/utils/calculateTotalEta.js

@@ -0,0 +1,21 @@
+import getBytesRemaining from '@scaleflex/widget-utils/lib/getBytesRemaining';
+import getSpeed from '@scaleflex/widget-utils/lib/getSpeed';
+var getTotalSpeed = function getTotalSpeed(files) {
+  return files.reduce(function (total, file) {
+    return total + getSpeed(file.progress);
+  }, 0);
+};
+
+// Eta (ETA) = Estimated Time of Arrival to finish operations in seconds
+var calculateTotalEta = function calculateTotalEta(files) {
+  var totalSpeed = getTotalSpeed(files);
+  if (totalSpeed === 0) {
+    return 0;
+  }
+  var totalBytesRemaining = getBytesRemaining(files);
+  if (totalBytesRemaining && totalSpeed) {
+    // ETA = remainingDistance/Speed
+    return Math.round(totalBytesRemaining / totalSpeed * 10) / 10;
+  }
+};
+export default calculateTotalEta;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@scaleflex/widget-core",
+  "description": "Core module for the extensible JavaScript file upload widget with support for drag&drop, resumable uploads, previews, restrictions, file processing/encoding, remote providers like Instagram, Dropbox, Google Drive, Box, One Drive, S3 and more.",
+  "version": "0.0.1",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "style": "dist/style.min.css",
+  "types": "types/index.d.ts",
+  "files": [
+    "/dist",
+    "/lib",
+    "/types"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@reduxjs/toolkit": "^1.9.5",
+    "@scaleflex/icons": "^3.0.0-beta.11",
+    "@scaleflex/ui": "^3.0.0-beta.11",
+    "@scaleflex/widget-utils": "^0.0.1",
+    "@transloadit/prettier-bytes": "0.1.0",
+    "cuid": "^3.0.0",
+    "lodash.throttle": "^4.1.1",
+    "mime-match": "^1.0.2",
+    "namespace-emitter": "^2.0.1",
+    "react-redux": "^8.1.1"
+  },
+  "devDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "peerDependencies": {
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0"
+  },
+  "gitHead": "64ea82e745b7deda36d6794863350e6671e9010d"
+}

package/types/index.d.ts

@@ -0,0 +1,301 @@
+const FilerobotUtils = require("@scaleflex/widget-utils");
+
+declare module Filerobot {
+  // Utility types
+  type OmitKey<T, Key> = Pick<T, Exclude<keyof T, Key>>;
+
+  // These are defined in @scaleflex/widget-utils instead of core so it can be used there without creating import cycles
+  export type FilerobotFile<
+    TMeta extends IndexedObject<any> = {},
+    TBody extends IndexedObject<any> = {}
+  > = FilerobotUtils.FilerobotFile<TMeta, TBody>;
+  export type Store = FilerobotUtils.Store;
+  export type InternalMetadata = FilerobotUtils.InternalMetadata;
+
+  interface IndexedObject<T> {
+    [key: string]: T;
+    [key: number]: T;
+  }
+
+  interface UploadedFilerobotFile<TMeta, TBody>
+    extends FilerobotFile<TMeta, TBody> {
+    uploadURL: string;
+  }
+
+  interface FailedFilerobotFile<TMeta, TBody>
+    extends FilerobotFile<TMeta, TBody> {
+    error: string;
+  }
+
+  // Replace the `meta` property type with one that allows omitting internal metadata; addFile() will add that
+  type FilerobotFileWithoutMeta<TMeta, TBody> = OmitKey<
+    FilerobotFile<TMeta, TBody>,
+    "meta"
+  >;
+  interface AddFileOptions<
+    TMeta = IndexedObject<any>,
+    TBody = IndexedObject<any>
+  > extends Partial<FilerobotFileWithoutMeta<TMeta, TBody>> {
+    // `.data` is the only required property here.
+    data: Blob | File;
+    meta?: Partial<InternalMetadata> & TMeta;
+  }
+
+  interface PluginOptions {
+    id?: string;
+  }
+  interface DefaultPluginOptions extends PluginOptions {
+    [prop: string]: any;
+  }
+
+  type PluginTarget = string | Element | typeof Plugin;
+
+  class Plugin<TOptions extends PluginOptions = DefaultPluginOptions> {
+    id: string;
+    filerobot: Filerobot;
+    type: string;
+    constructor(filerobot: Filerobot, opts?: TOptions);
+    setOptions(update: Partial<TOptions>): void;
+    getPluginState(): object;
+    setPluginState(update: IndexedObject<any>): object;
+    update(state?: object): void;
+    mount(target: PluginTarget, plugin: typeof Plugin): void;
+    render(state: object): void;
+    addTarget<TPlugin extends Plugin>(plugin: TPlugin): void;
+    unmount(): void;
+    install(): void;
+    uninstall(): void;
+  }
+
+  type LocaleStrings<TNames extends string> = {
+    [K in TNames]?: string | { [n: number]: string };
+  };
+  interface Locale<TNames extends string = string> {
+    strings: LocaleStrings<TNames>;
+    pluralize?: (n: number) => number;
+  }
+
+  interface Restrictions {
+    maxFileSize?: number | null;
+    maxNumberOfFiles?: number | null;
+    minNumberOfFiles?: number | null;
+    allowedFileTypes?: string[] | null;
+    maxItemsSizeForCompression: number | null;
+  }
+
+  interface FilerobotOptions<TMeta extends IndexedObject<any> = {}> {
+    container: string;
+    securityTemplateId?: string;
+    sassKey?: string;
+    dev?: boolean;
+    userInfo?: {
+      email: string;
+      name: string;
+      photo_uri: string;
+      uuid: string;
+    };
+    autoProceed?: boolean;
+    allowMultipleUploads?: boolean;
+    debug?: boolean;
+    restrictions?: Restrictions;
+    meta?: TMeta;
+    onBeforeFileAdded?: (
+      currentFile: FilerobotFile<TMeta>,
+      files: { [key: string]: FilerobotFile<TMeta> }
+    ) => FilerobotFile<TMeta> | boolean | undefined;
+    onBeforeUpload?: (files: {
+      [key: string]: FilerobotFile<TMeta>;
+    }) => { [key: string]: FilerobotFile<TMeta> } | boolean;
+    locale?: Locale;
+    store?: Store;
+    userPermissions?: string[];
+    userFoldersScope?: string[];
+    apiEndpoint?: string;
+    skipApiEndpointToken?: boolean;
+    adminApiEndpoint?: string;
+    shareApiEndpoint?: string;
+  }
+
+  interface UploadResult<
+    TMeta extends IndexedObject<any> = {},
+    TBody extends IndexedObject<any> = {}
+  > {
+    successful: UploadedFilerobotFile<TMeta, TBody>[];
+    failed: FailedFilerobotFile<TMeta, TBody>[];
+  }
+
+  interface State<
+    TMeta extends IndexedObject<any> = {},
+    TBody extends IndexedObject<any> = {}
+  > extends IndexedObject<any> {
+    capabilities?: { resumableUploads?: boolean };
+    currentUploads: {};
+    error?: string;
+    files: {
+      [key: string]:
+        | UploadedFilerobotFile<TMeta, TBody>
+        | FailedFilerobotFile<TMeta, TBody>;
+    };
+    info?: {
+      isHidden: boolean;
+      type: string;
+      message: string;
+      details: string;
+    };
+    plugins?: IndexedObject<any>;
+    totalProgress: number;
+  }
+
+  type LogLevel = "info" | "warning" | "error";
+
+  /** Enable the old, untyped `filerobot.use()` signature. */
+  type LooseTypes = "loose";
+  /** Disable the old, untyped `filerobot.use()` signature. */
+  type StrictTypes = "strict";
+  type TypeChecking = LooseTypes | StrictTypes;
+
+  // This hack accepts _any_ string for `Event`, but also tricks VSCode and friends into providing autocompletions
+  // for the names listed. https://github.com/microsoft/TypeScript/issues/29729#issuecomment-505826972
+  type LiteralUnion<T extends U, U = string> = T | (U & {});
+  type Event = LiteralUnion<
+    | "file-added"
+    | "file-removed"
+    | "upload"
+    | "upload-progress"
+    | "upload-success"
+    | "complete"
+    | "error"
+    | "upload-error"
+    | "upload-retry"
+    | "info-visible"
+    | "info-hidden"
+    | "cancel-uploads"
+    | "restriction-failed"
+    | "reset-progress"
+  >;
+
+  type UploadHandler = (fileIDs: string[]) => Promise<void>;
+
+  class Filerobot<TUseStrictTypes extends TypeChecking = TypeChecking> {
+    constructor(opts?: FilerobotOptions);
+    on<TMeta extends IndexedObject<any> = {}>(
+      event: "upload-success",
+      callback: (
+        file: FilerobotFile<TMeta>,
+        body: any,
+        uploadURL: string
+      ) => void
+    ): this;
+    on<TMeta extends IndexedObject<any> = {}>(
+      event: "complete",
+      callback: (result: UploadResult<TMeta>) => void
+    ): this;
+    on(event: Event, callback: (...args: any[]) => void): this;
+    off(event: Event, callback: (...args: any[]) => void): this;
+    /**
+     * For use by plugins only.
+     */
+    emit(event: Event, ...args: any[]): void;
+    updateAll(state: object): void;
+    setOptions(update: Partial<FilerobotOptions>): void;
+    setState(patch: object): void;
+    getState<TMeta extends IndexedObject<any> = {}>(): State<TMeta>;
+    readonly state: State;
+    addPreProcessor(fn: UploadHandler): void;
+    removePreProcessor(fn: UploadHandler): void;
+    addPostProcessor(fn: UploadHandler): void;
+    removePostProcessor(fn: UploadHandler): void;
+    addFilerobot(fn: UploadHandler): void;
+    removeFilerobot(fn: UploadHandler): void;
+    setMeta<TMeta extends IndexedObject<any> = {}>(data: TMeta): void;
+    setFileMeta<TMeta extends IndexedObject<any> = {}>(
+      fileID: string,
+      data: TMeta
+    ): void;
+    getFile<
+      TMeta extends IndexedObject<any> = {},
+      TBody extends IndexedObject<any> = {}
+    >(fileID: string): FilerobotFile<TMeta, TBody>;
+    getFiles<
+      TMeta extends IndexedObject<any> = {},
+      TBody extends IndexedObject<any> = {}
+    >(): Array<FilerobotFile<TMeta, TBody>>;
+    addFile<TMeta extends IndexedObject<any> = {}>(
+      file: AddFileOptions<TMeta>
+    ): void;
+    removeFile(fileID: string): void;
+    pauseResume(fileID: string): void;
+    cancelUploads(): void;
+    retryUpload<TMeta extends IndexedObject<any> = {}>(
+      fileID: string
+    ): Promise<UploadResult<TMeta>>;
+    pauseAll(): void;
+    resumeAll(): void;
+    retryAll<TMeta extends IndexedObject<any> = {}>(): Promise<
+      UploadResult<TMeta>
+    >;
+    cancelAll(): void;
+    getId(): string;
+    /**
+     * Add a plugin to this Filerobot instance.
+     */
+    use<TOptions, TInstance extends Plugin<TOptions>>(
+      pluginClass: new (filerobot: this, opts: TOptions) => TInstance,
+      opts?: TOptions
+    ): this;
+    /**
+     * Fallback `.use()` overload with unchecked plugin options.
+     *
+     * This does not validate that the options you pass in are correct.
+     * We recommend disabling this overload by using the `Filerobot<Filerobot.StrictTypes>` type, instead of the plain `Filerobot` type, to enforce strict typechecking.
+     * This overload will be removed in Filerobot 2.0.
+     */
+    use(
+      pluginClass: TUseStrictTypes extends StrictTypes
+        ? never
+        : new (filerobot: this, opts: any) => Plugin<any>,
+      opts?: object
+    ): this;
+    getPlugin(name: string): Plugin;
+    iteratePlugins(callback: (plugin: Plugin) => void): void;
+    removePlugin(instance: Plugin): void;
+    close(): void;
+    info(
+      message: string | { message: string; details: string },
+      type?: LogLevel,
+      duration?: number
+    ): void;
+    hideInfo(): void;
+    log(msg: string, type?: LogLevel): void;
+    /**
+     * Obsolete: do not use. This method does nothing and will be removed in a future release.
+     */
+    run(): this;
+    restore<TMeta extends IndexedObject<any> = {}>(
+      uploadID: string
+    ): Promise<UploadResult<TMeta>>;
+    addResultData(uploadID: string, data: object): void;
+    upload<TMeta extends IndexedObject<any> = {}>(): Promise<
+      UploadResult<TMeta>
+    >;
+  }
+}
+
+/**
+ * Create a filerobot instance.
+ *
+ * By default, Filerobot's `.use(Plugin, options)` method uses loose type checking.
+ * In Filerobot 2.0, the `.use()` method will get a stricter type signature. You can enable strict type checking of plugin classes and their options today by using:
+ * ```ts
+ * const filerobot = Filerobot<Filerobot.StrictTypes>()
+ * ```
+ * Make sure to also declare any variables and class properties with the `StrictTypes` parameter:
+ * ```ts
+ * private filerobot: Filerobot<Filerobot.StrictTypes>;
+ * ```
+ */
+declare function Filerobot<
+  TUseStrictTypes extends Filerobot.TypeChecking = Filerobot.TypeChecking
+>(opts?: Filerobot.FilerobotOptions): Filerobot.Filerobot<TUseStrictTypes>;
+
+export = Filerobot;