@bytescale/sdk 3.0.0-alpha.12 → 3.0.0-alpha.14

package/dist/node/esm/main.mjs

@@ -1,25 +1,3 @@
-// ----------------------------------------
-// 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
@@ -2053,10 +2031,13 @@ var UploadManagerBase = /*#__PURE__*/function () {
         _this2.assertNotCancelled(request);
         var source = _this2.processUploadSource(request.data);
         var preUploadInfo = _this2.getPreUploadInfo(request, source);
-        var onProgress = _this2.makeProgressCallback(request, preUploadInfo.size);
+        var bytesTotal = preUploadInfo.size;
+        var makeOnProgressForPart = _this2.makeOnProgressForPartFactory(request, bytesTotal);
         var init = _this2.preUpload(source);
         // Raise initial progress event SYNCHRONOUSLY.
-        onProgress(0);
+        if (request.onProgress !== undefined) {
+          request.onProgress(_this2.makeProgressEvent(0, bytesTotal));
+        }
         return UploadManagerBase_await(_this2.beginUpload(request, preUploadInfo), function (uploadInfo) {
           var partCount = uploadInfo.uploadParts.count;
           var parts = UploadManagerBase_toConsumableArray(Array(partCount).keys());
@@ -2066,7 +2047,7 @@ var UploadManagerBase = /*#__PURE__*/function () {
           var intervalHandle = setInterval(_this2.onIntervalTick(request, cancel), _this2.intervalMs);
           return UploadManagerBase_continue(UploadManagerBase_finallyRethrows(function () {
             return UploadManagerBase_await(_this2.mapAsync(parts, preUploadInfo.maxConcurrentUploadParts, _async(function (part) {
-              return _this2.uploadPart(request, source, part, uploadInfo, onProgress, addCancellationHandler);
+              return _this2.uploadPart(request, source, part, uploadInfo, makeOnProgressForPart(), addCancellationHandler);
             })), function () {
               return UploadManagerBase_awaitIgnored(_this2.postUpload(init));
             });
@@ -2122,21 +2103,37 @@ var UploadManagerBase = /*#__PURE__*/function () {
         addCancellationHandler: addCancellationHandler
       };
     }
+    /**
+     * Returns a callback, which when called, returns a callback that can be used by ONE specific part to report its progress.
+     */
   }, {
-    key: "makeProgressCallback",
-    value: function makeProgressCallback(request, bytesTotal) {
+    key: "makeOnProgressForPartFactory",
+    value: function makeOnProgressForPartFactory(request, bytesTotal) {
+      var _this4 = this;
       var onProgress = request.onProgress;
       if (onProgress === undefined) {
-        return function () {};
+        return function () {
+          return function () {};
+        };
       }
       var bytesSent = 0;
-      return function (bytesSentDelta) {
-        bytesSent += bytesSentDelta;
-        onProgress({
-          bytesTotal: bytesTotal,
-          bytesSent: bytesSent,
-          progress: Math.round(bytesSent / bytesTotal * 100)
-        });
+      return function () {
+        var bytesSentForPart = 0;
+        return function (bytesSentTotalForPart) {
+          var delta = bytesSentTotalForPart - bytesSentForPart;
+          bytesSentForPart += delta;
+          bytesSent += delta;
+          onProgress(_this4.makeProgressEvent(bytesSent, bytesTotal));
+        };
+      };
+    }
+  }, {
+    key: "makeProgressEvent",
+    value: function makeProgressEvent(bytesSent, bytesTotal) {
+      return {
+        bytesTotal: bytesTotal,
+        bytesSent: bytesSent,
+        progress: Math.round(bytesSent / bytesTotal * 100)
       };
     }
   }, {
@@ -2159,9 +2156,9 @@ var UploadManagerBase = /*#__PURE__*/function () {
         mime = _ref2.mime,
         originalFileName = _ref2.originalFileName;
       try {
-        var _this5 = this;
-        return UploadManagerBase_await(_this5.uploadApi.beginMultipartUpload({
-          accountId: _this5.accountId,
+        var _this6 = this;
+        return UploadManagerBase_await(_this6.uploadApi.beginMultipartUpload({
+          accountId: _this6.accountId,
           beginMultipartUploadRequest: {
             metadata: request.metadata,
             mime: mime,
@@ -2180,14 +2177,14 @@ var UploadManagerBase = /*#__PURE__*/function () {
     key: "uploadPart",
     value: function uploadPart(request, source, partIndex, uploadInfo, onProgress, addCancellationHandler) {
       try {
-        var _this7 = this;
-        _this7.assertNotCancelled(request);
-        return UploadManagerBase_await(_this7.getUploadPart(partIndex, uploadInfo), function (part) {
-          _this7.assertNotCancelled(request);
-          return UploadManagerBase_await(_this7.putUploadPart(part, source, onProgress, addCancellationHandler), function (etag) {
-            _this7.assertNotCancelled(request);
-            return UploadManagerBase_awaitIgnored(_this7.uploadApi.completeUploadPart({
-              accountId: _this7.accountId,
+        var _this8 = this;
+        _this8.assertNotCancelled(request);
+        return UploadManagerBase_await(_this8.getUploadPart(partIndex, uploadInfo), function (part) {
+          _this8.assertNotCancelled(request);
+          return UploadManagerBase_await(_this8.putUploadPart(part, source, onProgress, addCancellationHandler), function (etag) {
+            _this8.assertNotCancelled(request);
+            return UploadManagerBase_awaitIgnored(_this8.uploadApi.completeUploadPart({
+              accountId: _this8.accountId,
               uploadId: uploadInfo.uploadId,
               uploadPartIndex: partIndex,
               completeUploadPartRequest: {
@@ -2207,9 +2204,9 @@ var UploadManagerBase = /*#__PURE__*/function () {
     key: "putUploadPart",
     value: function putUploadPart(part, source, onProgress, addCancellationHandler) {
       try {
-        var _this9 = this;
+        var _this10 = this;
         var contentLength = part.range.inclusiveEnd + 1 - part.range.inclusiveStart;
-        return UploadManagerBase_await(_this9.doPutUploadPart(part, contentLength, source, onProgress, addCancellationHandler), function (_ref3) {
+        return UploadManagerBase_await(_this10.doPutUploadPart(part, contentLength, source, onProgress, addCancellationHandler), function (_ref3) {
           var status = _ref3.status,
             etag = _ref3.etag;
           if (Math.floor(status / 100) !== 2) {
@@ -2218,6 +2215,8 @@ var UploadManagerBase = /*#__PURE__*/function () {
           if (etag === undefined) {
             throw new Error("No 'etag' response header found in upload part response.");
           }
+          // Always send 100% for part, as some UploadManager implementations either don't report progress, or may not report the last chunk uploaded.
+          onProgress(contentLength);
           return etag;
         });
       } catch (e) {
@@ -2228,13 +2227,13 @@ var UploadManagerBase = /*#__PURE__*/function () {
     key: "getUploadPart",
     value: function getUploadPart(partIndex, uploadInfo) {
       try {
-        var _this11 = this;
+        var _this12 = this;
         if (partIndex === 0) {
           return uploadInfo.uploadParts.first;
         }
-        return UploadManagerBase_await(_this11.uploadApi.getUploadPart({
+        return UploadManagerBase_await(_this12.uploadApi.getUploadPart({
           uploadId: uploadInfo.uploadId,
-          accountId: _this11.accountId,
+          accountId: _this12.accountId,
           uploadPartIndex: partIndex
         }));
       } catch (e) {
@@ -2307,6 +2306,11 @@ var StreamUtils = /*#__PURE__*/function () {
       StreamUtils.endStream(readable);
       return readable;
     }
+  }, {
+    key: "fromArrayBuffer",
+    value: function fromArrayBuffer(buffer) {
+      return StreamUtils.fromBuffer(Buffer.from(buffer));
+    }
   }, {
     key: "fromBuffer",
     value: function fromBuffer(buffer) {
@@ -2517,6 +2521,61 @@ var NodeChunkedStream = /*#__PURE__*/function () {
 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/private/UploadManagerFetchUtils.ts
+function UploadManagerFetchUtils_typeof(obj) { "@babel/helpers - typeof"; return UploadManagerFetchUtils_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, UploadManagerFetchUtils_typeof(obj); }
+function UploadManagerFetchUtils_await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function UploadManagerFetchUtils_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function UploadManagerFetchUtils_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, UploadManagerFetchUtils_toPropertyKey(descriptor.key), descriptor); } }
+function UploadManagerFetchUtils_createClass(Constructor, protoProps, staticProps) { if (protoProps) UploadManagerFetchUtils_defineProperties(Constructor.prototype, protoProps); if (staticProps) UploadManagerFetchUtils_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function UploadManagerFetchUtils_toPropertyKey(arg) { var key = UploadManagerFetchUtils_toPrimitive(arg, "string"); return UploadManagerFetchUtils_typeof(key) === "symbol" ? key : String(key); }
+function UploadManagerFetchUtils_toPrimitive(input, hint) { if (UploadManagerFetchUtils_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UploadManagerFetchUtils_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+var UploadManagerFetchUtils = /*#__PURE__*/function () {
+  function UploadManagerFetchUtils() {
+    UploadManagerFetchUtils_classCallCheck(this, UploadManagerFetchUtils);
+  }
+  UploadManagerFetchUtils_createClass(UploadManagerFetchUtils, null, [{
+    key: "doPutUploadPart",
+    value: function doPutUploadPart(config, part, content, contentLength, addCancellationHandler) {
+      try {
+        var _a;
+        var fetchApi = BytescaleApiClientConfigUtils.getFetchApi(config);
+        // Configure cancellation:
+        var controller = new AbortController();
+        var signal = controller.signal;
+        addCancellationHandler(function () {
+          return controller.abort();
+        });
+        var headers = {
+          // Required to prevent fetch using "Transfer-Encoding: Chunked" when body is a stream.
+          "content-length": contentLength.toString()
+        };
+        return UploadManagerFetchUtils_await(fetchApi(part.uploadUrl, {
+          method: "PUT",
+          headers: headers,
+          body: content,
+          signal: signal
+        }), function (response) {
+          return {
+            etag: (_a = response.headers.get("etag")) !== null && _a !== void 0 ? _a : undefined,
+            status: response.status
+          };
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  }]);
+  return UploadManagerFetchUtils;
+}();
 ;// CONCATENATED MODULE: ./src/public/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() {}
@@ -2716,6 +2775,7 @@ function UploadManagerNode_getPrototypeOf(o) { UploadManagerNode_getPrototypeOf
 
 
 
+
 var UploadManager = /*#__PURE__*/function (_UploadManagerBase) {
   UploadManagerNode_inherits(UploadManager, _UploadManagerBase);
   var _super = UploadManagerNode_createSuper(UploadManager);
@@ -2747,13 +2807,19 @@ var UploadManager = /*#__PURE__*/function (_UploadManagerBase) {
           value: data
         };
       }
+      if (data.byteLength !== undefined) {
+        return {
+          type: "ArrayBuffer",
+          value: data
+        };
+      }
       if (data.size !== undefined) {
         return {
           type: "Blob",
           value: data
         };
       }
-      throw new Error("Unsupported type for 'data' parameter. Please provide a String, Blob, or Readable (Node.js).");
+      throw new Error("Unsupported type for 'data' parameter. Please provide a String, Blob, Buffer, ArrayBuffer, or ReadableStream (Node.js).");
     }
   }, {
     key: "getPreUploadInfoPartial",
@@ -2762,9 +2828,10 @@ var UploadManager = /*#__PURE__*/function (_UploadManagerBase) {
         case "Blob":
           return this.getBlobInfo(data);
         case "Buffer":
+        case "ArrayBuffer":
           return {
             mime: undefined,
-            size: data.value.length,
+            size: data.value.byteLength,
             originalFileName: undefined,
             maxConcurrentUploadParts: undefined
           };
@@ -2815,40 +2882,20 @@ var UploadManager = /*#__PURE__*/function (_UploadManagerBase) {
     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;
+        var bytesSent = 0;
         return UploadManagerNode_await(_this2.sliceDataForRequest(source, part), function (stream) {
           var streamWithProgress = stream.on("data", function (data) {
-            if (data.length !== undefined) {
-              onProgress(data.length);
+            if (data.byteLength !== undefined) {
+              bytesSent += data.byteLength;
+              onProgress(bytesSent);
             } 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
-            };
-          });
+          return UploadManagerNode_await(UploadManagerFetchUtils.doPutUploadPart(_this2.config, part, _this2.coerceRequestBody(streamWithProgress), contentLength, addCancellationHandler));
         });
       } catch (e) {
         return Promise.reject(e);
@@ -2872,12 +2919,14 @@ var UploadManager = /*#__PURE__*/function (_UploadManagerBase) {
         return _switch(data.type, [[function () {
           return "Blob";
         }, function () {
-          var _fromBuffer = StreamUtils.fromBuffer,
-            _Buffer = Buffer,
-            _from = _Buffer.from;
+          var _fromArrayBuffer = StreamUtils.fromArrayBuffer;
           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));
+            return _fromArrayBuffer.call(StreamUtils, _data$value$slice$arr);
           });
+        }], [function () {
+          return "ArrayBuffer";
+        }, function () {
+          return StreamUtils.fromArrayBuffer(data.value.slice(start, endExclusive));
         }], [function () {
           return "Buffer";
         }, function () {
@@ -2908,17 +2957,17 @@ var EnvChecker = /*#__PURE__*/function () {
     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: "isBrowser",
+    value: function isBrowser() {
+      return typeof window !== "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.)"));
+      if (!EnvChecker.isBrowser()) {
+        return new Error("You must call '".concat(methodName, "' in your client-side code. (You have called it in your server-side code.)"));
       }
-      return new Error("The '".concat(methodName, "' method cannot be called because you have bundled 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 new Error("The '".concat(methodName, "' method cannot be called because you have bundled a non-browser implementation of the Bytescale JavaScript SDK into your client-side code. Please ensure your bundling tool (Webpack, Rollup, etc.) is honouring the \"browser\" field of the \"package.json\" file for this package, as this will allow the browser implementation of the Bytescale JavaScript SDK to be included in your client-side code."));
     }
   }]);
   return EnvChecker;

package/dist/types/index.worker.d.ts

@@ -0,0 +1,2 @@
+export * from "./public/shared";
+export * from "./public/worker";

package/dist/types/private/EnvChecker.d.ts

@@ -1,4 +1,4 @@
 export declare class EnvChecker {
-    static isNodeJs(): boolean;
+    static isBrowser(): boolean;
     static methodRequiresBrowser(methodName: string): Error;
 }

package/dist/types/private/StreamUtils.d.ts

@@ -3,6 +3,7 @@ import type * as stream from "stream";
 export declare class StreamUtils {
     static create(): stream.Readable;
     static empty(): NodeJS.ReadableStream;
+    static fromArrayBuffer(buffer: ArrayBuffer): NodeJS.ReadableStream;
     static fromBuffer(buffer: Buffer): NodeJS.ReadableStream;
     static endStream(readable: stream.Readable): void;
 }

package/dist/types/private/UploadManagerBase.d.ts

@@ -29,7 +29,11 @@ export declare abstract class UploadManagerBase<TSource, TInit> implements Uploa
     protected abstract doPutUploadPart(part: UploadPart, contentLength: number, source: TSource, onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<PutUploadPartResult>;
     private onIntervalTick;
     private makeCancellationMethods;
-    private makeProgressCallback;
+    /**
+     * Returns a callback, which when called, returns a callback that can be used by ONE specific part to report its progress.
+     */
+    private makeOnProgressForPartFactory;
+    private makeProgressEvent;
     private assertNotCancelled;
     private isCancelled;
     private beginUpload;

package/dist/types/private/UploadManagerBrowserWorkerBase.d.ts

@@ -0,0 +1,19 @@
+import { UploadManagerBase } from "./UploadManagerBase";
+import { UploadSourceProcessedBrowser, UploadSourceProcessedWorker } from "./model/UploadSourceProcessed";
+import { PreUploadInfo } from "./model/PreUploadInfo";
+import { UploadPart } from "../public/shared/generated";
+import { UploadManagerParams, UploadSource } from "../public/shared/CommonTypes";
+declare type BrowserOrWorkerUploadSource = UploadSourceProcessedBrowser | UploadSourceProcessedWorker;
+/**
+ * The "browser" and "worker" runtimes support the same input types, but the former uses XHR and the latter uses Fetch.
+ */
+export declare abstract class UploadManagerBrowserWorkerBase extends UploadManagerBase<BrowserOrWorkerUploadSource, undefined> {
+    protected processUploadSource(data: UploadSource): BrowserOrWorkerUploadSource;
+    protected getPreUploadInfoPartial(_request: UploadManagerParams, data: BrowserOrWorkerUploadSource): Partial<PreUploadInfo> & {
+        size: number;
+    };
+    protected preUpload(_source: BrowserOrWorkerUploadSource): undefined;
+    protected postUpload(_init: undefined): Promise<void>;
+    protected getRequestBody(part: UploadPart, blob: BrowserOrWorkerUploadSource): Blob | ArrayBuffer;
+}
+export {};

package/dist/types/private/UploadManagerFetchUtils.d.ts

@@ -0,0 +1,8 @@
+import { BytescaleApiClientConfig, UploadPart } from "../public/shared";
+import { AddCancellationHandler } from "./model/AddCancellationHandler";
+export declare class UploadManagerFetchUtils {
+    static doPutUploadPart(config: BytescaleApiClientConfig, part: UploadPart, content: BodyInit, contentLength: number, addCancellationHandler: AddCancellationHandler): Promise<{
+        etag: string | undefined;
+        status: number;
+    }>;
+}

package/dist/types/private/model/OnPartProgress.d.ts

@@ -1 +1 @@
-export declare type OnPartProgress = (bytesSentDelta: number) => void;
+export declare type OnPartProgress = (bytesSentTotalForPart: number) => void;

package/dist/types/private/model/UploadSourceProcessed.d.ts

@@ -9,10 +9,15 @@ export interface UploadSourceBuffer {
     type: "Buffer";
     value: Buffer;
 }
+export interface UploadSourceArrayBuffer {
+    type: "ArrayBuffer";
+    value: ArrayBuffer;
+}
 export interface UploadSourceStream {
     type: "Stream";
     value: NodeChunkedStream;
 }
-export declare type UploadSourceProcessedIsomorphic = UploadSourceBlob;
+export declare type UploadSourceProcessedIsomorphic = UploadSourceBlob | UploadSourceArrayBuffer;
 export declare type UploadSourceProcessedBrowser = UploadSourceProcessedIsomorphic;
+export declare type UploadSourceProcessedWorker = UploadSourceProcessedIsomorphic;
 export declare type UploadSourceProcessedNode = UploadSourceStream | UploadSourceBuffer | UploadSourceProcessedIsomorphic;

package/dist/types/public/browser/UploadManagerBrowser.d.ts

@@ -1,17 +1,8 @@
-import { UploadManagerBase } from "../../private/UploadManagerBase";
 import { UploadSourceProcessedBrowser } from "../../private/model/UploadSourceProcessed";
-import { PreUploadInfo } from "../../private/model/PreUploadInfo";
 import { UploadPart } from "../shared/generated";
 import { PutUploadPartResult } from "../../private/model/PutUploadPartResult";
 import { AddCancellationHandler } from "../../private/model/AddCancellationHandler";
-import { UploadManagerParams, UploadSource } from "../shared/CommonTypes";
-export declare class UploadManager extends UploadManagerBase<UploadSourceProcessedBrowser, undefined> {
-    protected processUploadSource(data: UploadSource): UploadSourceProcessedBrowser;
-    protected getPreUploadInfoPartial(_request: UploadManagerParams, data: UploadSourceProcessedBrowser): Partial<PreUploadInfo> & {
-        size: number;
-    };
-    protected preUpload(_source: UploadSourceProcessedBrowser): undefined;
-    protected postUpload(_init: undefined): Promise<void>;
-    protected doPutUploadPart(part: UploadPart, contentLength: number, source: UploadSourceProcessedBrowser, onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<PutUploadPartResult>;
-    private getRequestBody;
+import { UploadManagerBrowserWorkerBase } from "../../private/UploadManagerBrowserWorkerBase";
+export declare class UploadManager extends UploadManagerBrowserWorkerBase {
+    protected doPutUploadPart(part: UploadPart, _contentLength: number, source: UploadSourceProcessedBrowser, onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<PutUploadPartResult>;
 }

package/dist/types/public/worker/UploadManagerWorker.d.ts

@@ -0,0 +1,8 @@
+import { UploadSourceProcessedWorker } from "../../private/model/UploadSourceProcessed";
+import { UploadPart } from "../shared/generated";
+import { PutUploadPartResult } from "../../private/model/PutUploadPartResult";
+import { AddCancellationHandler } from "../../private/model/AddCancellationHandler";
+import { UploadManagerBrowserWorkerBase } from "../../private/UploadManagerBrowserWorkerBase";
+export declare class UploadManager extends UploadManagerBrowserWorkerBase {
+    protected doPutUploadPart(part: UploadPart, contentLength: number, source: UploadSourceProcessedWorker, _onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<PutUploadPartResult>;
+}

package/dist/types/public/worker/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./UploadManagerWorker";
+export * from "../node/AuthManagerNode";