@bytescale/sdk 3.0.0-alpha.9 → 3.2.0

package/dist/worker/cjs/main.js

@@ -0,0 +1,2578 @@
+/******/ (function() { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __lib_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	!function() {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__lib_require__.d = function(exports, definition) {
+/******/ 			for(var key in definition) {
+/******/ 				if(__lib_require__.o(definition, key) && !__lib_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	!function() {
+/******/ 		__lib_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	!function() {
+/******/ 		// define __esModule on exports
+/******/ 		__lib_require__.r = function(exports) {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/************************************************************************/
+var __lib_exports__ = {};
+// ESM COMPAT FLAG
+__lib_require__.r(__lib_exports__);
+
+// EXPORTS
+__lib_require__.d(__lib_exports__, {
+  "AuthManager": function() { return /* reexport */ AuthManager; },
+  "BaseAPI": function() { return /* reexport */ BaseAPI; },
+  "BinaryResult": function() { return /* reexport */ BinaryResult; },
+  "BytescaleApiClientConfigUtils": function() { return /* reexport */ BytescaleApiClientConfigUtils; },
+  "BytescaleApiError": function() { return /* reexport */ BytescaleApiError; },
+  "CancelledError": function() { return /* reexport */ CancelledError; },
+  "CommonTypesNoOp": function() { return /* reexport */ CommonTypesNoOp; },
+  "FileApi": function() { return /* reexport */ FileApi; },
+  "FolderApi": function() { return /* reexport */ FolderApi; },
+  "JSONApiResponse": function() { return /* reexport */ JSONApiResponse; },
+  "JobApi": function() { return /* reexport */ JobApi; },
+  "UploadApi": function() { return /* reexport */ UploadApi; },
+  "UploadManager": function() { return /* reexport */ UploadManager; },
+  "UrlBuilder": function() { return /* reexport */ UrlBuilder; },
+  "UrlBuilderTypesNoOp": function() { return /* reexport */ UrlBuilderTypesNoOp; },
+  "VoidApiResponse": function() { return /* reexport */ VoidApiResponse; },
+  "querystring": function() { return /* reexport */ querystring; }
+});
+
+;// CONCATENATED MODULE: ./src/private/Mutex.ts
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _call(body, then, direct) {
+  if (direct) {
+    return then ? then(body()) : body();
+  }
+  try {
+    var result = Promise.resolve(body());
+    return then ? result.then(then) : result;
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+function _rethrow(thrown, value) {
+  if (thrown) throw value;
+  return value;
+}
+function _finallyRethrows(body, finalizer) {
+  try {
+    var result = body();
+  } catch (e) {
+    return finalizer(true, e);
+  }
+  if (result && result.then) {
+    return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
+  }
+  return finalizer(false, result);
+}
+function _await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function _empty() {}
+function _awaitIgnored(value, direct) {
+  if (!direct) {
+    return value && value.then ? value.then(_empty) : Promise.resolve();
+  }
+}
+function _settle(pact, state, value) {
+  if (!pact.s) {
+    if (value instanceof _Pact) {
+      if (value.s) {
+        if (state & 1) {
+          state = value.s;
+        }
+        value = value.v;
+      } else {
+        value.o = _settle.bind(null, pact, state);
+        return;
+      }
+    }
+    if (value && value.then) {
+      value.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));
+      return;
+    }
+    pact.s = state;
+    pact.v = value;
+    var observer = pact.o;
+    if (observer) {
+      observer(pact);
+    }
+  }
+}
+var _Pact = /*#__PURE__*/function () {
+  function _Pact() {}
+  _Pact.prototype.then = function (onFulfilled, onRejected) {
+    var result = new _Pact();
+    var state = this.s;
+    if (state) {
+      var callback = state & 1 ? onFulfilled : onRejected;
+      if (callback) {
+        try {
+          _settle(result, 1, callback(this.v));
+        } catch (e) {
+          _settle(result, 2, e);
+        }
+        return result;
+      } else {
+        return this;
+      }
+    }
+    this.o = function (_this) {
+      try {
+        var value = _this.v;
+        if (_this.s & 1) {
+          _settle(result, 1, onFulfilled ? onFulfilled(value) : value);
+        } else if (onRejected) {
+          _settle(result, 1, onRejected(value));
+        } else {
+          _settle(result, 2, value);
+        }
+      } catch (e) {
+        _settle(result, 2, e);
+      }
+    };
+    return result;
+  };
+  return _Pact;
+}();
+function _isSettledPact(thenable) {
+  return thenable instanceof _Pact && thenable.s & 1;
+}
+function _for(test, update, body) {
+  var stage;
+  for (;;) {
+    var shouldContinue = test();
+    if (_isSettledPact(shouldContinue)) {
+      shouldContinue = shouldContinue.v;
+    }
+    if (!shouldContinue) {
+      return result;
+    }
+    if (shouldContinue.then) {
+      stage = 0;
+      break;
+    }
+    var result = body();
+    if (result && result.then) {
+      if (_isSettledPact(result)) {
+        result = result.s;
+      } else {
+        stage = 1;
+        break;
+      }
+    }
+    if (update) {
+      var updateValue = update();
+      if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
+        stage = 2;
+        break;
+      }
+    }
+  }
+  var pact = new _Pact();
+  var reject = _settle.bind(null, pact, 2);
+  (stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);
+  return pact;
+  function _resumeAfterBody(value) {
+    result = value;
+    do {
+      if (update) {
+        updateValue = update();
+        if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
+          updateValue.then(_resumeAfterUpdate).then(void 0, reject);
+          return;
+        }
+      }
+      shouldContinue = test();
+      if (!shouldContinue || _isSettledPact(shouldContinue) && !shouldContinue.v) {
+        _settle(pact, 1, result);
+        return;
+      }
+      if (shouldContinue.then) {
+        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+        return;
+      }
+      result = body();
+      if (_isSettledPact(result)) {
+        result = result.v;
+      }
+    } while (!result || !result.then);
+    result.then(_resumeAfterBody).then(void 0, reject);
+  }
+  function _resumeAfterTest(shouldContinue) {
+    if (shouldContinue) {
+      result = body();
+      if (result && result.then) {
+        result.then(_resumeAfterBody).then(void 0, reject);
+      } else {
+        _resumeAfterBody(result);
+      }
+    } else {
+      _settle(pact, 1, result);
+    }
+  }
+  function _resumeAfterUpdate() {
+    if (shouldContinue = test()) {
+      if (shouldContinue.then) {
+        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+      } else {
+        _resumeAfterTest(shouldContinue);
+      }
+    } else {
+      _settle(pact, 1, result);
+    }
+  }
+}
+function _continue(value, then) {
+  return value && value.then ? value.then(then) : then(value);
+}
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * A lightweight mutex. (Other libraries contain too many features and we want to keep size down).
+ *
+ * Characteristics:
+ * - Non-reentrant.
+ * - Unfair. (Multiple callers awaiting 'acquire' will be granted the mutex in no order.)
+ *   - When calling `safe` consecutively with no 'awaits' in-between, the current context will synchronously acquire
+ *     the mutex every time.
+ */
+var Mutex = /*#__PURE__*/function () {
+  function Mutex() {
+    _classCallCheck(this, Mutex);
+    this.mutex = undefined;
+    this.resolver = undefined;
+  }
+  _createClass(Mutex, [{
+    key: "safe",
+    value: function safe(callback) {
+      try {
+        var _this2 = this;
+        return _await(_this2.acquire(), function () {
+          return _finallyRethrows(callback, function (_wasThrown, _result) {
+            _this2.release();
+            return _rethrow(_wasThrown, _result);
+          });
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "acquire",
+    value: function acquire() {
+      try {
+        var _this4 = this;
+        // Loop necessary for when multiple calls are made to 'acquire' before a 'release' is called, else the call to
+        // 'release' will resume every caller currently waiting on 'acquire'.
+        return _continue(_for(function () {
+          return _this4.mutex !== undefined;
+        }, void 0, function () {
+          return _awaitIgnored(_this4.mutex);
+        }), function () {
+          _this4.mutex = new Promise(function (resolve) {
+            _this4.resolver = resolve;
+          });
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "release",
+    value: function release() {
+      if (this.resolver === undefined) {
+        throw new Error("Unable to release mutex: already released.");
+      }
+      this.resolver();
+      this.resolver = undefined;
+      this.mutex = undefined;
+    }
+  }]);
+  return Mutex;
+}();
+;// CONCATENATED MODULE: ./src/private/AuthSessionState.ts
+function AuthSessionState_typeof(obj) { "@babel/helpers - typeof"; return AuthSessionState_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, AuthSessionState_typeof(obj); }
+function AuthSessionState_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function AuthSessionState_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, AuthSessionState_toPropertyKey(descriptor.key), descriptor); } }
+function AuthSessionState_createClass(Constructor, protoProps, staticProps) { if (protoProps) AuthSessionState_defineProperties(Constructor.prototype, protoProps); if (staticProps) AuthSessionState_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function AuthSessionState_toPropertyKey(arg) { var key = AuthSessionState_toPrimitive(arg, "string"); return AuthSessionState_typeof(key) === "symbol" ? key : String(key); }
+function AuthSessionState_toPrimitive(input, hint) { if (AuthSessionState_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (AuthSessionState_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+/**
+ * Maintains a global session state, even across package versions.
+ *
+ * This is to allow users to start auth sessions via the Bytescale JavaScript SDK, where due to versioning or other
+ * bundling issues, the Bytescale Upload Widget has been bundled with a different Bytescale JavaScript SDK. In this
+ * scenario, the user wouldn't be able to start an auth session with the Bytescale Upload Widget. Therefore, we use
+ * global state (i.e. on the window) to ensure the session state can be shared between the user's instance of the
+ * Bytescale JavaScript SDK and the Upload Widget's version of the Bytescale JavaScript SDK.
+ *
+ * Users also frequently have problems caused by them not keeping track of *Api and *Manager instances correctly, so
+ * making this global prevents a lot of common mistakes.
+ */
+var AuthSessionState = /*#__PURE__*/function () {
+  function AuthSessionState() {
+    AuthSessionState_classCallCheck(this, AuthSessionState);
+  }
+  AuthSessionState_createClass(AuthSessionState, null, [{
+    key: "getMutex",
+    value:
+    /**
+     * Called in the browser only.
+     */
+    function getMutex() {
+      var key = AuthSessionState.mutexKey;
+      var mutex = window[key];
+      if (mutex === undefined) {
+        mutex = new Mutex();
+        window[key] = mutex;
+      }
+      return mutex;
+    }
+    /**
+     * Called in the browser only.
+     */
+  }, {
+    key: "setSession",
+    value: function setSession(session) {
+      window[AuthSessionState.stateKey] = session;
+    }
+    /**
+     * Called in the browser and in Node.js (so we check the env before calling env-specific code).
+     */
+  }, {
+    key: "getSession",
+    value: function getSession() {
+      if (typeof window === "undefined") {
+        return undefined;
+      }
+      return window[AuthSessionState.stateKey];
+    }
+  }]);
+  return AuthSessionState;
+}();
+AuthSessionState.stateKey = "BytescaleSessionState";
+AuthSessionState.mutexKey = "BytescaleSessionStateMutex";
+;// CONCATENATED MODULE: ./src/public/shared/generated/runtime.ts
+function runtime_typeof(obj) { "@babel/helpers - typeof"; return runtime_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, runtime_typeof(obj); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (runtime_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _catch(body, recover) {
+  try {
+    var result = body();
+  } catch (e) {
+    return recover(e);
+  }
+  if (result && result.then) {
+    return result.then(void 0, recover);
+  }
+  return result;
+}
+function runtime_empty() {}
+function runtime_continue(value, then) {
+  return value && value.then ? value.then(then) : then(value);
+}
+function _invoke(body, then) {
+  var result = body();
+  if (result && result.then) {
+    return result.then(then);
+  }
+  return then(result);
+}
+function _defineProperty(obj, key, value) { key = runtime_toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function runtime_await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function runtime_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function runtime_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, runtime_toPropertyKey(descriptor.key), descriptor); } }
+function runtime_createClass(Constructor, protoProps, staticProps) { if (protoProps) runtime_defineProperties(Constructor.prototype, protoProps); if (staticProps) runtime_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function runtime_toPropertyKey(arg) { var key = runtime_toPrimitive(arg, "string"); return runtime_typeof(key) === "symbol" ? key : String(key); }
+function runtime_toPrimitive(input, hint) { if (runtime_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (runtime_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+var BytescaleApiClientConfigUtils = /*#__PURE__*/function () {
+  function BytescaleApiClientConfigUtils() {
+    runtime_classCallCheck(this, BytescaleApiClientConfigUtils);
+  }
+  runtime_createClass(BytescaleApiClientConfigUtils, null, [{
+    key: "getApiUrl",
+    value: function getApiUrl(config) {
+      var _a;
+      return (_a = config.apiUrl) !== null && _a !== void 0 ? _a : BytescaleApiClientConfigUtils.defaultApiUrl;
+    }
+  }, {
+    key: "getCdnUrl",
+    value: function getCdnUrl(config) {
+      var _a;
+      return (_a = config.cdnUrl) !== null && _a !== void 0 ? _a : BytescaleApiClientConfigUtils.defaultCdnUrl;
+    }
+  }, {
+    key: "getFetchApi",
+    value: function getFetchApi(config) {
+      var _a;
+      return (_a = config.fetchApi) !== null && _a !== void 0 ? _a : fetch;
+    }
+  }, {
+    key: "getAccountId",
+    value: function getAccountId(config) {
+      var _a, _b;
+      var accountId;
+      if (BytescaleApiClientConfigUtils.specialApiKeys.includes(config.apiKey)) {
+        accountId = BytescaleApiClientConfigUtils.specialApiKeyAccountId;
+      } else {
+        accountId = (_b = (_a = config.apiKey.split("_")[1]) === null || _a === void 0 ? void 0 : _a.substr(0, BytescaleApiClientConfigUtils.accountIdLength)) !== null && _b !== void 0 ? _b : "";
+        if (accountId.length !== BytescaleApiClientConfigUtils.accountIdLength) {
+          throw new Error("Invalid Bytescale API key.");
+        }
+      }
+      return accountId;
+    }
+  }, {
+    key: "validate",
+    value: function validate(config) {
+      var _a;
+      // Defensive programming, for users not using TypeScript. Mainly because this is used by UploadWidget users.
+      if ((config !== null && config !== void 0 ? config : undefined) === undefined) {
+        throw new Error("Config parameter required.");
+      }
+      if (((_a = config.apiKey) !== null && _a !== void 0 ? _a : undefined) === undefined) {
+        throw new Error("Please provide an API key via the 'apiKey' config parameter.");
+      }
+      if (config.apiKey.trim() !== config.apiKey) {
+        // We do not support API keys with whitespace (by trimming ourselves) because otherwise we'd need to support this
+        // everywhere in perpetuity (since removing the trimming would be a breaking change).
+        throw new Error("API key needs trimming (whitespace detected).");
+      }
+      // This performs futher validation on the API key...
+      BytescaleApiClientConfigUtils.getAccountId(config);
+    }
+  }]);
+  return BytescaleApiClientConfigUtils;
+}();
+BytescaleApiClientConfigUtils.defaultApiUrl = "https://api.bytescale.com";
+BytescaleApiClientConfigUtils.defaultCdnUrl = "https://upcdn.io";
+BytescaleApiClientConfigUtils.specialApiKeys = ["free", "demo"];
+BytescaleApiClientConfigUtils.specialApiKeyAccountId = "W142hJk";
+BytescaleApiClientConfigUtils.accountIdLength = 7; // Sync with: upload/shared/**/AccountIdUtils
+/**
+ * This is the base class for all generated API classes.
+ */
+var BaseAPI = /*#__PURE__*/function () {
+  function BaseAPI(config) {
+    runtime_classCallCheck(this, BaseAPI);
+    this.config = config;
+    BytescaleApiClientConfigUtils.validate(config);
+  }
+  /**
+   * Returns a successful response (2**) else throws an error.
+   */
+  runtime_createClass(BaseAPI, [{
+    key: "request",
+    value: function request(context, initOverrides, baseUrlOverride) {
+      try {
+        var _this2 = this;
+        var _a;
+        var apiKey = _this2.config.apiKey;
+        context.headers["Authorization"] = "Bearer ".concat(apiKey); // authorization-header authentication
+        var session = AuthSessionState.getSession();
+        if ((session === null || session === void 0 ? void 0 : session.accessToken) !== undefined) {
+          context.headers["Authorization-Token"] = session.accessToken;
+        }
+        // Key: any possible value for 'baseUrlOverride'
+        // Value: user-overridden value for that base URL from the config.
+        var nonDefaultBasePaths = _defineProperty({}, BytescaleApiClientConfigUtils.defaultCdnUrl, BytescaleApiClientConfigUtils.getCdnUrl(_this2.config));
+        return runtime_await(_this2.createFetchParams(context, initOverrides, baseUrlOverride === undefined ? undefined : (_a = nonDefaultBasePaths[baseUrlOverride]) !== null && _a !== void 0 ? _a : baseUrlOverride), function (_ref) {
+          var url = _ref.url,
+            init = _ref.init;
+          return BaseAPI.fetch(url, init, Object.assign(Object.assign({}, _this2.config), {
+            isBytescaleApi: true
+          }));
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "encodeParam",
+    value: function encodeParam(paramName, paramValue) {
+      if (paramName === "filePath") {
+        if (!paramValue.startsWith("/")) {
+          // Non-obvious errors are returned by the Bytescale CDN if forward slashes are omitted, so catch it client-side:
+          throw new Error("The 'filePath' parameter must begin with a '/' character.");
+        }
+        // We must not encode the filePath param (as slashes are valid).
+        return paramValue;
+      }
+      return encodeURIComponent(paramValue);
+    }
+  }, {
+    key: "createFetchParams",
+    value: function createFetchParams(context, initOverrides, baseUrlOverride) {
+      try {
+        var _this4 = this;
+        var url = (baseUrlOverride !== null && baseUrlOverride !== void 0 ? baseUrlOverride : BytescaleApiClientConfigUtils.getApiUrl(_this4.config)) + context.path;
+        if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+          // only add the querystring to the URL if there are query parameters.
+          // this is done to avoid urls ending with a "?" character which buggy webservers
+          // do not handle correctly sometimes.
+          url += "?" + querystring(context.query);
+        }
+        var configHeaders = _this4.config.headers;
+        var _Object$assign3 = Object.assign({}, context.headers);
+        return runtime_await(configHeaders === undefined ? {} : configHeaders(), function (_configHeaders) {
+          var headers = Object.assign(_Object$assign3, _configHeaders);
+          Object.keys(headers).forEach(function (key) {
+            return headers[key] === undefined ? delete headers[key] : {};
+          });
+          var initOverrideFn = typeof initOverrides === "function" ? initOverrides : function () {
+            return runtime_await(initOverrides);
+          };
+          var initParams = {
+            method: context.method,
+            headers: headers,
+            body: context.body
+          };
+          var _Object$assign2 = Object.assign({}, initParams);
+          return runtime_await(initOverrideFn({
+            init: initParams,
+            context: context
+          }), function (_initOverrideFn) {
+            var overriddenInit = Object.assign(_Object$assign2, _initOverrideFn);
+            var init = Object.assign(Object.assign({}, overriddenInit), {
+              body: JSON.stringify(overriddenInit.body)
+            });
+            return {
+              url: url,
+              init: init
+            };
+          });
+        }, configHeaders === undefined);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }], [{
+    key: "fetch",
+    value: function fetch(url, init, config) {
+      try {
+        var _exit3 = false;
+        var _a, _b;
+        var response;
+        return runtime_continue(_catch(function () {
+          return runtime_await(BytescaleApiClientConfigUtils.getFetchApi(config)(url, Object.assign(Object.assign({}, init), {
+            // This is specifically added to cater for Next.js's Fetch implementation, which caches POST requests...
+            //
+            // "fetch requests that use the POST method are also automatically cached."
+            // - https://nextjs.org/docs/app/building-your-application/data-fetching/fetching-caching-and-revalidating#caching-data
+            //
+            // However, this is probably a good idea, even for all GET requests, as if the user is refreshing a JWT
+            // or downloading a file via 'FileApi.downloadFile', then they'll likely want the latest.
+            cache: "no-store"
+          })), function (_BytescaleApiClientCo) {
+            response = _BytescaleApiClientCo;
+          });
+        }, function (e) {
+          // Network-level errors, CORS errors, or HTTP-level errors from intermediary services (e.g. AWS or the user's own infrastructure/proxies).
+          // HTTP-level errors from external services (e.g. AWS or the user's own proxy) will appear as CORS errors as their response headers won't include the appropriate CORS values.
+          throw new Error(config.isBytescaleApi ? "Unable to resolve the Bytescale API: ".concat(e.message, " If the problem persists, and your network connection is OK, then please contact support@bytescale.com and provide: (a) time of failed request in UTC (b) screenshot of failed network response header + body (c) screenshot of failed network request header + body (d) browser and OS version.") : "Unable to resolve URL (".concat(url, "): ").concat(e.message));
+        }), function (_result) {
+          var _exit2 = false;
+          if (_exit3) return _result;
+          return response.status >= 200 && response.status < 300 ? response : _invoke(function () {
+            if (config.isBytescaleApi) {
+              var jsonError = undefined;
+              return runtime_continue(_catch(function () {
+                return runtime_await(response.json(), function (_response$json) {
+                  jsonError = _response$json;
+                });
+              }, runtime_empty), function () {
+                if (typeof ((_a = jsonError === null || jsonError === void 0 ? void 0 : jsonError.error) === null || _a === void 0 ? void 0 : _a.code) === "string") {
+                  throw new BytescaleApiError(jsonError);
+                }
+                // HTTP-level errors from intermediary services (e.g. AWS or the user's own infrastructure/proxies). On the browser,
+                // this error is unlikely to be triggered since these errors will masqurade as CORS errors (see above) but in Node.js
+                // this error will appear from any intermediary service failure.
+                throw new Error("Unable to connect to the Bytescale API (".concat(response.status, "): please try again."));
+              });
+            }
+          }, function (_result2) {
+            if (_exit2) return _result2;
+            throw new Error("Failure status code (".concat(response.status, ") received for request: ").concat((_b = init.method) !== null && _b !== void 0 ? _b : "GET", " ").concat(url));
+          });
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return BaseAPI;
+}();
+var CancelledError = /*#__PURE__*/function (_Error) {
+  _inherits(CancelledError, _Error);
+  var _super = _createSuper(CancelledError);
+  function CancelledError() {
+    var _this5;
+    runtime_classCallCheck(this, CancelledError);
+    _this5 = _super.call(this, "Operation cancelled by caller.");
+    _this5.name = "CancelledError";
+    return _this5;
+  }
+  return runtime_createClass(CancelledError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+var BytescaleApiError = /*#__PURE__*/function (_Error2) {
+  _inherits(BytescaleApiError, _Error2);
+  var _super2 = _createSuper(BytescaleApiError);
+  function BytescaleApiError(response) {
+    var _this6;
+    runtime_classCallCheck(this, BytescaleApiError);
+    _this6 = _super2.call(this, response.error.message);
+    _this6.name = "BytescaleApiError";
+    _this6.errorCode = response.error.code;
+    _this6.details = response.error.details;
+    return _this6;
+  }
+  return runtime_createClass(BytescaleApiError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+function querystring(params) {
+  return Object.keys(params).map(function (key) {
+    return querystringSingleKey(key, params[key]);
+  }).filter(function (part) {
+    return part.length > 0;
+  }).join("&");
+}
+function querystringSingleKey(key, value) {
+  if (value instanceof Object) {
+    return querystring(value);
+  }
+  return "".concat(encodeURIComponent(key), "=").concat(encodeURIComponent(String(value)));
+}
+var JSONApiResponse = /*#__PURE__*/function () {
+  function JSONApiResponse(raw) {
+    runtime_classCallCheck(this, JSONApiResponse);
+    this.raw = raw;
+  }
+  runtime_createClass(JSONApiResponse, [{
+    key: "value",
+    value: function value() {
+      try {
+        var _this8 = this;
+        return runtime_await(_this8.raw.json());
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return JSONApiResponse;
+}();
+var VoidApiResponse = /*#__PURE__*/function () {
+  function VoidApiResponse(raw) {
+    runtime_classCallCheck(this, VoidApiResponse);
+    this.raw = raw;
+  }
+  runtime_createClass(VoidApiResponse, [{
+    key: "value",
+    value: function value() {
+      return runtime_await(undefined);
+    }
+  }]);
+  return VoidApiResponse;
+}();
+var BinaryResult = /*#__PURE__*/function () {
+  function BinaryResult(raw) {
+    runtime_classCallCheck(this, BinaryResult);
+    this.raw = raw;
+  }
+  runtime_createClass(BinaryResult, [{
+    key: "stream",
+    value: function stream() {
+      if (this.raw.bodyUsed) {
+        throw new Error("Response body has already been consumed.");
+      }
+      if (this.raw.body === null) {
+        throw new Error("Response body does not exist.");
+      }
+      return this.raw.body;
+    }
+  }, {
+    key: "text",
+    value: function text() {
+      try {
+        var _this10 = this;
+        return runtime_await(_this10.raw.text());
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "blob",
+    value: function blob() {
+      try {
+        var _this12 = this;
+        return runtime_await(_this12.raw.blob());
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "json",
+    value: function json() {
+      try {
+        var _this14 = this;
+        return runtime_await(_this14.raw.json());
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return BinaryResult;
+}();
+;// CONCATENATED MODULE: ./src/public/shared/generated/apis/FileApi.ts
+function FileApi_typeof(obj) { "@babel/helpers - typeof"; return FileApi_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, FileApi_typeof(obj); }
+function FileApi_await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function FileApi_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function FileApi_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, FileApi_toPropertyKey(descriptor.key), descriptor); } }
+function FileApi_createClass(Constructor, protoProps, staticProps) { if (protoProps) FileApi_defineProperties(Constructor.prototype, protoProps); if (staticProps) FileApi_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function FileApi_toPropertyKey(arg) { var key = FileApi_toPrimitive(arg, "string"); return FileApi_typeof(key) === "symbol" ? key : String(key); }
+function FileApi_toPrimitive(input, hint) { if (FileApi_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (FileApi_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function FileApi_inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) FileApi_setPrototypeOf(subClass, superClass); }
+function FileApi_setPrototypeOf(o, p) { FileApi_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return FileApi_setPrototypeOf(o, p); }
+function FileApi_createSuper(Derived) { var hasNativeReflectConstruct = FileApi_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = FileApi_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = FileApi_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return FileApi_possibleConstructorReturn(this, result); }; }
+function FileApi_possibleConstructorReturn(self, call) { if (call && (FileApi_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return FileApi_assertThisInitialized(self); }
+function FileApi_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function FileApi_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function FileApi_getPrototypeOf(o) { FileApi_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return FileApi_getPrototypeOf(o); }
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * @bytescale/api
+ * Bytescale API
+ *
+ * The version of the OpenAPI document: 2.0.0
+ * Contact: hello@bytescale.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+// @ts-ignore
+
+var FileApi = /*#__PURE__*/function (_runtime$BaseAPI) {
+  FileApi_inherits(FileApi, _runtime$BaseAPI);
+  var _super = FileApi_createSuper(FileApi);
+  function FileApi() {
+    FileApi_classCallCheck(this, FileApi);
+    return _super.apply(this, arguments);
+  }
+  FileApi_createClass(FileApi, [{
+    key: "copyFile",
+    value:
+    /**
+     * Copies a file synchronously.
+     */
+    function copyFile(params) {
+      try {
+        var _this2 = this;
+        var query = {};
+        var headers = {};
+        headers["Content-Type"] = "application/json";
+        return FileApi_await(_this2.request({
+          path: "/v2/accounts/{accountId}/files/copy".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this2.encodeParam("accountId", params.accountId)),
+          method: "POST",
+          headers: headers,
+          query: query,
+          body: params.copyFileRequest
+        }, undefined, [][0]), function (response) {
+          return FileApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Copies multiple files asynchronously.
+     */
+  }, {
+    key: "copyFileBatch",
+    value: function copyFileBatch(params) {
+      try {
+        var _this4 = this;
+        var query = {};
+        var headers = {};
+        headers["Content-Type"] = "application/json";
+        return FileApi_await(_this4.request({
+          path: "/v2/accounts/{accountId}/files/copy/batch".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this4.encodeParam("accountId", params.accountId)),
+          method: "POST",
+          headers: headers,
+          query: query,
+          body: params.copyFileBatchRequest
+        }, undefined, [][0]), function (response) {
+          return FileApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Deletes a file synchronously.
+     */
+  }, {
+    key: "deleteFile",
+    value: function deleteFile(params) {
+      try {
+        var _this6 = this;
+        var query = {};
+        if (params.filePath !== undefined) {
+          query["filePath"] = params.filePath;
+        }
+        var headers = {};
+        return FileApi_await(_this6.request({
+          path: "/v2/accounts/{accountId}/files".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this6.encodeParam("accountId", params.accountId)),
+          method: "DELETE",
+          headers: headers,
+          query: query
+        }, undefined, [][0]), function (response) {
+          return FileApi_await(new VoidApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Deletes multiple files asynchronously.
+     */
+  }, {
+    key: "deleteFileBatch",
+    value: function deleteFileBatch(params) {
+      try {
+        var _this8 = this;
+        var query = {};
+        var headers = {};
+        headers["Content-Type"] = "application/json";
+        return FileApi_await(_this8.request({
+          path: "/v2/accounts/{accountId}/files/batch".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this8.encodeParam("accountId", params.accountId)),
+          method: "DELETE",
+          headers: headers,
+          query: query,
+          body: params.deleteFileBatchRequest
+        }, undefined, [][0]), function (response) {
+          return FileApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Downloads a file in its original/unprocessed state.
+     */
+  }, {
+    key: "downloadFile",
+    value: function downloadFile(params) {
+      try {
+        var _this10 = this;
+        var query = {};
+        if (params.cache !== undefined) {
+          query["cache"] = params.cache;
+        }
+        if (params.cacheTtl !== undefined) {
+          query["cache_ttl"] = params.cacheTtl;
+        }
+        if (params.version !== undefined) {
+          query["version"] = params.version;
+        }
+        var headers = {};
+        return FileApi_await(_this10.request({
+          path: "/{accountId}/raw{filePath}".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this10.encodeParam("accountId", params.accountId)).replace("{".concat("filePath", "}"),
+          // @ts-ignore
+          _this10.encodeParam("filePath", params.filePath)),
+          method: "GET",
+          headers: headers,
+          query: query
+        }, undefined, ["https://upcdn.io"][0]), function (response) {
+          return new BinaryResult(response);
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Gets the full details (e.g. metadata, tags, etc.) for a file.
+     */
+  }, {
+    key: "getFileDetails",
+    value: function getFileDetails(params) {
+      try {
+        var _this12 = this;
+        var query = {};
+        if (params.filePath !== undefined) {
+          query["filePath"] = params.filePath;
+        }
+        var headers = {};
+        return FileApi_await(_this12.request({
+          path: "/v2/accounts/{accountId}/files/details".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this12.encodeParam("accountId", params.accountId)),
+          method: "GET",
+          headers: headers,
+          query: query
+        }, undefined, [][0]), function (response) {
+          return FileApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Processes a file and returns the result.
+     */
+  }, {
+    key: "processFile",
+    value: function processFile(params) {
+      try {
+        var _this14 = this;
+        var query = {};
+        if (params.artifact !== undefined) {
+          query["artifact"] = params.artifact;
+        }
+        if (params.cache !== undefined) {
+          query["cache"] = params.cache;
+        }
+        if (params.cachePerm !== undefined) {
+          query["cache_perm"] = params.cachePerm;
+        }
+        if (params.cacheTtl !== undefined) {
+          query["cache_ttl"] = params.cacheTtl;
+        }
+        if (params.large !== undefined) {
+          query["large"] = params.large;
+        }
+        if (params.transformationParams !== undefined) {
+          query["transformationParams"] = params.transformationParams;
+        }
+        if (params.version !== undefined) {
+          query["version"] = params.version;
+        }
+        var headers = {};
+        return FileApi_await(_this14.request({
+          path: "/{accountId}/{transformation}{filePath}".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this14.encodeParam("accountId", params.accountId)).replace("{".concat("filePath", "}"),
+          // @ts-ignore
+          _this14.encodeParam("filePath", params.filePath)).replace("{".concat("transformation", "}"),
+          // @ts-ignore
+          _this14.encodeParam("transformation", params.transformation)),
+          method: "GET",
+          headers: headers,
+          query: query
+        }, undefined, ["https://upcdn.io"][0]), function (response) {
+          return new BinaryResult(response);
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Processes a file and saves the result.
+     */
+  }, {
+    key: "processFileAndSave",
+    value: function processFileAndSave(params) {
+      try {
+        var _this16 = this;
+        var query = {};
+        if (params.transformationParams !== undefined) {
+          query["transformationParams"] = params.transformationParams;
+        }
+        var headers = {};
+        headers["Content-Type"] = "application/json";
+        return FileApi_await(_this16.request({
+          path: "/{accountId}/save/{transformation}{filePath}".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this16.encodeParam("accountId", params.accountId)).replace("{".concat("filePath", "}"),
+          // @ts-ignore
+          _this16.encodeParam("filePath", params.filePath)).replace("{".concat("transformation", "}"),
+          // @ts-ignore
+          _this16.encodeParam("transformation", params.transformation)),
+          method: "POST",
+          headers: headers,
+          query: query,
+          body: params.processFileAndSaveRequest
+        }, undefined, ["https://upcdn.io"][0]), function (response) {
+          return FileApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return FileApi;
+}(BaseAPI);
+;// CONCATENATED MODULE: ./src/public/shared/generated/apis/FolderApi.ts
+function FolderApi_typeof(obj) { "@babel/helpers - typeof"; return FolderApi_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, FolderApi_typeof(obj); }
+function FolderApi_await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function FolderApi_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function FolderApi_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, FolderApi_toPropertyKey(descriptor.key), descriptor); } }
+function FolderApi_createClass(Constructor, protoProps, staticProps) { if (protoProps) FolderApi_defineProperties(Constructor.prototype, protoProps); if (staticProps) FolderApi_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function FolderApi_toPropertyKey(arg) { var key = FolderApi_toPrimitive(arg, "string"); return FolderApi_typeof(key) === "symbol" ? key : String(key); }
+function FolderApi_toPrimitive(input, hint) { if (FolderApi_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (FolderApi_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function FolderApi_inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) FolderApi_setPrototypeOf(subClass, superClass); }
+function FolderApi_setPrototypeOf(o, p) { FolderApi_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return FolderApi_setPrototypeOf(o, p); }
+function FolderApi_createSuper(Derived) { var hasNativeReflectConstruct = FolderApi_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = FolderApi_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = FolderApi_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return FolderApi_possibleConstructorReturn(this, result); }; }
+function FolderApi_possibleConstructorReturn(self, call) { if (call && (FolderApi_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return FolderApi_assertThisInitialized(self); }
+function FolderApi_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function FolderApi_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function FolderApi_getPrototypeOf(o) { FolderApi_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return FolderApi_getPrototypeOf(o); }
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * @bytescale/api
+ * Bytescale API
+ *
+ * The version of the OpenAPI document: 2.0.0
+ * Contact: hello@bytescale.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+// @ts-ignore
+
+var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
+  FolderApi_inherits(FolderApi, _runtime$BaseAPI);
+  var _super = FolderApi_createSuper(FolderApi);
+  function FolderApi() {
+    FolderApi_classCallCheck(this, FolderApi);
+    return _super.apply(this, arguments);
+  }
+  FolderApi_createClass(FolderApi, [{
+    key: "copyFolder",
+    value:
+    /**
+     * Copies a folder asynchronously.  You can use ListFolder to preview the operation: set `dryRun=true` with ```recursive```, ```includeFiles```, ```includeOverriddenStorage``` and ```includeVirtualFolders``` set to match the values you\'re using here. Leave all other flags unset.
+     */
+    function copyFolder(params) {
+      try {
+        var _this2 = this;
+        var query = {};
+        var headers = {};
+        headers["Content-Type"] = "application/json";
+        return FolderApi_await(_this2.request({
+          path: "/v2/accounts/{accountId}/folders/copy".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this2.encodeParam("accountId", params.accountId)),
+          method: "POST",
+          headers: headers,
+          query: query,
+          body: params.copyFolderRequest
+        }, undefined, [][0]), function (response) {
+          return FolderApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Copies multiple folders asynchronously.  You can use ListFolder to preview the operation: set `dryRun=true` with ```recursive```, ```includeFiles```, ```includeOverriddenStorage``` and ```includeVirtualFolders``` set to match the values you\'re using here. Leave all other flags unset.
+     */
+  }, {
+    key: "copyFolderBatch",
+    value: function copyFolderBatch(params) {
+      try {
+        var _this4 = this;
+        var query = {};
+        var headers = {};
+        headers["Content-Type"] = "application/json";
+        return FolderApi_await(_this4.request({
+          path: "/v2/accounts/{accountId}/folders/copy/batch".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this4.encodeParam("accountId", params.accountId)),
+          method: "POST",
+          headers: headers,
+          query: query,
+          body: params.copyFolderBatchRequest
+        }, undefined, [][0]), function (response) {
+          return FolderApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Deletes a folder asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation: set `dryRun=true` with ```recursive```, ```includeFiles``` and ```includeVirtualFolders``` set to match the values you\'re using here. Leave all other flags unset.
+     */
+  }, {
+    key: "deleteFolder",
+    value: function deleteFolder(params) {
+      try {
+        var _this6 = this;
+        var query = {};
+        var headers = {};
+        headers["Content-Type"] = "application/json";
+        return FolderApi_await(_this6.request({
+          path: "/v2/accounts/{accountId}/folders".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this6.encodeParam("accountId", params.accountId)),
+          method: "DELETE",
+          headers: headers,
+          query: query,
+          body: params.deleteFolderRequest
+        }, undefined, [][0]), function (response) {
+          return FolderApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Deletes multiple folders asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation: set `dryRun=true` with ```recursive```, ```includeFiles``` and ```includeVirtualFolders``` set to match the values you\'re using here. Leave all other flags unset.
+     */
+  }, {
+    key: "deleteFolderBatch",
+    value: function deleteFolderBatch(params) {
+      try {
+        var _this8 = this;
+        var query = {};
+        var headers = {};
+        headers["Content-Type"] = "application/json";
+        return FolderApi_await(_this8.request({
+          path: "/v2/accounts/{accountId}/folders/batch".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this8.encodeParam("accountId", params.accountId)),
+          method: "DELETE",
+          headers: headers,
+          query: query,
+          body: params.deleteFolderBatchRequest
+        }, undefined, [][0]), function (response) {
+          return FolderApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Gets the full details (e.g. permission, storage layer, etc.) for a folder.  Returns an empty object if no settings have been configured for this folder.
+     */
+  }, {
+    key: "getFolderDetails",
+    value: function getFolderDetails(params) {
+      try {
+        var _this10 = this;
+        var query = {};
+        if (params.folderPath !== undefined) {
+          query["folderPath"] = params.folderPath;
+        }
+        var headers = {};
+        return FolderApi_await(_this10.request({
+          path: "/v2/accounts/{accountId}/folders".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this10.encodeParam("accountId", params.accountId)),
+          method: "GET",
+          headers: headers,
+          query: query
+        }, undefined, [][0]), function (response) {
+          return FolderApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Lists the folder\'s contents.  The result may be paginated: subsequent pages can be requested by passing the ```cursor``` from the response into the ```cursor``` request parameter.  Pagination is complete when the response includes `isPaginationComplete=true`.
+     */
+  }, {
+    key: "listFolder",
+    value: function listFolder(params) {
+      try {
+        var _this12 = this;
+        var query = {};
+        if (params.cursor !== undefined) {
+          query["cursor"] = params.cursor;
+        }
+        if (params.dryRun !== undefined) {
+          query["dryRun"] = params.dryRun;
+        }
+        if (params.folderPath !== undefined) {
+          query["folderPath"] = params.folderPath;
+        }
+        if (params.includeFiles !== undefined) {
+          query["includeFiles"] = params.includeFiles;
+        }
+        if (params.includeOverriddenStorage !== undefined) {
+          query["includeOverriddenStorage"] = params.includeOverriddenStorage;
+        }
+        if (params.includePhysicalFolders !== undefined) {
+          query["includePhysicalFolders"] = params.includePhysicalFolders;
+        }
+        if (params.includeVirtualFolders !== undefined) {
+          query["includeVirtualFolders"] = params.includeVirtualFolders;
+        }
+        if (params.limit !== undefined) {
+          query["limit"] = params.limit;
+        }
+        if (params.recursive !== undefined) {
+          query["recursive"] = params.recursive;
+        }
+        var headers = {};
+        return FolderApi_await(_this12.request({
+          path: "/v2/accounts/{accountId}/folders/list".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this12.encodeParam("accountId", params.accountId)),
+          method: "GET",
+          headers: headers,
+          query: query
+        }, undefined, [][0]), function (response) {
+          return FolderApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Creates or updates the folder specified by the `folderPath`.  If the folder\'s ancestors do not exist, they will be created automatically (with empty FolderSettings).  Note: you don\'t need to create folders before uploading files to them.
+     */
+  }, {
+    key: "putFolder",
+    value: function putFolder(params) {
+      try {
+        var _this14 = this;
+        var query = {};
+        var headers = {};
+        headers["Content-Type"] = "application/json";
+        return FolderApi_await(_this14.request({
+          path: "/v2/accounts/{accountId}/folders".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this14.encodeParam("accountId", params.accountId)),
+          method: "PUT",
+          headers: headers,
+          query: query,
+          body: params.putFolderRequest
+        }, undefined, [][0]), function (response) {
+          return FolderApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return FolderApi;
+}(BaseAPI);
+;// CONCATENATED MODULE: ./src/public/shared/generated/apis/JobApi.ts
+function JobApi_typeof(obj) { "@babel/helpers - typeof"; return JobApi_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, JobApi_typeof(obj); }
+function JobApi_await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function JobApi_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function JobApi_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, JobApi_toPropertyKey(descriptor.key), descriptor); } }
+function JobApi_createClass(Constructor, protoProps, staticProps) { if (protoProps) JobApi_defineProperties(Constructor.prototype, protoProps); if (staticProps) JobApi_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function JobApi_toPropertyKey(arg) { var key = JobApi_toPrimitive(arg, "string"); return JobApi_typeof(key) === "symbol" ? key : String(key); }
+function JobApi_toPrimitive(input, hint) { if (JobApi_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (JobApi_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function JobApi_inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) JobApi_setPrototypeOf(subClass, superClass); }
+function JobApi_setPrototypeOf(o, p) { JobApi_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return JobApi_setPrototypeOf(o, p); }
+function JobApi_createSuper(Derived) { var hasNativeReflectConstruct = JobApi_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = JobApi_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = JobApi_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return JobApi_possibleConstructorReturn(this, result); }; }
+function JobApi_possibleConstructorReturn(self, call) { if (call && (JobApi_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return JobApi_assertThisInitialized(self); }
+function JobApi_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function JobApi_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function JobApi_getPrototypeOf(o) { JobApi_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return JobApi_getPrototypeOf(o); }
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * @bytescale/api
+ * Bytescale API
+ *
+ * The version of the OpenAPI document: 2.0.0
+ * Contact: hello@bytescale.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+// @ts-ignore
+
+var JobApi = /*#__PURE__*/function (_runtime$BaseAPI) {
+  JobApi_inherits(JobApi, _runtime$BaseAPI);
+  var _super = JobApi_createSuper(JobApi);
+  function JobApi() {
+    JobApi_classCallCheck(this, JobApi);
+    return _super.apply(this, arguments);
+  }
+  JobApi_createClass(JobApi, [{
+    key: "cancelJob",
+    value:
+    /**
+     * Cancels an in-progress background job.  Requires a `secret_*` API key.
+     */
+    function cancelJob(params) {
+      try {
+        var _this2 = this;
+        var query = {};
+        var headers = {};
+        return JobApi_await(_this2.request({
+          path: "/v2/accounts/{accountId}/jobs/{jobType}/{jobId}".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this2.encodeParam("accountId", params.accountId)).replace("{".concat("jobId", "}"),
+          // @ts-ignore
+          _this2.encodeParam("jobId", params.jobId)).replace("{".concat("jobType", "}"),
+          // @ts-ignore
+          _this2.encodeParam("jobType", params.jobType)),
+          method: "DELETE",
+          headers: headers,
+          query: query
+        }, undefined, [][0]), function (response) {
+          return JobApi_await(new VoidApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Gets information on a background job.  Requires a `secret_*` API key.
+     */
+  }, {
+    key: "getJob",
+    value: function getJob(params) {
+      try {
+        var _this4 = this;
+        var query = {};
+        var headers = {};
+        return JobApi_await(_this4.request({
+          path: "/v2/accounts/{accountId}/jobs/{jobType}/{jobId}".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this4.encodeParam("accountId", params.accountId)).replace("{".concat("jobId", "}"),
+          // @ts-ignore
+          _this4.encodeParam("jobId", params.jobId)).replace("{".concat("jobType", "}"),
+          // @ts-ignore
+          _this4.encodeParam("jobType", params.jobType)),
+          method: "GET",
+          headers: headers,
+          query: query
+        }, undefined, [][0]), function (response) {
+          return JobApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Lists the most recently issued background jobs.  Requires a `secret_*` API key.
+     */
+  }, {
+    key: "listRecentJobs",
+    value: function listRecentJobs(params) {
+      try {
+        var _this6 = this;
+        var query = {};
+        if (params.jobType) {
+          query["jobType"] = params.jobType;
+        }
+        var headers = {};
+        return JobApi_await(_this6.request({
+          path: "/v2/accounts/{accountId}/jobs".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this6.encodeParam("accountId", params.accountId)),
+          method: "GET",
+          headers: headers,
+          query: query
+        }, undefined, [][0]), function (response) {
+          return JobApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return JobApi;
+}(BaseAPI);
+;// CONCATENATED MODULE: ./src/public/shared/generated/apis/UploadApi.ts
+function UploadApi_typeof(obj) { "@babel/helpers - typeof"; return UploadApi_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, UploadApi_typeof(obj); }
+function UploadApi_await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function UploadApi_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function UploadApi_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, UploadApi_toPropertyKey(descriptor.key), descriptor); } }
+function UploadApi_createClass(Constructor, protoProps, staticProps) { if (protoProps) UploadApi_defineProperties(Constructor.prototype, protoProps); if (staticProps) UploadApi_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function UploadApi_toPropertyKey(arg) { var key = UploadApi_toPrimitive(arg, "string"); return UploadApi_typeof(key) === "symbol" ? key : String(key); }
+function UploadApi_toPrimitive(input, hint) { if (UploadApi_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UploadApi_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function UploadApi_inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) UploadApi_setPrototypeOf(subClass, superClass); }
+function UploadApi_setPrototypeOf(o, p) { UploadApi_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return UploadApi_setPrototypeOf(o, p); }
+function UploadApi_createSuper(Derived) { var hasNativeReflectConstruct = UploadApi_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = UploadApi_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = UploadApi_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return UploadApi_possibleConstructorReturn(this, result); }; }
+function UploadApi_possibleConstructorReturn(self, call) { if (call && (UploadApi_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return UploadApi_assertThisInitialized(self); }
+function UploadApi_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function UploadApi_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function UploadApi_getPrototypeOf(o) { UploadApi_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return UploadApi_getPrototypeOf(o); }
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * @bytescale/api
+ * Bytescale API
+ *
+ * The version of the OpenAPI document: 2.0.0
+ * Contact: hello@bytescale.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+// @ts-ignore
+
+var UploadApi = /*#__PURE__*/function (_runtime$BaseAPI) {
+  UploadApi_inherits(UploadApi, _runtime$BaseAPI);
+  var _super = UploadApi_createSuper(UploadApi);
+  function UploadApi() {
+    UploadApi_classCallCheck(this, UploadApi);
+    return _super.apply(this, arguments);
+  }
+  UploadApi_createClass(UploadApi, [{
+    key: "beginMultipartUpload",
+    value:
+    /**
+     * Begins a new multipart file upload process.
+     */
+    function beginMultipartUpload(params) {
+      try {
+        var _this2 = this;
+        var query = {};
+        var headers = {};
+        headers["Content-Type"] = "application/json";
+        return UploadApi_await(_this2.request({
+          path: "/v2/accounts/{accountId}/uploads".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this2.encodeParam("accountId", params.accountId)),
+          method: "POST",
+          headers: headers,
+          query: query,
+          body: params.beginMultipartUploadRequest
+        }, undefined, [][0]), function (response) {
+          return UploadApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Marks an upload part as uploaded.  You must call this endpoint after you have successfully issued a `PUT` request to the `uploadUrl` on the corresponding UploadPart.
+     */
+  }, {
+    key: "completeUploadPart",
+    value: function completeUploadPart(params) {
+      try {
+        var _this4 = this;
+        var query = {};
+        var headers = {};
+        headers["Content-Type"] = "application/json";
+        return UploadApi_await(_this4.request({
+          path: "/v2/accounts/{accountId}/uploads/{uploadId}/parts/{uploadPartIndex}".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this4.encodeParam("accountId", params.accountId)).replace("{".concat("uploadId", "}"),
+          // @ts-ignore
+          _this4.encodeParam("uploadId", params.uploadId)).replace("{".concat("uploadPartIndex", "}"),
+          // @ts-ignore
+          _this4.encodeParam("uploadPartIndex", params.uploadPartIndex)),
+          method: "PUT",
+          headers: headers,
+          query: query,
+          body: params.completeUploadPartRequest
+        }, undefined, [][0]), function (response) {
+          return UploadApi_await(new VoidApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Gets a remaining upload part for a multipart file upload.
+     */
+  }, {
+    key: "getUploadPart",
+    value: function getUploadPart(params) {
+      try {
+        var _this6 = this;
+        var query = {};
+        var headers = {};
+        return UploadApi_await(_this6.request({
+          path: "/v2/accounts/{accountId}/uploads/{uploadId}/parts/{uploadPartIndex}".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this6.encodeParam("accountId", params.accountId)).replace("{".concat("uploadId", "}"),
+          // @ts-ignore
+          _this6.encodeParam("uploadId", params.uploadId)).replace("{".concat("uploadPartIndex", "}"),
+          // @ts-ignore
+          _this6.encodeParam("uploadPartIndex", params.uploadPartIndex)),
+          method: "GET",
+          headers: headers,
+          query: query
+        }, undefined, [][0]), function (response) {
+          return UploadApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Lists the remaining upload parts for a multipart file upload.  An empty array is returned when the upload is complete.
+     */
+  }, {
+    key: "listUploadParts",
+    value: function listUploadParts(params) {
+      try {
+        var _this8 = this;
+        var query = {};
+        var headers = {};
+        return UploadApi_await(_this8.request({
+          path: "/v2/accounts/{accountId}/uploads/{uploadId}/parts".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this8.encodeParam("accountId", params.accountId)).replace("{".concat("uploadId", "}"),
+          // @ts-ignore
+          _this8.encodeParam("uploadId", params.uploadId)),
+          method: "GET",
+          headers: headers,
+          query: query
+        }, undefined, [][0]), function (response) {
+          return UploadApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Upload from a URL with a single HTTP request:
+     */
+  }, {
+    key: "uploadFromUrl",
+    value: function uploadFromUrl(params) {
+      try {
+        var _this10 = this;
+        var query = {};
+        var headers = {};
+        headers["Content-Type"] = "application/json";
+        return UploadApi_await(_this10.request({
+          path: "/v2/accounts/{accountId}/uploads/url".replace("{".concat("accountId", "}"),
+          // @ts-ignore
+          _this10.encodeParam("accountId", params.accountId)),
+          method: "POST",
+          headers: headers,
+          query: query,
+          body: params.uploadFromUrlRequest
+        }, undefined, [][0]), function (response) {
+          return UploadApi_await(new JSONApiResponse(response).value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return UploadApi;
+}(BaseAPI);
+;// CONCATENATED MODULE: ./src/public/shared/generated/apis/index.ts
+/* tslint:disable */
+/* eslint-disable */
+
+
+
+
+;// CONCATENATED MODULE: ./src/public/shared/generated/index.ts
+/* tslint:disable */
+/* eslint-disable */
+
+
+
+;// CONCATENATED MODULE: ./src/public/shared/CommonTypes.ts
+/**
+ * Workaround for tsc aliases, where we cannot export implementation-less modules in our dists.
+ */
+var CommonTypesNoOp = false;
+;// CONCATENATED MODULE: ./src/private/TypeUtils.ts
+function assertUnreachable(x) {
+  throw new Error("Didn't expect to get here: ".concat(JSON.stringify(x)));
+}
+function isDefinedEntry(object) {
+  return object[1] !== undefined && object[1] !== null;
+}
+;// CONCATENATED MODULE: ./src/public/shared/UrlBuilder.ts
+function UrlBuilder_typeof(obj) { "@babel/helpers - typeof"; return UrlBuilder_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, UrlBuilder_typeof(obj); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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 _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function UrlBuilder_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function UrlBuilder_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, UrlBuilder_toPropertyKey(descriptor.key), descriptor); } }
+function UrlBuilder_createClass(Constructor, protoProps, staticProps) { if (protoProps) UrlBuilder_defineProperties(Constructor.prototype, protoProps); if (staticProps) UrlBuilder_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function UrlBuilder_toPropertyKey(arg) { var key = UrlBuilder_toPrimitive(arg, "string"); return UrlBuilder_typeof(key) === "symbol" ? key : String(key); }
+function UrlBuilder_toPrimitive(input, hint) { if (UrlBuilder_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UrlBuilder_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+
+var UrlBuilder = /*#__PURE__*/function () {
+  function UrlBuilder() {
+    UrlBuilder_classCallCheck(this, UrlBuilder);
+  }
+  UrlBuilder_createClass(UrlBuilder, null, [{
+    key: "url",
+    value:
+    /**
+     * Builds a URL to either a raw file or a transformed file.
+     *
+     * Example 1) Getting a publicly-accessible raw file URL:
+     *
+     *   new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg" })
+     *
+     * Example 2) Getting a publicly-accessible image URL, resized to 500x500:
+     *
+     *   new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg", options: { transformation: { type: "image", params: { w: 500, h: 500, fit: "crop" } } } })
+     *
+     * Example 3) Getting a privately-accessible image URL, resized to 500x500 (requires 'AuthManager.beginAuthSession' to be called before accessing the URL):
+     *
+     *   new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg", options: { transformation: { type: "image", params: { w: 500, h: 500, fit: "crop" } }, auth: true } })
+     *
+     * Example 4) Getting a publicly-accessible image URL, resized using a transformation preset called "thumbnail" that was created manually in the Bytescale Dashboard:
+     *
+     *   new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg", options: { transformation: { type: "preset", preset: "thumbnail" } } })
+     */
+    function url(params) {
+      var _a;
+      return ((_a = params.options) === null || _a === void 0 ? void 0 : _a.transformation) === undefined ? this.raw(params) : this.transformation(params, params.options);
+    }
+  }, {
+    key: "raw",
+    value: function raw(params) {
+      var _a;
+      var baseUrl = this.getBaseUrl(params, "raw");
+      var commonParams = this.getCommonQueryParams((_a = params.options) !== null && _a !== void 0 ? _a : {});
+      return this.addQueryParams(baseUrl, commonParams);
+    }
+  }, {
+    key: "transformation",
+    value: function transformation(params, trans) {
+      var _a;
+      var baseUrl = this.getBaseUrl(params, trans.transformation === "preset" ? trans.transformationPreset : trans.transformation);
+      var transParams = trans.transformation === "preset" ? [] : this.getTransformationParams(trans);
+      var commonParams = this.getCommonQueryParams((_a = params.options) !== null && _a !== void 0 ? _a : {});
+      var transCommonParams = this.getCommonTransformationQueryParams(trans);
+      // This format puts "artifact" at the end, which isn't required, but is convention.
+      return this.addQueryParams(baseUrl, [].concat(_toConsumableArray(transParams), _toConsumableArray(commonParams), _toConsumableArray(transCommonParams)));
+    }
+  }, {
+    key: "getBaseUrl",
+    value: function getBaseUrl(params, prefix) {
+      var cdnUrl = BytescaleApiClientConfigUtils.defaultCdnUrl;
+      return "".concat(cdnUrl, "/").concat(params.accountId, "/").concat(prefix).concat(params.filePath);
+    }
+  }, {
+    key: "getCommonTransformationQueryParams",
+    value: function getCommonTransformationQueryParams(trans) {
+      return this.makeQueryParams(["cachePermanently", "large", "artifact"], {
+        cachePermanently: "cache_perm"
+      })(trans);
+    }
+  }, {
+    key: "getCommonQueryParams",
+    value: function getCommonQueryParams(params) {
+      return this.makeQueryParams(["auth", "cache", "cacheTtl", "version", "forceDownloadPrompt"], {
+        cacheTtl: "cache_ttl",
+        forceDownloadPrompt: "download"
+      })(params);
+    }
+  }, {
+    key: "makeQueryParams",
+    value: function makeQueryParams(keys, keyOverrides) {
+      return function (data) {
+        var result = [];
+        keys.forEach(function (key) {
+          var _a;
+          var value = data[key];
+          if (value !== undefined) {
+            result.push([(_a = keyOverrides[key]) !== null && _a !== void 0 ? _a : key, value.toString()]);
+          }
+        });
+        return result;
+      };
+    }
+  }, {
+    key: "getTransformationParams",
+    value: function getTransformationParams(trans) {
+      var params = trans.transformationParams;
+      if (params === undefined) {
+        return [];
+      }
+      var serializeObj = function serializeObj(obj) {
+        return Object.entries(obj).filter(isDefinedEntry).map(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            key = _ref2[0],
+            value = _ref2[1];
+          return [key, value.toString()];
+        });
+      };
+      return Array.isArray(params) ? params.flatMap(serializeObj) : serializeObj(params);
+    }
+  }, {
+    key: "addQueryParams",
+    value: function addQueryParams(baseUrl, params) {
+      if (params.length === 0) {
+        return baseUrl;
+      }
+      return "".concat(baseUrl, "?").concat(params.map(function (_ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2),
+          key = _ref4[0],
+          value = _ref4[1];
+        return "".concat(encodeURIComponent(key), "=").concat(encodeURIComponent(value));
+      }).join("&"));
+    }
+  }]);
+  return UrlBuilder;
+}();
+;// CONCATENATED MODULE: ./src/public/shared/UrlBuilderTypes.ts
+/**
+ * Workaround for tsc aliases, where we cannot export implementation-less modules in our dists.
+ */
+var UrlBuilderTypesNoOp = false;
+;// CONCATENATED MODULE: ./src/public/shared/index.ts
+
+
+
+
+;// CONCATENATED MODULE: ./src/private/UploadManagerBase.ts
+function UploadManagerBase_typeof(obj) { "@babel/helpers - typeof"; return UploadManagerBase_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, UploadManagerBase_typeof(obj); }
+function _async(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
+function _invokeIgnored(body) {
+  var result = body();
+  if (result && result.then) {
+    return result.then(UploadManagerBase_empty);
+  }
+}
+function UploadManagerBase_settle(pact, state, value) {
+  if (!pact.s) {
+    if (value instanceof UploadManagerBase_Pact) {
+      if (value.s) {
+        if (state & 1) {
+          state = value.s;
+        }
+        value = value.v;
+      } else {
+        value.o = UploadManagerBase_settle.bind(null, pact, state);
+        return;
+      }
+    }
+    if (value && value.then) {
+      value.then(UploadManagerBase_settle.bind(null, pact, state), UploadManagerBase_settle.bind(null, pact, 2));
+      return;
+    }
+    pact.s = state;
+    pact.v = value;
+    var observer = pact.o;
+    if (observer) {
+      observer(pact);
+    }
+  }
+}
+var UploadManagerBase_Pact = /*#__PURE__*/function () {
+  function _Pact() {}
+  _Pact.prototype.then = function (onFulfilled, onRejected) {
+    var result = new _Pact();
+    var state = this.s;
+    if (state) {
+      var callback = state & 1 ? onFulfilled : onRejected;
+      if (callback) {
+        try {
+          UploadManagerBase_settle(result, 1, callback(this.v));
+        } catch (e) {
+          UploadManagerBase_settle(result, 2, e);
+        }
+        return result;
+      } else {
+        return this;
+      }
+    }
+    this.o = function (_this) {
+      try {
+        var value = _this.v;
+        if (_this.s & 1) {
+          UploadManagerBase_settle(result, 1, onFulfilled ? onFulfilled(value) : value);
+        } else if (onRejected) {
+          UploadManagerBase_settle(result, 1, onRejected(value));
+        } else {
+          UploadManagerBase_settle(result, 2, value);
+        }
+      } catch (e) {
+        UploadManagerBase_settle(result, 2, e);
+      }
+    };
+    return result;
+  };
+  return _Pact;
+}();
+function UploadManagerBase_isSettledPact(thenable) {
+  return thenable instanceof UploadManagerBase_Pact && thenable.s & 1;
+}
+function UploadManagerBase_for(test, update, body) {
+  var stage;
+  for (;;) {
+    var shouldContinue = test();
+    if (UploadManagerBase_isSettledPact(shouldContinue)) {
+      shouldContinue = shouldContinue.v;
+    }
+    if (!shouldContinue) {
+      return result;
+    }
+    if (shouldContinue.then) {
+      stage = 0;
+      break;
+    }
+    var result = body();
+    if (result && result.then) {
+      if (UploadManagerBase_isSettledPact(result)) {
+        result = result.s;
+      } else {
+        stage = 1;
+        break;
+      }
+    }
+    if (update) {
+      var updateValue = update();
+      if (updateValue && updateValue.then && !UploadManagerBase_isSettledPact(updateValue)) {
+        stage = 2;
+        break;
+      }
+    }
+  }
+  var pact = new UploadManagerBase_Pact();
+  var reject = UploadManagerBase_settle.bind(null, pact, 2);
+  (stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);
+  return pact;
+  function _resumeAfterBody(value) {
+    result = value;
+    do {
+      if (update) {
+        updateValue = update();
+        if (updateValue && updateValue.then && !UploadManagerBase_isSettledPact(updateValue)) {
+          updateValue.then(_resumeAfterUpdate).then(void 0, reject);
+          return;
+        }
+      }
+      shouldContinue = test();
+      if (!shouldContinue || UploadManagerBase_isSettledPact(shouldContinue) && !shouldContinue.v) {
+        UploadManagerBase_settle(pact, 1, result);
+        return;
+      }
+      if (shouldContinue.then) {
+        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+        return;
+      }
+      result = body();
+      if (UploadManagerBase_isSettledPact(result)) {
+        result = result.v;
+      }
+    } while (!result || !result.then);
+    result.then(_resumeAfterBody).then(void 0, reject);
+  }
+  function _resumeAfterTest(shouldContinue) {
+    if (shouldContinue) {
+      result = body();
+      if (result && result.then) {
+        result.then(_resumeAfterBody).then(void 0, reject);
+      } else {
+        _resumeAfterBody(result);
+      }
+    } else {
+      UploadManagerBase_settle(pact, 1, result);
+    }
+  }
+  function _resumeAfterUpdate() {
+    if (shouldContinue = test()) {
+      if (shouldContinue.then) {
+        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+      } else {
+        _resumeAfterTest(shouldContinue);
+      }
+    } else {
+      UploadManagerBase_settle(pact, 1, result);
+    }
+  }
+}
+function _continueIgnored(value) {
+  if (value && value.then) {
+    return value.then(UploadManagerBase_empty);
+  }
+}
+function UploadManagerBase_toConsumableArray(arr) { return UploadManagerBase_arrayWithoutHoles(arr) || UploadManagerBase_iterableToArray(arr) || UploadManagerBase_unsupportedIterableToArray(arr) || UploadManagerBase_nonIterableSpread(); }
+function UploadManagerBase_nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function UploadManagerBase_unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return UploadManagerBase_arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return UploadManagerBase_arrayLikeToArray(o, minLen); }
+function UploadManagerBase_iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function UploadManagerBase_arrayWithoutHoles(arr) { if (Array.isArray(arr)) return UploadManagerBase_arrayLikeToArray(arr); }
+function UploadManagerBase_arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function UploadManagerBase_empty() {}
+function UploadManagerBase_awaitIgnored(value, direct) {
+  if (!direct) {
+    return value && value.then ? value.then(UploadManagerBase_empty) : Promise.resolve();
+  }
+}
+function UploadManagerBase_await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function UploadManagerBase_rethrow(thrown, value) {
+  if (thrown) throw value;
+  return value;
+}
+function UploadManagerBase_finallyRethrows(body, finalizer) {
+  try {
+    var result = body();
+  } catch (e) {
+    return finalizer(true, e);
+  }
+  if (result && result.then) {
+    return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
+  }
+  return finalizer(false, result);
+}
+function UploadManagerBase_continue(value, then) {
+  return value && value.then ? value.then(then) : then(value);
+}
+function UploadManagerBase_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function UploadManagerBase_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, UploadManagerBase_toPropertyKey(descriptor.key), descriptor); } }
+function UploadManagerBase_createClass(Constructor, protoProps, staticProps) { if (protoProps) UploadManagerBase_defineProperties(Constructor.prototype, protoProps); if (staticProps) UploadManagerBase_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function UploadManagerBase_toPropertyKey(arg) { var key = UploadManagerBase_toPrimitive(arg, "string"); return UploadManagerBase_typeof(key) === "symbol" ? key : String(key); }
+function UploadManagerBase_toPrimitive(input, hint) { if (UploadManagerBase_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UploadManagerBase_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+/**
+ * Methods common to UploadManagerNode and UploadManagerBrowser.
+ */
+var UploadManagerBase = /*#__PURE__*/function () {
+  function UploadManagerBase(config) {
+    UploadManagerBase_classCallCheck(this, UploadManagerBase);
+    this.config = config;
+    this.stringMimeType = "text/plain";
+    this.defaultMaxConcurrentUploadParts = 4;
+    this.intervalMs = 500;
+    this.uploadApi = new UploadApi(config);
+    this.accountId = BytescaleApiClientConfigUtils.getAccountId(config);
+  }
+  UploadManagerBase_createClass(UploadManagerBase, [{
+    key: "upload",
+    value: function upload(request) {
+      try {
+        var _this2 = this;
+        _this2.assertNotCancelled(request);
+        var source = _this2.processUploadSource(request.data);
+        var preUploadInfo = _this2.getPreUploadInfo(request, source);
+        var bytesTotal = preUploadInfo.size;
+        var makeOnProgressForPart = _this2.makeOnProgressForPartFactory(request, bytesTotal);
+        var init = _this2.preUpload(source);
+        // Raise initial progress event SYNCHRONOUSLY.
+        if (request.onProgress !== undefined) {
+          request.onProgress(_this2.makeProgressEvent(0, bytesTotal));
+        }
+        return UploadManagerBase_await(_this2.beginUpload(request, preUploadInfo), function (uploadInfo) {
+          var partCount = uploadInfo.uploadParts.count;
+          var parts = UploadManagerBase_toConsumableArray(Array(partCount).keys());
+          var _this2$makeCancellati = _this2.makeCancellationMethods(),
+            cancel = _this2$makeCancellati.cancel,
+            addCancellationHandler = _this2$makeCancellati.addCancellationHandler;
+          var intervalHandle = setInterval(_this2.onIntervalTick(request, cancel), _this2.intervalMs);
+          return UploadManagerBase_continue(UploadManagerBase_finallyRethrows(function () {
+            return UploadManagerBase_await(_this2.mapAsync(parts, preUploadInfo.maxConcurrentUploadParts, _async(function (part) {
+              return _this2.uploadPart(request, source, part, uploadInfo, makeOnProgressForPart(), addCancellationHandler);
+            })), function () {
+              return UploadManagerBase_awaitIgnored(_this2.postUpload(init));
+            });
+          }, function (_wasThrown, _result) {
+            clearInterval(intervalHandle);
+            return UploadManagerBase_rethrow(_wasThrown, _result);
+          }), function () {
+            return uploadInfo.file;
+          });
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "getBlobInfo",
+    value: function getBlobInfo(_ref) {
+      var _ref$value = _ref.value,
+        name = _ref$value.name,
+        size = _ref$value.size,
+        type = _ref$value.type;
+      return {
+        mime: type,
+        size: size,
+        originalFileName: name,
+        maxConcurrentUploadParts: undefined
+      };
+    }
+  }, {
+    key: "onIntervalTick",
+    value: function onIntervalTick(request, cancel) {
+      var _this3 = this;
+      return function () {
+        if (_this3.isCancelled(request)) {
+          cancel();
+        }
+      };
+    }
+  }, {
+    key: "makeCancellationMethods",
+    value: function makeCancellationMethods() {
+      var cancellationHandlers = [];
+      var addCancellationHandler = function addCancellationHandler(ca) {
+        cancellationHandlers.push(ca);
+      };
+      var cancel = function cancel() {
+        return cancellationHandlers.forEach(function (x) {
+          return x();
+        });
+      };
+      return {
+        cancel: cancel,
+        addCancellationHandler: addCancellationHandler
+      };
+    }
+    /**
+     * Returns a callback, which when called, returns a callback that can be used by ONE specific part to report its progress.
+     */
+  }, {
+    key: "makeOnProgressForPartFactory",
+    value: function makeOnProgressForPartFactory(request, bytesTotal) {
+      var _this4 = this;
+      var onProgress = request.onProgress;
+      if (onProgress === undefined) {
+        return function () {
+          return function () {};
+        };
+      }
+      var bytesSent = 0;
+      return function () {
+        var bytesSentForPart = 0;
+        return function (bytesSentTotalForPart) {
+          var delta = bytesSentTotalForPart - bytesSentForPart;
+          bytesSentForPart += delta;
+          bytesSent += delta;
+          onProgress(_this4.makeProgressEvent(bytesSent, bytesTotal));
+        };
+      };
+    }
+  }, {
+    key: "makeProgressEvent",
+    value: function makeProgressEvent(bytesSent, bytesTotal) {
+      return {
+        bytesTotal: bytesTotal,
+        bytesSent: bytesSent,
+        progress: Math.round(bytesSent / bytesTotal * 100)
+      };
+    }
+  }, {
+    key: "assertNotCancelled",
+    value: function assertNotCancelled(request) {
+      if (this.isCancelled(request)) {
+        throw new CancelledError();
+      }
+    }
+  }, {
+    key: "isCancelled",
+    value: function isCancelled(request) {
+      var _a;
+      return ((_a = request.cancellationToken) === null || _a === void 0 ? void 0 : _a.isCancelled) === true;
+    }
+  }, {
+    key: "beginUpload",
+    value: function beginUpload(request, _ref2) {
+      var size = _ref2.size,
+        mime = _ref2.mime,
+        originalFileName = _ref2.originalFileName;
+      try {
+        var _this6 = this;
+        return UploadManagerBase_await(_this6.uploadApi.beginMultipartUpload({
+          accountId: _this6.accountId,
+          beginMultipartUploadRequest: {
+            metadata: request.metadata,
+            mime: mime,
+            originalFileName: originalFileName,
+            path: request.path,
+            protocol: "1.1",
+            size: size,
+            tags: request.tags
+          }
+        }));
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "uploadPart",
+    value: function uploadPart(request, source, partIndex, uploadInfo, onProgress, addCancellationHandler) {
+      try {
+        var _this8 = this;
+        _this8.assertNotCancelled(request);
+        return UploadManagerBase_await(_this8.getUploadPart(partIndex, uploadInfo), function (part) {
+          _this8.assertNotCancelled(request);
+          return UploadManagerBase_await(_this8.putUploadPart(part, source, onProgress, addCancellationHandler), function (etag) {
+            _this8.assertNotCancelled(request);
+            return UploadManagerBase_awaitIgnored(_this8.uploadApi.completeUploadPart({
+              accountId: _this8.accountId,
+              uploadId: uploadInfo.uploadId,
+              uploadPartIndex: partIndex,
+              completeUploadPartRequest: {
+                etag: etag
+              }
+            }));
+          });
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Returns etag for the part.
+     */
+  }, {
+    key: "putUploadPart",
+    value: function putUploadPart(part, source, onProgress, addCancellationHandler) {
+      try {
+        var _this10 = this;
+        var contentLength = part.range.inclusiveEnd + 1 - part.range.inclusiveStart;
+        return UploadManagerBase_await(_this10.doPutUploadPart(part, contentLength, source, onProgress, addCancellationHandler), function (_ref3) {
+          var status = _ref3.status,
+            etag = _ref3.etag;
+          if (Math.floor(status / 100) !== 2) {
+            throw new Error("Failed to upload part (".concat(status, ")."));
+          }
+          if (etag === undefined) {
+            throw new Error("No 'etag' response header found in upload part response.");
+          }
+          // Always send 100% for part, as some UploadManager implementations either don't report progress, or may not report the last chunk uploaded.
+          onProgress(contentLength);
+          return etag;
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "getUploadPart",
+    value: function getUploadPart(partIndex, uploadInfo) {
+      try {
+        var _this12 = this;
+        if (partIndex === 0) {
+          return uploadInfo.uploadParts.first;
+        }
+        return UploadManagerBase_await(_this12.uploadApi.getUploadPart({
+          uploadId: uploadInfo.uploadId,
+          accountId: _this12.accountId,
+          uploadPartIndex: partIndex
+        }));
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "getPreUploadInfo",
+    value: function getPreUploadInfo(request, source) {
+      var _a, _b, _c;
+      var partial = this.getPreUploadInfoPartial(request, source);
+      return {
+        maxConcurrentUploadParts: (_a = partial.maxConcurrentUploadParts) !== null && _a !== void 0 ? _a : this.defaultMaxConcurrentUploadParts,
+        originalFileName: (_b = request.originalFileName) !== null && _b !== void 0 ? _b : partial.originalFileName,
+        mime: (_c = request.mime) !== null && _c !== void 0 ? _c : partial.mime,
+        size: partial.size
+      };
+    }
+  }, {
+    key: "mapAsync",
+    value: function mapAsync(items, concurrency, callback) {
+      try {
+        var workQueue = UploadManagerBase_toConsumableArray(items);
+        return UploadManagerBase_awaitIgnored(Promise.all(UploadManagerBase_toConsumableArray(Array(concurrency).keys()).map(_async(function () {
+          return _continueIgnored(UploadManagerBase_for(function () {
+            return workQueue.length > 0;
+          }, void 0, function () {
+            var work = workQueue.shift(); // IMPORTANT: use 'shift' instead of 'pop' to ensure 'items' are processed in order when 'concurrency = 1'.
+            return _invokeIgnored(function () {
+              if (work !== undefined) {
+                return UploadManagerBase_awaitIgnored(callback(work));
+              }
+            });
+          }));
+        }))));
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return UploadManagerBase;
+}();
+;// CONCATENATED MODULE: ./src/private/UploadManagerBrowserWorkerBase.ts
+function UploadManagerBrowserWorkerBase_typeof(obj) { "@babel/helpers - typeof"; return UploadManagerBrowserWorkerBase_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, UploadManagerBrowserWorkerBase_typeof(obj); }
+function UploadManagerBrowserWorkerBase_await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function UploadManagerBrowserWorkerBase_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function UploadManagerBrowserWorkerBase_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, UploadManagerBrowserWorkerBase_toPropertyKey(descriptor.key), descriptor); } }
+function UploadManagerBrowserWorkerBase_createClass(Constructor, protoProps, staticProps) { if (protoProps) UploadManagerBrowserWorkerBase_defineProperties(Constructor.prototype, protoProps); if (staticProps) UploadManagerBrowserWorkerBase_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function UploadManagerBrowserWorkerBase_toPropertyKey(arg) { var key = UploadManagerBrowserWorkerBase_toPrimitive(arg, "string"); return UploadManagerBrowserWorkerBase_typeof(key) === "symbol" ? key : String(key); }
+function UploadManagerBrowserWorkerBase_toPrimitive(input, hint) { if (UploadManagerBrowserWorkerBase_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UploadManagerBrowserWorkerBase_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function UploadManagerBrowserWorkerBase_inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) UploadManagerBrowserWorkerBase_setPrototypeOf(subClass, superClass); }
+function UploadManagerBrowserWorkerBase_setPrototypeOf(o, p) { UploadManagerBrowserWorkerBase_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return UploadManagerBrowserWorkerBase_setPrototypeOf(o, p); }
+function UploadManagerBrowserWorkerBase_createSuper(Derived) { var hasNativeReflectConstruct = UploadManagerBrowserWorkerBase_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = UploadManagerBrowserWorkerBase_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = UploadManagerBrowserWorkerBase_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return UploadManagerBrowserWorkerBase_possibleConstructorReturn(this, result); }; }
+function UploadManagerBrowserWorkerBase_possibleConstructorReturn(self, call) { if (call && (UploadManagerBrowserWorkerBase_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return UploadManagerBrowserWorkerBase_assertThisInitialized(self); }
+function UploadManagerBrowserWorkerBase_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function UploadManagerBrowserWorkerBase_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function UploadManagerBrowserWorkerBase_getPrototypeOf(o) { UploadManagerBrowserWorkerBase_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return UploadManagerBrowserWorkerBase_getPrototypeOf(o); }
+
+
+/**
+ * The "browser" and "worker" runtimes support the same input types, but the former uses XHR and the latter uses Fetch.
+ */
+var UploadManagerBrowserWorkerBase = /*#__PURE__*/function (_UploadManagerBase) {
+  UploadManagerBrowserWorkerBase_inherits(UploadManagerBrowserWorkerBase, _UploadManagerBase);
+  var _super = UploadManagerBrowserWorkerBase_createSuper(UploadManagerBrowserWorkerBase);
+  function UploadManagerBrowserWorkerBase() {
+    UploadManagerBrowserWorkerBase_classCallCheck(this, UploadManagerBrowserWorkerBase);
+    return _super.apply(this, arguments);
+  }
+  UploadManagerBrowserWorkerBase_createClass(UploadManagerBrowserWorkerBase, [{
+    key: "processUploadSource",
+    value: function processUploadSource(data) {
+      if (typeof data === "string") {
+        // 'Blob' must be from 'global' (i.e. not imported) as we're in a browser context here, so is globally available.
+        return {
+          type: "Blob",
+          value: new Blob([data], {
+            type: this.stringMimeType
+          })
+        };
+      }
+      if (data.byteLength !== undefined) {
+        return {
+          type: "ArrayBuffer",
+          value: data
+        };
+      }
+      if (data.size !== undefined) {
+        return {
+          type: "Blob",
+          value: data
+        };
+      }
+      throw new Error("Unsupported type for 'data' parameter. Please provide a String, Blob, ArrayBuffer, or File object (from a file input element).");
+    }
+  }, {
+    key: "getPreUploadInfoPartial",
+    value: function getPreUploadInfoPartial(_request, data) {
+      switch (data.type) {
+        case "Blob":
+          return this.getBlobInfo(data);
+        case "ArrayBuffer":
+          return {
+            mime: undefined,
+            size: data.value.byteLength,
+            originalFileName: undefined,
+            maxConcurrentUploadParts: undefined
+          };
+        default:
+          assertUnreachable(data);
+      }
+    }
+  }, {
+    key: "preUpload",
+    value: function preUpload(_source) {
+      return undefined;
+    }
+  }, {
+    key: "postUpload",
+    value: function postUpload(_init) {
+      return UploadManagerBrowserWorkerBase_await();
+    } // NO-OP.
+  }, {
+    key: "getRequestBody",
+    value: function getRequestBody(part, blob) {
+      return part.range.inclusiveEnd === -1 ? new Blob() : blob.value.slice(part.range.inclusiveStart, part.range.inclusiveEnd + 1);
+    }
+  }]);
+  return UploadManagerBrowserWorkerBase;
+}(UploadManagerBase);
+;// CONCATENATED MODULE: ./src/private/UploadManagerFetchUtils.ts
+function UploadManagerFetchUtils_typeof(obj) { "@babel/helpers - typeof"; return UploadManagerFetchUtils_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, UploadManagerFetchUtils_typeof(obj); }
+function UploadManagerFetchUtils_await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function UploadManagerFetchUtils_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function UploadManagerFetchUtils_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, UploadManagerFetchUtils_toPropertyKey(descriptor.key), descriptor); } }
+function UploadManagerFetchUtils_createClass(Constructor, protoProps, staticProps) { if (protoProps) UploadManagerFetchUtils_defineProperties(Constructor.prototype, protoProps); if (staticProps) UploadManagerFetchUtils_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function UploadManagerFetchUtils_toPropertyKey(arg) { var key = UploadManagerFetchUtils_toPrimitive(arg, "string"); return UploadManagerFetchUtils_typeof(key) === "symbol" ? key : String(key); }
+function UploadManagerFetchUtils_toPrimitive(input, hint) { if (UploadManagerFetchUtils_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UploadManagerFetchUtils_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+var UploadManagerFetchUtils = /*#__PURE__*/function () {
+  function UploadManagerFetchUtils() {
+    UploadManagerFetchUtils_classCallCheck(this, UploadManagerFetchUtils);
+  }
+  UploadManagerFetchUtils_createClass(UploadManagerFetchUtils, null, [{
+    key: "doPutUploadPart",
+    value: function doPutUploadPart(config, part, content, contentLength, addCancellationHandler) {
+      try {
+        var _a;
+        var fetchApi = BytescaleApiClientConfigUtils.getFetchApi(config);
+        // Configure cancellation:
+        var controller = new AbortController();
+        var signal = controller.signal;
+        addCancellationHandler(function () {
+          return controller.abort();
+        });
+        var headers = {
+          // Required to prevent fetch using "Transfer-Encoding: Chunked" when body is a stream.
+          "content-length": contentLength.toString()
+        };
+        return UploadManagerFetchUtils_await(fetchApi(part.uploadUrl, {
+          method: "PUT",
+          headers: headers,
+          body: content,
+          signal: signal,
+          cache: "no-store" // Required for Next.js's Fetch implementation, which caches POST/PUT requests by default.
+        }), function (response) {
+          return {
+            etag: (_a = response.headers.get("etag")) !== null && _a !== void 0 ? _a : undefined,
+            status: response.status
+          };
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return UploadManagerFetchUtils;
+}();
+;// CONCATENATED MODULE: ./src/public/worker/UploadManagerWorker.ts
+function UploadManagerWorker_typeof(obj) { "@babel/helpers - typeof"; return UploadManagerWorker_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, UploadManagerWorker_typeof(obj); }
+function UploadManagerWorker_await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function UploadManagerWorker_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function UploadManagerWorker_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, UploadManagerWorker_toPropertyKey(descriptor.key), descriptor); } }
+function UploadManagerWorker_createClass(Constructor, protoProps, staticProps) { if (protoProps) UploadManagerWorker_defineProperties(Constructor.prototype, protoProps); if (staticProps) UploadManagerWorker_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function UploadManagerWorker_toPropertyKey(arg) { var key = UploadManagerWorker_toPrimitive(arg, "string"); return UploadManagerWorker_typeof(key) === "symbol" ? key : String(key); }
+function UploadManagerWorker_toPrimitive(input, hint) { if (UploadManagerWorker_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UploadManagerWorker_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function UploadManagerWorker_inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) UploadManagerWorker_setPrototypeOf(subClass, superClass); }
+function UploadManagerWorker_setPrototypeOf(o, p) { UploadManagerWorker_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return UploadManagerWorker_setPrototypeOf(o, p); }
+function UploadManagerWorker_createSuper(Derived) { var hasNativeReflectConstruct = UploadManagerWorker_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = UploadManagerWorker_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = UploadManagerWorker_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return UploadManagerWorker_possibleConstructorReturn(this, result); }; }
+function UploadManagerWorker_possibleConstructorReturn(self, call) { if (call && (UploadManagerWorker_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return UploadManagerWorker_assertThisInitialized(self); }
+function UploadManagerWorker_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function UploadManagerWorker_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function UploadManagerWorker_getPrototypeOf(o) { UploadManagerWorker_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return UploadManagerWorker_getPrototypeOf(o); }
+
+
+var UploadManager = /*#__PURE__*/function (_UploadManagerBrowser) {
+  UploadManagerWorker_inherits(UploadManager, _UploadManagerBrowser);
+  var _super = UploadManagerWorker_createSuper(UploadManager);
+  function UploadManager() {
+    UploadManagerWorker_classCallCheck(this, UploadManager);
+    return _super.apply(this, arguments);
+  }
+  UploadManagerWorker_createClass(UploadManager, [{
+    key: "doPutUploadPart",
+    value: function doPutUploadPart(part, contentLength, source, _onProgress, addCancellationHandler) {
+      try {
+        var _this2 = this;
+        return UploadManagerWorker_await(UploadManagerFetchUtils.doPutUploadPart(_this2.config, part, _this2.getRequestBody(part, source), contentLength, addCancellationHandler));
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return UploadManager;
+}(UploadManagerBrowserWorkerBase);
+;// CONCATENATED MODULE: ./src/private/EnvChecker.ts
+function EnvChecker_typeof(obj) { "@babel/helpers - typeof"; return EnvChecker_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, EnvChecker_typeof(obj); }
+function EnvChecker_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function EnvChecker_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, EnvChecker_toPropertyKey(descriptor.key), descriptor); } }
+function EnvChecker_createClass(Constructor, protoProps, staticProps) { if (protoProps) EnvChecker_defineProperties(Constructor.prototype, protoProps); if (staticProps) EnvChecker_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function EnvChecker_toPropertyKey(arg) { var key = EnvChecker_toPrimitive(arg, "string"); return EnvChecker_typeof(key) === "symbol" ? key : String(key); }
+function EnvChecker_toPrimitive(input, hint) { if (EnvChecker_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (EnvChecker_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var EnvChecker = /*#__PURE__*/function () {
+  function EnvChecker() {
+    EnvChecker_classCallCheck(this, EnvChecker);
+  }
+  EnvChecker_createClass(EnvChecker, null, [{
+    key: "isBrowser",
+    value: function isBrowser() {
+      return typeof window !== "undefined";
+    }
+  }, {
+    key: "methodRequiresBrowser",
+    value: function methodRequiresBrowser(methodName) {
+      if (!EnvChecker.isBrowser()) {
+        return new Error("You must call '".concat(methodName, "' in your client-side code. (You have called it in your server-side code.)"));
+      }
+      return new Error("The '".concat(methodName, "' method cannot be called because you have bundled a non-browser implementation of the Bytescale JavaScript SDK into your client-side code. Please ensure your bundling tool (Webpack, Rollup, etc.) is honouring the \"browser\" field of the \"package.json\" file for this package, as this will allow the browser implementation of the Bytescale JavaScript SDK to be included in your client-side code."));
+    }
+  }]);
+  return EnvChecker;
+}();
+;// CONCATENATED MODULE: ./src/public/node/AuthManagerNode.ts
+function AuthManagerNode_typeof(obj) { "@babel/helpers - typeof"; return AuthManagerNode_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, AuthManagerNode_typeof(obj); }
+function AuthManagerNode_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function AuthManagerNode_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, AuthManagerNode_toPropertyKey(descriptor.key), descriptor); } }
+function AuthManagerNode_createClass(Constructor, protoProps, staticProps) { if (protoProps) AuthManagerNode_defineProperties(Constructor.prototype, protoProps); if (staticProps) AuthManagerNode_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function AuthManagerNode_toPropertyKey(arg) { var key = AuthManagerNode_toPrimitive(arg, "string"); return AuthManagerNode_typeof(key) === "symbol" ? key : String(key); }
+function AuthManagerNode_toPrimitive(input, hint) { if (AuthManagerNode_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (AuthManagerNode_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+var AuthManagerImpl = /*#__PURE__*/function () {
+  function AuthManagerImpl() {
+    AuthManagerNode_classCallCheck(this, AuthManagerImpl);
+  }
+  AuthManagerNode_createClass(AuthManagerImpl, [{
+    key: "beginAuthSession",
+    value: function beginAuthSession(_params) {
+      try {
+        throw EnvChecker.methodRequiresBrowser("beginAuthSession");
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "endAuthSession",
+    value: function endAuthSession() {
+      try {
+        throw EnvChecker.methodRequiresBrowser("endAuthSession");
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "isAuthSessionActive",
+    value: function isAuthSessionActive() {
+      return false;
+    }
+  }]);
+  return AuthManagerImpl;
+}();
+/**
+ * Alternative way of implementing a static class (i.e. all methods static). We do this so we can use a interface on the class (interfaces can't define static methods).
+ */
+var AuthManager = new AuthManagerImpl();
+;// CONCATENATED MODULE: ./src/public/worker/index.ts
+
+
+;// CONCATENATED MODULE: ./src/index.worker.ts
+/* tslint:disable */
+/* eslint-disable */
+
+
+module.exports = __lib_exports__;
+/******/ })()
+;