@bytescale/sdk 3.0.0-alpha.7 → 3.0.0-alpha.8

package/dist/node/esm/main.mjs

@@ -0,0 +1,2671 @@
+// ----------------------------------------
+// POLYFILL GUIDE:
+// ----------------------------------------
+//
+// "buffer" & "stream" are not required for browser environments.
+//
+// They are only used when the code detects it's running in Node.js (at runtime).
+//
+// You may polyfill them with empty objects (for browser environments):
+//
+// ----------------------------------------
+// Webpack:
+// {
+//   resolve: {
+//     fallback: {
+//       buffer: false,
+//       stream: false
+//     }
+//   }
+// }
+// ----------------------------------------
+//
+import * as __WEBPACK_EXTERNAL_MODULE_stream__ from "stream";
+import * as __WEBPACK_EXTERNAL_MODULE_buffer__ from "buffer";
+/******/ // 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); }
+/******/ }();
+/******/ 
+/************************************************************************/
+var __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/AuthSessionState.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 _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); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+var AuthSessionState = /*#__PURE__*/_createClass(function AuthSessionState() {
+  _classCallCheck(this, AuthSessionState);
+});
+;// 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 _empty() {}
+function _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 _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);
+  }
+  runtime_createClass(BaseAPI, [{
+    key: "request",
+    value: function request(context, initOverrides, baseUrlOverride) {
+      try {
+        var _this2 = this;
+        var _a, _b;
+        var apiKey = _this2.config.apiKey;
+        context.headers["Authorization"] = "Bearer ".concat(apiKey); // authorization-header authentication
+        if (((_a = AuthSessionState.session) === null || _a === void 0 ? void 0 : _a.accessToken) !== undefined) {
+          context.headers["Authorization-Token"] = AuthSessionState.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 _await(_this2.createFetchParams(context, initOverrides, baseUrlOverride === undefined ? undefined : (_b = nonDefaultBasePaths[baseUrlOverride]) !== null && _b !== void 0 ? _b : baseUrlOverride), function (_ref) {
+          var url = _ref.url,
+            init = _ref.init;
+          return _this2.doFetch(url, init, true);
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Returns a successful response (2**) else throws an error.
+     */
+  }, {
+    key: "doFetch",
+    value: function doFetch(url, init, isBytescaleApi) {
+      try {
+        var _exit3 = false;
+        var _this4 = this;
+        var _a, _b;
+        var response;
+        return _continue(_catch(function () {
+          return _await(BytescaleApiClientConfigUtils.getFetchApi(_this4.config)(url, init), 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(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 (isBytescaleApi) {
+              var jsonError = undefined;
+              return _continue(_catch(function () {
+                return _await(response.json(), function (_response$json) {
+                  jsonError = _response$json;
+                });
+              }, _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);
+      }
+    }
+  }, {
+    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 _this6 = this;
+        var url = (baseUrlOverride !== null && baseUrlOverride !== void 0 ? baseUrlOverride : BytescaleApiClientConfigUtils.getApiUrl(_this6.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 = _this6.config.headers;
+        var _Object$assign3 = Object.assign({}, context.headers);
+        return _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 _await(initOverrides);
+          };
+          var initParams = {
+            method: context.method,
+            headers: headers,
+            body: context.body
+          };
+          var _Object$assign2 = Object.assign({}, initParams);
+          return _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);
+      }
+    }
+  }]);
+  return BaseAPI;
+}();
+var CancelledError = /*#__PURE__*/function (_Error) {
+  _inherits(CancelledError, _Error);
+  var _super = _createSuper(CancelledError);
+  function CancelledError() {
+    var _this7;
+    runtime_classCallCheck(this, CancelledError);
+    _this7 = _super.call(this, "Operation cancelled by caller.");
+    _this7.name = "CancelledError";
+    return _this7;
+  }
+  return runtime_createClass(CancelledError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+var BytescaleApiError = /*#__PURE__*/function (_Error2) {
+  _inherits(BytescaleApiError, _Error2);
+  var _super2 = _createSuper(BytescaleApiError);
+  function BytescaleApiError(response) {
+    var _this8;
+    runtime_classCallCheck(this, BytescaleApiError);
+    _this8 = _super2.call(this, response.error.message);
+    _this8.name = "BytescaleApiError";
+    _this8.errorCode = response.error.code;
+    _this8.details = response.error.details;
+    return _this8;
+  }
+  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 _this10 = this;
+        return _await(_this10.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 _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 _this12 = this;
+        return _await(_this12.raw.text());
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "blob",
+    value: function blob() {
+      try {
+        var _this14 = this;
+        return _await(_this14.raw.blob());
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "json",
+    value: function json() {
+      try {
+        var _this16 = this;
+        return _await(_this16.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 libs 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(config) {
+    UrlBuilder_classCallCheck(this, UrlBuilder);
+    var _a;
+    this.cdnUrl = (_a = config === null || config === void 0 ? void 0 : config.cdnUrl) !== null && _a !== void 0 ? _a : BytescaleApiClientConfigUtils.defaultCdnUrl;
+  }
+  /**
+   * 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" } } })
+   */
+  UrlBuilder_createClass(UrlBuilder, [{
+    key: "url",
+    value: 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) {
+      return "".concat(this.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 libs 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 _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 _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 _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 _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 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);
+  }
+  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 onProgress = _this2.makeProgressCallback(request, preUploadInfo.size);
+        var init = _this2.preUpload(source);
+        // Raise initial progress event SYNCHRONOUSLY.
+        onProgress(0);
+        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(_finallyRethrows(function () {
+            return UploadManagerBase_await(_this2.mapAsync(parts, preUploadInfo.maxConcurrentUploadParts, _async(function (part) {
+              return _this2.uploadPart(request, source, part, uploadInfo, onProgress, addCancellationHandler);
+            })), function () {
+              return _awaitIgnored(_this2.postUpload(init));
+            });
+          }, function (_wasThrown, _result) {
+            clearInterval(intervalHandle);
+            return _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
+      };
+    }
+  }, {
+    key: "makeProgressCallback",
+    value: function makeProgressCallback(request, bytesTotal) {
+      var onProgress = request.onProgress;
+      if (onProgress === undefined) {
+        return function () {};
+      }
+      var bytesSent = 0;
+      return function (bytesSentDelta) {
+        bytesSent += bytesSentDelta;
+        onProgress({
+          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 _this5 = this;
+        return UploadManagerBase_await(_this5.uploadApi.beginMultipartUpload({
+          accountId: request.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 _this7 = this;
+        _this7.assertNotCancelled(request);
+        return UploadManagerBase_await(_this7.getUploadPart(request, partIndex, uploadInfo), function (part) {
+          _this7.assertNotCancelled(request);
+          return UploadManagerBase_await(_this7.putUploadPart(part, source, onProgress, addCancellationHandler), function (etag) {
+            _this7.assertNotCancelled(request);
+            return _awaitIgnored(_this7.uploadApi.completeUploadPart({
+              accountId: request.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 _this9 = this;
+        var contentLength = part.range.inclusiveEnd + 1 - part.range.inclusiveStart;
+        return UploadManagerBase_await(_this9.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.");
+          }
+          return etag;
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "getUploadPart",
+    value: function getUploadPart(request, partIndex, uploadInfo) {
+      try {
+        var _this11 = this;
+        if (partIndex === 0) {
+          return uploadInfo.uploadParts.first;
+        }
+        return UploadManagerBase_await(_this11.uploadApi.getUploadPart({
+          uploadId: uploadInfo.uploadId,
+          accountId: request.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 _awaitIgnored(Promise.all(UploadManagerBase_toConsumableArray(Array(concurrency).keys()).map(_async(function () {
+          return _continueIgnored(_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 _awaitIgnored(callback(work));
+              }
+            });
+          }));
+        }))));
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return UploadManagerBase;
+}();
+;// CONCATENATED MODULE: external "stream"
+var x = y => { var x = {}; __lib_require__.d(x, y); return x; }
+var y = x => () => x
+var external_stream_namespaceObject = x({ ["Readable"]: () => __WEBPACK_EXTERNAL_MODULE_stream__.Readable });
+;// CONCATENATED MODULE: ./src/private/StreamUtils.ts
+function StreamUtils_typeof(obj) { "@babel/helpers - typeof"; return StreamUtils_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; }, StreamUtils_typeof(obj); }
+function StreamUtils_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function StreamUtils_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, StreamUtils_toPropertyKey(descriptor.key), descriptor); } }
+function StreamUtils_createClass(Constructor, protoProps, staticProps) { if (protoProps) StreamUtils_defineProperties(Constructor.prototype, protoProps); if (staticProps) StreamUtils_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function StreamUtils_toPropertyKey(arg) { var key = StreamUtils_toPrimitive(arg, "string"); return StreamUtils_typeof(key) === "symbol" ? key : String(key); }
+function StreamUtils_toPrimitive(input, hint) { if (StreamUtils_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (StreamUtils_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+var StreamUtils = /*#__PURE__*/function () {
+  function StreamUtils() {
+    StreamUtils_classCallCheck(this, StreamUtils);
+  }
+  StreamUtils_createClass(StreamUtils, null, [{
+    key: "create",
+    value: function create() {
+      var readable = new external_stream_namespaceObject.Readable();
+      readable._read = function () {}; // _read is required but you can noop it
+      return readable;
+    }
+  }, {
+    key: "empty",
+    value: function empty() {
+      var readable = StreamUtils.create();
+      StreamUtils.endStream(readable);
+      return readable;
+    }
+  }, {
+    key: "fromBuffer",
+    value: function fromBuffer(buffer) {
+      var readable = StreamUtils.create();
+      readable.push(buffer);
+      StreamUtils.endStream(readable);
+      return readable;
+    }
+  }, {
+    key: "endStream",
+    value: function endStream(readable) {
+      readable.push(null);
+    }
+  }]);
+  return StreamUtils;
+}();
+;// CONCATENATED MODULE: ./src/private/NodeChunkedStream.ts
+function NodeChunkedStream_typeof(obj) { "@babel/helpers - typeof"; return NodeChunkedStream_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; }, NodeChunkedStream_typeof(obj); }
+function NodeChunkedStream_slicedToArray(arr, i) { return NodeChunkedStream_arrayWithHoles(arr) || NodeChunkedStream_iterableToArrayLimit(arr, i) || NodeChunkedStream_unsupportedIterableToArray(arr, i) || NodeChunkedStream_nonIterableRest(); }
+function NodeChunkedStream_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 NodeChunkedStream_unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return NodeChunkedStream_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 NodeChunkedStream_arrayLikeToArray(o, minLen); }
+function NodeChunkedStream_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 NodeChunkedStream_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 NodeChunkedStream_arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function NodeChunkedStream_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 NodeChunkedStream_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function NodeChunkedStream_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, NodeChunkedStream_toPropertyKey(descriptor.key), descriptor); } }
+function NodeChunkedStream_createClass(Constructor, protoProps, staticProps) { if (protoProps) NodeChunkedStream_defineProperties(Constructor.prototype, protoProps); if (staticProps) NodeChunkedStream_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function NodeChunkedStream_toPropertyKey(arg) { var key = NodeChunkedStream_toPrimitive(arg, "string"); return NodeChunkedStream_typeof(key) === "symbol" ? key : String(key); }
+function NodeChunkedStream_toPrimitive(input, hint) { if (NodeChunkedStream_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (NodeChunkedStream_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+/**
+ * For Node.js streams only:
+ *
+ * Converts a stream into a stream of streams, where the next stream is requested via '.take(sizeInBytes: number): Stream'
+ *
+ * This allows the source stream to be sequentially read (in serial) as a sequence of sub-streams, for the purpose of
+ * issuing PutObject requests for a multipart upload, whereby each request requires its own stream, but where that stream
+ * needs to be a slice of the source stream.
+ */
+var NodeChunkedStream = /*#__PURE__*/function () {
+  function NodeChunkedStream(source) {
+    NodeChunkedStream_classCallCheck(this, NodeChunkedStream);
+    this.source = source;
+    this.buffer = Buffer.alloc(0);
+    this.isSourceFullyConsumed = false; // true if the source stream indicates it has finished.
+    this.isFinishedConsuming = false; // true if _we_ indicate we have finished reading all we want from the stream.
+    this.resolver = undefined;
+  }
+  /**
+   * If the source stream is larger than the 'size' the user is consuming (i.e. they're only wanting to upload a subset
+   * of the stream) then the stream won't be resolved by the 'end' event inside 'runChunkPipeline', so calling this
+   * method is necessary.
+   */
+  NodeChunkedStream_createClass(NodeChunkedStream, [{
+    key: "finishedConsuming",
+    value: function finishedConsuming() {
+      this.isFinishedConsuming = true;
+      if (this.resolver !== undefined) {
+        this.resolver();
+      }
+    }
+    /**
+     * Promise resolves when the entire stream has finished processing, or an error occurs.
+     * You must call 'take' a sufficient number of times after calling this method in order for this promise to resolve.
+     */
+  }, {
+    key: "runChunkPipeline",
+    value: function runChunkPipeline() {
+      try {
+        var _this2 = this;
+        return NodeChunkedStream_await(new Promise(function (resolve, reject) {
+          _this2.resolver = resolve;
+          var onError = function onError(error) {
+            removeListeners();
+            reject(error);
+          };
+          var onEnd = function onEnd() {
+            _this2.isSourceFullyConsumed = true;
+            removeListeners();
+            resolve();
+          };
+          var onData = function onData(buffer) {
+            try {
+              if (_this2.isFinishedConsuming) {
+                return;
+              }
+              if (_this2.consumer === undefined) {
+                console.warn("Stream yielded data while paused. The data will be buffered, but excessive buffering can cause memory issues.");
+                _this2.buffer = Buffer.concat([_this2.buffer, buffer]);
+                return;
+              }
+              if (_this2.consumer.bytesRemaining <= 0) {
+                throw new Error("Consumer requires zero bytes, so should not be consuming from the stream.");
+              }
+              if (_this2.buffer.byteLength > 0) {
+                throw new Error("Buffer was expected to be empty (as it should have been flushed to the consumer when '.take' was called).");
+              }
+              var splitResult = _this2.splitBuffer(buffer, _this2.consumer.bytesRemaining);
+              if (splitResult === undefined) {
+                return; // Received empty data.
+              }
+
+              var _splitResult = NodeChunkedStream_slicedToArray(splitResult, 2),
+                consumed = _splitResult[0],
+                remaining = _splitResult[1];
+              _this2.buffer = remaining;
+              _this2.consumer.bytesRemaining -= consumed.byteLength;
+              _this2.consumer.stream.push(consumed);
+              if (_this2.consumer.bytesRemaining === 0) {
+                StreamUtils.endStream(_this2.consumer.stream);
+                _this2.consumer = undefined;
+                _this2.source.pause();
+              }
+            } catch (e) {
+              removeListeners();
+              reject(e);
+            }
+          };
+          var removeListeners = function removeListeners() {
+            _this2.source.removeListener("data", onData);
+            _this2.source.removeListener("error", onError);
+            _this2.source.removeListener("end", onEnd);
+          };
+          _this2.source.on("data", onData);
+          _this2.source.on("error", onError);
+          _this2.source.on("end", onEnd);
+          _this2.source.pause(); // Resumed when 'take' is called.
+        }));
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Only call 'take' after the previously returned stream has been fully consumed.
+     */
+  }, {
+    key: "take",
+    value: function take(bytes) {
+      var _a;
+      if (this.consumer !== undefined) {
+        throw new Error("The stream from the previous 'take' call must be fully consumed before calling 'take' again.");
+      }
+      if (bytes <= 0) {
+        return StreamUtils.empty();
+      }
+      var readable = StreamUtils.create();
+      var consumedFromBuffer = this.consumeFromBuffer(bytes);
+      var consumedFromBufferLength = (_a = consumedFromBuffer === null || consumedFromBuffer === void 0 ? void 0 : consumedFromBuffer.length) !== null && _a !== void 0 ? _a : 0;
+      var bytesToConsumeFromStream = bytes - consumedFromBufferLength;
+      if (consumedFromBuffer !== undefined) {
+        readable.push(consumedFromBuffer);
+      }
+      if (bytesToConsumeFromStream > 0) {
+        if (this.isSourceFullyConsumed) {
+          throw new Error("Stream finished processing earlier than expected. The \"size\" parameter is likely larger than the stream's actual contents.");
+        }
+        this.consumer = {
+          bytesRemaining: bytesToConsumeFromStream,
+          stream: readable
+        };
+        this.source.resume();
+      } else {
+        StreamUtils.endStream(readable);
+      }
+      return readable;
+    }
+  }, {
+    key: "consumeFromBuffer",
+    value: function consumeFromBuffer(bytes) {
+      var splitResult = this.splitBuffer(this.buffer, bytes);
+      if (splitResult === undefined) {
+        return undefined;
+      }
+      var _splitResult2 = NodeChunkedStream_slicedToArray(splitResult, 2),
+        consumed = _splitResult2[0],
+        remaining = _splitResult2[1];
+      this.buffer = remaining;
+      return consumed;
+    }
+  }, {
+    key: "splitBuffer",
+    value: function splitBuffer(buffer, maxBytes) {
+      if (buffer.byteLength === 0) {
+        return undefined;
+      }
+      var bytesToConsume = Math.min(maxBytes, buffer.byteLength);
+      if (bytesToConsume === buffer.byteLength) {
+        return [buffer, Buffer.alloc(0)]; // Optimization
+      }
+
+      var consumed = buffer.subarray(0, bytesToConsume);
+      var remaining = buffer.subarray(bytesToConsume);
+      return [consumed, remaining];
+    }
+  }]);
+  return NodeChunkedStream;
+}();
+;// CONCATENATED MODULE: external "buffer"
+var external_buffer_x = y => { var x = {}; __lib_require__.d(x, y); return x; }
+var external_buffer_y = x => () => x
+var external_buffer_namespaceObject = external_buffer_x({ ["Blob"]: () => __WEBPACK_EXTERNAL_MODULE_buffer__.Blob });
+;// CONCATENATED MODULE: ./src/public/node/UploadManagerNode.ts
+function UploadManagerNode_typeof(obj) { "@babel/helpers - typeof"; return UploadManagerNode_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; }, UploadManagerNode_typeof(obj); }
+function UploadManagerNode_empty() {}
+function UploadManagerNode_awaitIgnored(value, direct) {
+  if (!direct) {
+    return value && value.then ? value.then(UploadManagerNode_empty) : Promise.resolve();
+  }
+}
+function UploadManagerNode_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 UploadManagerNode_settle(pact, state, value) {
+  if (!pact.s) {
+    if (value instanceof UploadManagerNode_Pact) {
+      if (value.s) {
+        if (state & 1) {
+          state = value.s;
+        }
+        value = value.v;
+      } else {
+        value.o = UploadManagerNode_settle.bind(null, pact, state);
+        return;
+      }
+    }
+    if (value && value.then) {
+      value.then(UploadManagerNode_settle.bind(null, pact, state), UploadManagerNode_settle.bind(null, pact, 2));
+      return;
+    }
+    pact.s = state;
+    pact.v = value;
+    var observer = pact.o;
+    if (observer) {
+      observer(pact);
+    }
+  }
+}
+var UploadManagerNode_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 {
+          UploadManagerNode_settle(result, 1, callback(this.v));
+        } catch (e) {
+          UploadManagerNode_settle(result, 2, e);
+        }
+        return result;
+      } else {
+        return this;
+      }
+    }
+    this.o = function (_this) {
+      try {
+        var value = _this.v;
+        if (_this.s & 1) {
+          UploadManagerNode_settle(result, 1, onFulfilled ? onFulfilled(value) : value);
+        } else if (onRejected) {
+          UploadManagerNode_settle(result, 1, onRejected(value));
+        } else {
+          UploadManagerNode_settle(result, 2, value);
+        }
+      } catch (e) {
+        UploadManagerNode_settle(result, 2, e);
+      }
+    };
+    return result;
+  };
+  return _Pact;
+}();
+function _switch(discriminant, cases) {
+  var dispatchIndex = -1;
+  var awaitBody;
+  outer: {
+    for (var i = 0; i < cases.length; i++) {
+      var test = cases[i][0];
+      if (test) {
+        var testValue = test();
+        if (testValue && testValue.then) {
+          break outer;
+        }
+        if (testValue === discriminant) {
+          dispatchIndex = i;
+          break;
+        }
+      } else {
+        // Found the default case, set it as the pending dispatch case
+        dispatchIndex = i;
+      }
+    }
+    if (dispatchIndex !== -1) {
+      do {
+        var body = cases[dispatchIndex][1];
+        while (!body) {
+          dispatchIndex++;
+          body = cases[dispatchIndex][1];
+        }
+        var result = body();
+        if (result && result.then) {
+          awaitBody = true;
+          break outer;
+        }
+        var fallthroughCheck = cases[dispatchIndex][2];
+        dispatchIndex++;
+      } while (fallthroughCheck && !fallthroughCheck());
+      return result;
+    }
+  }
+  var pact = new UploadManagerNode_Pact();
+  var reject = UploadManagerNode_settle.bind(null, pact, 2);
+  (awaitBody ? result.then(_resumeAfterBody) : testValue.then(_resumeAfterTest)).then(void 0, reject);
+  return pact;
+  function _resumeAfterTest(value) {
+    for (;;) {
+      if (value === discriminant) {
+        dispatchIndex = i;
+        break;
+      }
+      if (++i === cases.length) {
+        if (dispatchIndex !== -1) {
+          break;
+        } else {
+          UploadManagerNode_settle(pact, 1, result);
+          return;
+        }
+      }
+      test = cases[i][0];
+      if (test) {
+        value = test();
+        if (value && value.then) {
+          value.then(_resumeAfterTest).then(void 0, reject);
+          return;
+        }
+      } else {
+        dispatchIndex = i;
+      }
+    }
+    do {
+      var body = cases[dispatchIndex][1];
+      while (!body) {
+        dispatchIndex++;
+        body = cases[dispatchIndex][1];
+      }
+      var result = body();
+      if (result && result.then) {
+        result.then(_resumeAfterBody).then(void 0, reject);
+        return;
+      }
+      var fallthroughCheck = cases[dispatchIndex][2];
+      dispatchIndex++;
+    } while (fallthroughCheck && !fallthroughCheck());
+    UploadManagerNode_settle(pact, 1, result);
+  }
+  function _resumeAfterBody(result) {
+    for (;;) {
+      var fallthroughCheck = cases[dispatchIndex][2];
+      if (!fallthroughCheck || fallthroughCheck()) {
+        break;
+      }
+      dispatchIndex++;
+      var body = cases[dispatchIndex][1];
+      while (!body) {
+        dispatchIndex++;
+        body = cases[dispatchIndex][1];
+      }
+      result = body();
+      if (result && result.then) {
+        result.then(_resumeAfterBody).then(void 0, reject);
+        return;
+      }
+    }
+    UploadManagerNode_settle(pact, 1, result);
+  }
+}
+function UploadManagerNode_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function UploadManagerNode_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, UploadManagerNode_toPropertyKey(descriptor.key), descriptor); } }
+function UploadManagerNode_createClass(Constructor, protoProps, staticProps) { if (protoProps) UploadManagerNode_defineProperties(Constructor.prototype, protoProps); if (staticProps) UploadManagerNode_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function UploadManagerNode_toPropertyKey(arg) { var key = UploadManagerNode_toPrimitive(arg, "string"); return UploadManagerNode_typeof(key) === "symbol" ? key : String(key); }
+function UploadManagerNode_toPrimitive(input, hint) { if (UploadManagerNode_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UploadManagerNode_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function UploadManagerNode_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) UploadManagerNode_setPrototypeOf(subClass, superClass); }
+function UploadManagerNode_setPrototypeOf(o, p) { UploadManagerNode_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return UploadManagerNode_setPrototypeOf(o, p); }
+function UploadManagerNode_createSuper(Derived) { var hasNativeReflectConstruct = UploadManagerNode_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = UploadManagerNode_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = UploadManagerNode_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return UploadManagerNode_possibleConstructorReturn(this, result); }; }
+function UploadManagerNode_possibleConstructorReturn(self, call) { if (call && (UploadManagerNode_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 UploadManagerNode_assertThisInitialized(self); }
+function UploadManagerNode_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function UploadManagerNode_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 UploadManagerNode_getPrototypeOf(o) { UploadManagerNode_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return UploadManagerNode_getPrototypeOf(o); }
+
+
+
+
+
+var UploadManager = /*#__PURE__*/function (_UploadManagerBase) {
+  UploadManagerNode_inherits(UploadManager, _UploadManagerBase);
+  var _super = UploadManagerNode_createSuper(UploadManager);
+  function UploadManager() {
+    UploadManagerNode_classCallCheck(this, UploadManager);
+    return _super.apply(this, arguments);
+  }
+  UploadManagerNode_createClass(UploadManager, [{
+    key: "processUploadSource",
+    value: function processUploadSource(data) {
+      if (typeof data === "string") {
+        // 'Blob' must be from 'buffer' as we're in a node context here, so isn't globally available.
+        return {
+          type: "Blob",
+          value: new external_buffer_namespaceObject.Blob([data], {
+            type: this.stringMimeType
+          })
+        };
+      }
+      if (data.on !== undefined) {
+        return {
+          type: "Stream",
+          value: new NodeChunkedStream(data)
+        };
+      }
+      if (data.subarray !== undefined) {
+        return {
+          type: "Buffer",
+          value: data
+        };
+      }
+      if (data.size !== undefined) {
+        return {
+          type: "Blob",
+          value: data
+        };
+      }
+      throw new Error("Unsupported type for 'data' parameter. Please provide a String, Blob, or Readable (Node.js).");
+    }
+  }, {
+    key: "getPreUploadInfoPartial",
+    value: function getPreUploadInfoPartial(request, data) {
+      switch (data.type) {
+        case "Blob":
+          return this.getBlobInfo(data);
+        case "Buffer":
+          return {
+            mime: undefined,
+            size: data.value.length,
+            originalFileName: undefined,
+            maxConcurrentUploadParts: undefined
+          };
+        case "Stream":
+          if (request.size === undefined) {
+            throw new Error("You must include the 'size' parameter when using a stream for the 'data' parameter.");
+          }
+          return {
+            mime: undefined,
+            size: request.size,
+            originalFileName: undefined,
+            maxConcurrentUploadParts: 1 // Uploading from a stream concurrently is complex, so we serialize it.
+          };
+
+        default:
+          assertUnreachable(data);
+      }
+    }
+  }, {
+    key: "preUpload",
+    value: function preUpload(source) {
+      if (source.type !== "Stream") {
+        return undefined;
+      }
+      var chunkedStream = source.value;
+      var chunkedStreamPromise = chunkedStream.runChunkPipeline();
+      return {
+        chunkedStreamPromise: chunkedStreamPromise,
+        chunkedStream: chunkedStream
+      };
+    }
+  }, {
+    key: "postUpload",
+    value: function postUpload(init) {
+      try {
+        if (init === undefined) {
+          return;
+        }
+        init.chunkedStream.finishedConsuming();
+        // Raise any errors from the stream chunking task.
+        return UploadManagerNode_awaitIgnored(init.chunkedStreamPromise);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "doPutUploadPart",
+    value: function doPutUploadPart(part, contentLength, source, onProgress, addCancellationHandler) {
+      try {
+        var _this2 = this;
+        var _a, _b;
+        var fetchApi = (_a = _this2.config.fetchApi) !== null && _a !== void 0 ? _a : fetch;
+        var headers = {
+          // Required to prevent fetch using "Transfer-Encoding: Chunked" when body is a stream.
+          "content-length": contentLength.toString()
+        };
+        // Configure cancellation:
+        var controller = new AbortController();
+        var signal = controller.signal;
+        addCancellationHandler(function () {
+          return controller.abort();
+        });
+        // Report progress:
+        var hasWarned = false;
+        return UploadManagerNode_await(_this2.sliceDataForRequest(source, part), function (stream) {
+          var streamWithProgress = stream.on("data", function (data) {
+            if (data.length !== undefined) {
+              onProgress(data.length);
+            } else if (!hasWarned) {
+              hasWarned = true;
+              console.warn("Expected stream to contain buffers, but it did not, so upload progress won't be reported.");
+            }
+          });
+          return UploadManagerNode_await(fetchApi(part.uploadUrl, {
+            method: "PUT",
+            headers: headers,
+            body: _this2.coerceRequestBody(streamWithProgress),
+            signal: signal
+          }), function (response) {
+            return {
+              etag: (_b = response.headers.get("etag")) !== null && _b !== void 0 ? _b : undefined,
+              status: response.status
+            };
+          });
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }, {
+    key: "coerceRequestBody",
+    value: function coerceRequestBody(data) {
+      return data; // node-fetch supports 'NodeJS.ReadableStream'
+    }
+  }, {
+    key: "sliceDataForRequest",
+    value: function sliceDataForRequest(data, part) {
+      try {
+        if (part.range.inclusiveEnd === -1) {
+          return StreamUtils.empty();
+        }
+        var start = part.range.inclusiveStart;
+        var endExclusive = part.range.inclusiveEnd + 1;
+        var partSize = endExclusive - start;
+        return _switch(data.type, [[function () {
+          return "Blob";
+        }, function () {
+          var _fromBuffer = StreamUtils.fromBuffer,
+            _Buffer = Buffer,
+            _from = _Buffer.from;
+          return UploadManagerNode_await(data.value.slice(start, endExclusive).arrayBuffer(), function (_data$value$slice$arr) {
+            return _fromBuffer.call(StreamUtils, _from.call(_Buffer, _data$value$slice$arr));
+          });
+        }], [function () {
+          return "Buffer";
+        }, function () {
+          return StreamUtils.fromBuffer(data.value.subarray(start, endExclusive));
+        }], [function () {
+          return "Stream";
+        }, function () {
+          return data.value.take(partSize);
+        }], [void 0, function () {
+          assertUnreachable(data);
+        }, UploadManagerNode_empty]]);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return UploadManager;
+}(UploadManagerBase);
+;// 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: "isNodeJs",
+    value: function isNodeJs() {
+      return typeof process !== "undefined" && process.versions !== undefined && process.versions.node !== undefined;
+    }
+  }, {
+    key: "methodRequiresBrowser",
+    value: function methodRequiresBrowser(methodName) {
+      if (EnvChecker.isNodeJs()) {
+        return new Error("You must call '".concat(methodName, "' in the browser. (You are currently in Node.js.)"));
+      }
+      return new Error("The '".concat(methodName, "' method cannot be called because you have bundled the Node.js 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 AuthManager = /*#__PURE__*/function () {
+  function AuthManager() {
+    AuthManagerNode_classCallCheck(this, AuthManager);
+  }
+  AuthManagerNode_createClass(AuthManager, [{
+    key: "beginAuthSession",
+    value: function beginAuthSession(_authUrl, _authHeaders) {
+      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 AuthManager;
+}();
+;// CONCATENATED MODULE: ./src/public/node/index.ts
+
+
+;// CONCATENATED MODULE: ./src/index.node.ts
+/* tslint:disable */
+/* eslint-disable */
+
+
+var __lib_exports__AuthManager = __lib_exports__.AuthManager;
+var __lib_exports__BaseAPI = __lib_exports__.BaseAPI;
+var __lib_exports__BinaryResult = __lib_exports__.BinaryResult;
+var __lib_exports__BytescaleApiClientConfigUtils = __lib_exports__.BytescaleApiClientConfigUtils;
+var __lib_exports__BytescaleApiError = __lib_exports__.BytescaleApiError;
+var __lib_exports__CancelledError = __lib_exports__.CancelledError;
+var __lib_exports__CommonTypesNoOp = __lib_exports__.CommonTypesNoOp;
+var __lib_exports__FileApi = __lib_exports__.FileApi;
+var __lib_exports__FolderApi = __lib_exports__.FolderApi;
+var __lib_exports__JSONApiResponse = __lib_exports__.JSONApiResponse;
+var __lib_exports__JobApi = __lib_exports__.JobApi;
+var __lib_exports__UploadApi = __lib_exports__.UploadApi;
+var __lib_exports__UploadManager = __lib_exports__.UploadManager;
+var __lib_exports__UrlBuilder = __lib_exports__.UrlBuilder;
+var __lib_exports__UrlBuilderTypesNoOp = __lib_exports__.UrlBuilderTypesNoOp;
+var __lib_exports__VoidApiResponse = __lib_exports__.VoidApiResponse;
+var __lib_exports__querystring = __lib_exports__.querystring;
+export { __lib_exports__AuthManager as AuthManager, __lib_exports__BaseAPI as BaseAPI, __lib_exports__BinaryResult as BinaryResult, __lib_exports__BytescaleApiClientConfigUtils as BytescaleApiClientConfigUtils, __lib_exports__BytescaleApiError as BytescaleApiError, __lib_exports__CancelledError as CancelledError, __lib_exports__CommonTypesNoOp as CommonTypesNoOp, __lib_exports__FileApi as FileApi, __lib_exports__FolderApi as FolderApi, __lib_exports__JSONApiResponse as JSONApiResponse, __lib_exports__JobApi as JobApi, __lib_exports__UploadApi as UploadApi, __lib_exports__UploadManager as UploadManager, __lib_exports__UrlBuilder as UrlBuilder, __lib_exports__UrlBuilderTypesNoOp as UrlBuilderTypesNoOp, __lib_exports__VoidApiResponse as VoidApiResponse, __lib_exports__querystring as querystring };