@docbox-nz/hapi-gateway 0.1.0

package/dist/index.browser.cjs

@@ -0,0 +1,988 @@
+'use strict';
+
+var axios = require('axios');
+
+/**
+ * Types of generated files
+ */
+exports.GeneratedFileType = void 0;
+(function (GeneratedFileType) {
+    GeneratedFileType["PDF"] = "Pdf";
+    GeneratedFileType["COVER_PAGE"] = "CoverPage";
+    GeneratedFileType["SMALL_THUMBNAIL"] = "SmallThumbnail";
+    GeneratedFileType["LARGE_THUMBNAIL"] = "LargeThumbnail";
+    GeneratedFileType["TEXT_CONTENT"] = "TextContent";
+    GeneratedFileType["HTML_CONTENT"] = "HtmlContent";
+    GeneratedFileType["METADATA"] = "Metadata";
+})(exports.GeneratedFileType || (exports.GeneratedFileType = {}));
+/**
+ * Statuses that a presigned upload task can have
+ */
+exports.PresignedUploadStatus = void 0;
+(function (PresignedUploadStatus) {
+    PresignedUploadStatus["Pending"] = "Pending";
+    PresignedUploadStatus["Complete"] = "Complete";
+    PresignedUploadStatus["Failed"] = "Failed";
+})(exports.PresignedUploadStatus || (exports.PresignedUploadStatus = {}));
+exports.DocboxTaskStatus = void 0;
+(function (DocboxTaskStatus) {
+    DocboxTaskStatus["Pending"] = "Pending";
+    DocboxTaskStatus["Completed"] = "Completed";
+    DocboxTaskStatus["Failed"] = "Failed";
+})(exports.DocboxTaskStatus || (exports.DocboxTaskStatus = {}));
+
+/**
+ * Possible search result item types
+ */
+exports.SearchResultItemType = void 0;
+(function (SearchResultItemType) {
+    SearchResultItemType["FILE"] = "File";
+    SearchResultItemType["FOLDER"] = "Folder";
+    SearchResultItemType["LINK"] = "Link";
+})(exports.SearchResultItemType || (exports.SearchResultItemType = {}));
+
+exports.EditHistoryType = void 0;
+(function (EditHistoryType) {
+    EditHistoryType["MoveToFolder"] = "MoveToFolder";
+    EditHistoryType["Rename"] = "Rename";
+    EditHistoryType["LinkValue"] = "LinkValue";
+})(exports.EditHistoryType || (exports.EditHistoryType = {}));
+
+exports.DocboxItemType = void 0;
+(function (DocboxItemType) {
+    DocboxItemType["File"] = "File";
+    DocboxItemType["Folder"] = "Folder";
+    DocboxItemType["Link"] = "Link";
+})(exports.DocboxItemType || (exports.DocboxItemType = {}));
+
+function sleep(timeout) {
+    return new Promise((resolve) => setTimeout(resolve, timeout));
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var formdata_min = {};
+
+/*! formdata-polyfill. MIT License. Jimmy W?rting <https://jimmy.warting.se/opensource> */
+
+var hasRequiredFormdata_min;
+
+function requireFormdata_min () {
+	if (hasRequiredFormdata_min) return formdata_min;
+	hasRequiredFormdata_min = 1;
+(function(){var h;function l(a){var b=0;return function(){return b<a.length?{done:false,value:a[b++]}:{done:true}}}var m="function"==typeof Object.defineProperties?Object.defineProperty:function(a,b,c){if(a==Array.prototype||a==Object.prototype)return a;a[b]=c.value;return a};
+	function n(a){a=["object"==typeof globalThis&&globalThis,a,"object"==typeof window&&window,"object"==typeof self&&self,"object"==typeof commonjsGlobal&&commonjsGlobal];for(var b=0;b<a.length;++b){var c=a[b];if(c&&c.Math==Math)return c}throw Error("Cannot find global object");}var q=n(this);function r(a,b){if(b)a:{var c=q;a=a.split(".");for(var d=0;d<a.length-1;d++){var e=a[d];if(!(e in c))break a;c=c[e];}a=a[a.length-1];d=c[a];b=b(d);b!=d&&null!=b&&m(c,a,{configurable:true,writable:true,value:b});}}
+	r("Symbol",function(a){function b(f){if(this instanceof b)throw new TypeError("Symbol is not a constructor");return new c(d+(f||"")+"_"+e++,f)}function c(f,g){this.A=f;m(this,"description",{configurable:true,writable:true,value:g});}if(a)return a;c.prototype.toString=function(){return this.A};var d="jscomp_symbol_"+(1E9*Math.random()>>>0)+"_",e=0;return b});
+	r("Symbol.iterator",function(a){if(a)return a;a=Symbol("Symbol.iterator");for(var b="Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array".split(" "),c=0;c<b.length;c++){var d=q[b[c]];"function"===typeof d&&"function"!=typeof d.prototype[a]&&m(d.prototype,a,{configurable:true,writable:true,value:function(){return u(l(this))}});}return a});function u(a){a={next:a};a[Symbol.iterator]=function(){return this};return a}
+	function v(a){var b="undefined"!=typeof Symbol&&Symbol.iterator&&a[Symbol.iterator];return b?b.call(a):{next:l(a)}}var w;if("function"==typeof Object.setPrototypeOf)w=Object.setPrototypeOf;else {var y;a:{var z={a:true},A={};try{A.__proto__=z;y=A.a;break a}catch(a){}y=false;}w=y?function(a,b){a.__proto__=b;if(a.__proto__!==b)throw new TypeError(a+" is not extensible");return a}:null;}var B=w;function C(){this.m=false;this.j=null;this.v=void 0;this.h=1;this.u=this.C=0;this.l=null;}
+	function D(a){if(a.m)throw new TypeError("Generator is already running");a.m=true;}C.prototype.o=function(a){this.v=a;};C.prototype.s=function(a){this.l={D:a,F:true};this.h=this.C||this.u;};C.prototype.return=function(a){this.l={return:a};this.h=this.u;};function E(a,b){a.h=3;return {value:b}}function F(a){this.g=new C;this.G=a;}F.prototype.o=function(a){D(this.g);if(this.g.j)return G(this,this.g.j.next,a,this.g.o);this.g.o(a);return H(this)};
+	function I(a,b){D(a.g);var c=a.g.j;if(c)return G(a,"return"in c?c["return"]:function(d){return {value:d,done:true}},b,a.g.return);a.g.return(b);return H(a)}F.prototype.s=function(a){D(this.g);if(this.g.j)return G(this,this.g.j["throw"],a,this.g.o);this.g.s(a);return H(this)};
+	function G(a,b,c,d){try{var e=b.call(a.g.j,c);if(!(e instanceof Object))throw new TypeError("Iterator result "+e+" is not an object");if(!e.done)return a.g.m=!1,e;var f=e.value;}catch(g){return a.g.j=null,a.g.s(g),H(a)}a.g.j=null;d.call(a.g,f);return H(a)}function H(a){for(;a.g.h;)try{var b=a.G(a.g);if(b)return a.g.m=!1,{value:b.value,done:!1}}catch(c){a.g.v=void 0,a.g.s(c);}a.g.m=false;if(a.g.l){b=a.g.l;a.g.l=null;if(b.F)throw b.D;return {value:b.return,done:true}}return {value:void 0,done:true}}
+	function J(a){this.next=function(b){return a.o(b)};this.throw=function(b){return a.s(b)};this.return=function(b){return I(a,b)};this[Symbol.iterator]=function(){return this};}function K(a,b){b=new J(new F(b));B&&a.prototype&&B(b,a.prototype);return b}function L(a,b){a instanceof String&&(a+="");var c=0,d=false,e={next:function(){if(!d&&c<a.length){var f=c++;return {value:b(f,a[f]),done:false}}d=true;return {done:true,value:void 0}}};e[Symbol.iterator]=function(){return e};return e}
+	r("Array.prototype.entries",function(a){return a?a:function(){return L(this,function(b,c){return [b,c]})}});
+	if("undefined"!==typeof Blob&&("undefined"===typeof FormData||!FormData.prototype.keys)){var M=function(a,b){for(var c=0;c<a.length;c++)b(a[c]);},N=function(a){return a.replace(/\r?\n|\r/g,"\r\n")},O=function(a,b,c){if(b instanceof Blob){c=void 0!==c?String(c+""):"string"===typeof b.name?b.name:"blob";if(b.name!==c||"[object Blob]"===Object.prototype.toString.call(b))b=new File([b],c);return [String(a),b]}return [String(a),String(b)]},P=function(a,b){if(a.length<b)throw new TypeError(b+" argument required, but only "+
+	a.length+" present.");},Q="object"===typeof globalThis?globalThis:"object"===typeof window?window:"object"===typeof self?self:this,R=Q.FormData,S=Q.XMLHttpRequest&&Q.XMLHttpRequest.prototype.send,T=Q.Request&&Q.fetch,U=Q.navigator&&Q.navigator.sendBeacon,V=Q.Element&&Q.Element.prototype,W=Q.Symbol&&Symbol.toStringTag;W&&(Blob.prototype[W]||(Blob.prototype[W]="Blob"),"File"in Q&&!File.prototype[W]&&(File.prototype[W]="File"));try{new File([],"");}catch(a){Q.File=function(b,c,d){b=new Blob(b,d||{});
+	Object.defineProperties(b,{name:{value:c},lastModified:{value:+(d&&void 0!==d.lastModified?new Date(d.lastModified):new Date)},toString:{value:function(){return "[object File]"}}});W&&Object.defineProperty(b,W,{value:"File"});return b};}var escape=function(a){return a.replace(/\n/g,"%0A").replace(/\r/g,"%0D").replace(/"/g,"%22")},X=function(a){this.i=[];var b=this;a&&M(a.elements,function(c){if(c.name&&!c.disabled&&"submit"!==c.type&&"button"!==c.type&&!c.matches("form fieldset[disabled] *"))if("file"===
+	c.type){var d=c.files&&c.files.length?c.files:[new File([],"",{type:"application/octet-stream"})];M(d,function(e){b.append(c.name,e);});}else "select-multiple"===c.type||"select-one"===c.type?M(c.options,function(e){!e.disabled&&e.selected&&b.append(c.name,e.value);}):"checkbox"===c.type||"radio"===c.type?c.checked&&b.append(c.name,c.value):(d="textarea"===c.type?N(c.value):c.value,b.append(c.name,d));});};h=X.prototype;h.append=function(a,b,c){P(arguments,2);this.i.push(O(a,b,c));};h.delete=function(a){P(arguments,
+	1);var b=[];a=String(a);M(this.i,function(c){c[0]!==a&&b.push(c);});this.i=b;};h.entries=function b(){var c,d=this;return K(b,function(e){1==e.h&&(c=0);if(3!=e.h)return c<d.i.length?e=E(e,d.i[c]):(e.h=0,e=void 0),e;c++;e.h=2;})};h.forEach=function(b,c){P(arguments,1);for(var d=v(this),e=d.next();!e.done;e=d.next()){var f=v(e.value);e=f.next().value;f=f.next().value;b.call(c,f,e,this);}};h.get=function(b){P(arguments,1);var c=this.i;b=String(b);for(var d=0;d<c.length;d++)if(c[d][0]===b)return c[d][1];
+	return null};h.getAll=function(b){P(arguments,1);var c=[];b=String(b);M(this.i,function(d){d[0]===b&&c.push(d[1]);});return c};h.has=function(b){P(arguments,1);b=String(b);for(var c=0;c<this.i.length;c++)if(this.i[c][0]===b)return  true;return  false};h.keys=function c(){var d=this,e,f,g,k,p;return K(c,function(t){1==t.h&&(e=v(d),f=e.next());if(3!=t.h){if(f.done){t.h=0;return}g=f.value;k=v(g);p=k.next().value;return E(t,p)}f=e.next();t.h=2;})};h.set=function(c,d,e){P(arguments,2);c=String(c);var f=[],g=O(c,
+	d,e),k=true;M(this.i,function(p){p[0]===c?k&&(k=!f.push(g)):f.push(p);});k&&f.push(g);this.i=f;};h.values=function d(){var e=this,f,g,k,p,t;return K(d,function(x){1==x.h&&(f=v(e),g=f.next());if(3!=x.h){if(g.done){x.h=0;return}k=g.value;p=v(k);p.next();t=p.next().value;return E(x,t)}g=f.next();x.h=2;})};X.prototype._asNative=function(){for(var d=new R,e=v(this),f=e.next();!f.done;f=e.next()){var g=v(f.value);f=g.next().value;g=g.next().value;d.append(f,g);}return d};X.prototype._blob=function(){var d="----formdata-polyfill-"+
+	Math.random(),e=[],f="--"+d+'\r\nContent-Disposition: form-data; name="';this.forEach(function(g,k){return "string"==typeof g?e.push(f+escape(N(k))+('"\r\n\r\n'+N(g)+"\r\n")):e.push(f+escape(N(k))+('"; filename="'+escape(g.name)+'"\r\nContent-Type: '+(g.type||"application/octet-stream")+"\r\n\r\n"),g,"\r\n")});e.push("--"+d+"--");return new Blob(e,{type:"multipart/form-data; boundary="+d})};X.prototype[Symbol.iterator]=function(){return this.entries()};X.prototype.toString=function(){return "[object FormData]"};
+	V&&!V.matches&&(V.matches=V.matchesSelector||V.mozMatchesSelector||V.msMatchesSelector||V.oMatchesSelector||V.webkitMatchesSelector||function(d){d=(this.document||this.ownerDocument).querySelectorAll(d);for(var e=d.length;0<=--e&&d.item(e)!==this;);return  -1<e});W&&(X.prototype[W]="FormData");if(S){var Y=Q.XMLHttpRequest.prototype.setRequestHeader;Q.XMLHttpRequest.prototype.setRequestHeader=function(d,e){Y.call(this,d,e);"content-type"===d.toLowerCase()&&(this.B=true);};Q.XMLHttpRequest.prototype.send=
+	function(d){d instanceof X?(d=d._blob(),this.B||this.setRequestHeader("Content-Type",d.type),S.call(this,d)):S.call(this,d);};}T&&(Q.fetch=function(d,e){e&&e.body&&e.body instanceof X&&(e.body=e.body._blob());return T.call(this,d,e)});U&&(Q.navigator.sendBeacon=function(d,e){e instanceof X&&(e=e._asNative());return U.call(this,d,e)});Q.FormData=X;}})();
+	return formdata_min;
+}
+
+requireFormdata_min();
+
+class FileService {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get a URL to a raw version of a file
+     *
+     * @param scope Scope the file is within
+     * @param id ID of the file
+     * @returns The file URL
+     */
+    rawURL(scope, id) {
+        return `box/${scope}/file/${id}/raw`;
+    }
+    /**
+     * Get a URL to a raw version of a file with an additional
+     * cosmetic name shown in browser viewers
+     *
+     * @param scope Scope the file is within
+     * @param id ID of the file
+     * @param name Name to provide the file
+     * @returns The file URL
+     */
+    rawNamedURL(scope, id, name) {
+        return `box/${scope}/file/${id}/raw/${encodeURIComponent(name)}`;
+    }
+    /**
+     * Get a URL to a generated version of a file
+     *
+     * @param scope Scope the file is within
+     * @param id ID of the main file
+     * @param type Type of generated file to get
+     * @returns The URL to the generated file
+     */
+    generatedRawURL(scope, id, type) {
+        return `box/${scope}/file/${id}/generated/${type}/raw`;
+    }
+    /**
+     * Get a URL to a generated version of a file with an additional
+     * cosmetic name shown in browser viewers
+     *
+     * @param scope Scope the file is within
+     * @param id ID of the main file
+     * @param type Type of generated file to get
+     * @param name Name to provide the file
+     * @returns The URL to the generated file
+     */
+    generatedRawNamedURL(scope, id, type, name) {
+        return `box/${scope}/file/${id}/generated/${type}/raw/${encodeURIComponent(name)}`;
+    }
+    /**
+     * Direct upload
+     *
+     * @deprecated When behind the proxy service this will often encounter timeout issues
+     * its recommended you use another upload method
+     *
+     * Prefer {@link FileService.uploadAsync}
+     *
+     * @param scope Scope to upload the file into
+     * @param name Name of the file
+     * @param folder_id Folder to store the file in
+     * @param file File to store
+     * @returns File upload response
+     */
+    upload(scope, name, folder_id, file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Create form data
+            const data = new FormData();
+            data.append('name', name);
+            data.append('folder_id', folder_id);
+            data.append('file', file);
+            return this.client.httpPost(`box/${scope}/file`, data, {
+                // Clear default JSON content type (We need the browser to set multipart headers properly)
+                headers: { 'Content-Type': undefined },
+            });
+        });
+    }
+    /**
+     * Asynchronous direct upload
+     *
+     * (File is uploaded directly but processed asynchronously)
+     *
+     * If you are handling reasonably sized files prefer {@link FileService.uploadPresigned} to
+     * prevent running into browser timeouts as the file is transferred between services
+     *
+     * @param request Upload request data
+     * @returns The uploaded file response
+     */
+    uploadAsync(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Create form data
+            const data = new FormData();
+            data.append('name', request.name);
+            data.append('folder_id', request.folder_id);
+            data.append('file', request.file);
+            data.append('asynchronous', 'true');
+            if (request.fixed_id) {
+                data.append('fixed_id', request.fixed_id);
+            }
+            if (request.parent_id) {
+                data.append('fixed_id', request.parent_id);
+            }
+            if (request.processing_config) {
+                data.append('processing_config', JSON.stringify(request.processing_config));
+            }
+            const taskResponse = yield this.client.httpPost(`box/${request.scope}/file`, data, {
+                // Clear default JSON content type (We need the browser to set multipart headers properly)
+                headers: { 'Content-Type': undefined },
+            });
+            return yield this.client.task.finished(request.scope, taskResponse.task_id, 1000, request.abort);
+        });
+    }
+    /**
+     * Performs a pre-signed file upload
+     *
+     * @param scope Scope to upload the file into
+     * @param folderId ID of the folder to store the file within
+     * @param file File to upload
+     * @param options Request options
+     * @returns File upload response
+     */
+    uploadPresigned(scope, folderId, file, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options && options.onProgress) {
+                options.onProgress('Preparing');
+            }
+            const presigned = yield this.createPresignedUpload(scope, {
+                name: file.name,
+                folder_id: folderId,
+                size: file.size,
+                mime: file.type,
+                parent_id: options === null || options === void 0 ? void 0 : options.parent_id,
+                processing_config: options === null || options === void 0 ? void 0 : options.processing_config,
+            });
+            yield this.performPresignedUpload(file, presigned, options);
+            if (options && options.onProgress) {
+                options.onProgress('Processing');
+            }
+            const taskId = presigned.task_id;
+            const response = yield this.presignedFinished(scope, taskId, 1000, options === null || options === void 0 ? void 0 : options.abort);
+            if (options && options.onProgress) {
+                options.onProgress('Complete', 1);
+            }
+            return response;
+        });
+    }
+    performPresignedUpload(file, presigned, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options && options.onProgress) {
+                options.onProgress('Starting');
+            }
+            // Browser is not allowed to set this header
+            delete presigned.headers['content-length'];
+            const config = {
+                method: presigned.method,
+                url: presigned.uri,
+                headers: Object.assign({ 'Content-Type': file.type }, presigned.headers),
+                data: file,
+            };
+            if (options) {
+                if (options.onProgress) {
+                    const onProgress = options.onProgress;
+                    config.onUploadProgress = (event) => {
+                        if (!event.progress) {
+                            onProgress('Uploading');
+                            return;
+                        }
+                        if (event.progress === 1) {
+                            onProgress('Uploaded', 1);
+                        }
+                        else {
+                            onProgress('Uploading', event.progress);
+                        }
+                    };
+                }
+                // Apply abort signal
+                if (options.abort) {
+                    config.signal = options.abort.signal;
+                }
+            }
+            // Upload the file to the presigned target
+            yield axios.request(config);
+        });
+    }
+    /**
+     * Creates a new presigned upload
+     *
+     * @param scope Scope to upload the file within
+     * @param request The presigned upload request
+     * @returns The presigned upload details
+     */
+    createPresignedUpload(scope, request) {
+        return this.client.httpPost(`box/${scope}/file/presigned`, request);
+    }
+    /**
+     * Request the status of a presigned upload task
+     *
+     * @param scope Scope the upload file task is within
+     * @param taskId ID of the uploading task
+     * @param abort Abort handle to abort the request
+     * @returns The task status
+     */
+    presignedStatus(scope, taskId, abort) {
+        return this.client.httpGet(`box/${scope}/file/presigned/${taskId}`, { signal: abort === null || abort === void 0 ? void 0 : abort.signal });
+    }
+    /**
+     * Polls for the completion of a presigned upload task
+     *
+     * @param scope Scope the upload file task is within
+     * @param task_id ID of the uploading task
+     * @param interval Rate at which to poll for completion
+     * @param abort Abort handle that can abort the polling
+     * @returns The uploaded file response
+     */
+    presignedFinished(scope_1, task_id_1) {
+        return __awaiter(this, arguments, void 0, function* (scope, task_id, interval = 1000, abort) {
+            var _a;
+            while (abort === undefined ? true : !abort.signal.aborted) {
+                const task = yield this.presignedStatus(scope, task_id, abort);
+                if (task.status === 'Complete') {
+                    return { file: task.file, generated: task.generated };
+                }
+                if (task.status === 'Failed') {
+                    const error = (_a = task.error) !== null && _a !== void 0 ? _a : 'Unknown error';
+                    throw new Error(error);
+                }
+                yield sleep(interval);
+            }
+            throw new Error('upload tracking aborted');
+        });
+    }
+    /**
+     * Request the details of a file using its ID and scope
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file
+     * @returns The full file details
+     */
+    get(scope, file_id) {
+        return this.client.httpGet(`box/${scope}/file/${file_id}`);
+    }
+    /**
+     * Search within the contents of a file
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file
+     * @param request The search request
+     * @returns The full file details
+     */
+    search(scope, file_id, request) {
+        return this.client.httpPost(`box/${scope}/file/${file_id}/search`, request);
+    }
+    /**
+     * Request children of the file, in the case of .eml email files this
+     * would provide a list of files for the attachments associated with
+     * the email
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to find the children of
+     * @returns The files that are children
+     */
+    children(scope, file_id) {
+        return this.client.httpGet(`box/${scope}/file/${file_id}/children`);
+    }
+    /**
+     * Request the history of edits to the file
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to get the history for
+     * @returns The edit history
+     */
+    editHistory(scope, file_id) {
+        return this.client.httpGet(`box/${scope}/file/${file_id}/edit-history`);
+    }
+    /**
+     * Update the details about the file
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to update
+     * @param data The updates to perform
+     */
+    update(scope, file_id, data) {
+        return this.client.httpPut(`box/${scope}/file/${file_id}`, data);
+    }
+    /**
+     * Gets the raw file contents of the provided file
+     *
+     * On node this returns an {@link ArrayBuffer} not a blob
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to retrieve
+     * @returns The raw contents of the file
+     */
+    raw(scope, file_id) {
+        return this.client.httpGet(this.rawURL(scope, file_id), {
+            responseType: typeof window === 'undefined' ? 'arraybuffer' : 'blob',
+        });
+    }
+    /**
+     * Gets the raw file contents of the provided file
+     *
+     * This function is the same as {@link FileService.raw} just
+     * it has the correct return type for Node
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to retrieve
+     * @returns The raw contents of the file
+     */
+    rawNode(scope, file_id) {
+        return this.client.httpGet(this.rawURL(scope, file_id), {
+            responseType: 'arraybuffer',
+        });
+    }
+    /**
+     * Gets the raw file contents of the provided file in
+     * JSON format (Will only work if the actual file is JSON)
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to retrieve
+     * @returns The JSON contents of the file
+     */
+    json(scope, file_id) {
+        return this.client.httpGet(this.rawURL(scope, file_id), {
+            responseType: 'json',
+        });
+    }
+    /**
+     * Gets the raw file contents of the provided file as text
+     * (Will only work if the actual file is text)
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to retrieve
+     * @returns The text contents of the file
+     */
+    text(scope, file_id) {
+        return this.client.httpGet(this.rawURL(scope, file_id), {
+            responseType: 'text',
+        });
+    }
+    /**
+     * Deletes a file
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to delete
+     */
+    delete(scope, file_id) {
+        return this.client.httpDelete(`box/${scope}/file/${file_id}`);
+    }
+    /**
+     * Gets a generated file details
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to query
+     * @param type Type of the generated file
+     * @returns The generated file details
+     */
+    generated(scope, file_id, type) {
+        return this.client.httpGet(`box/${scope}/file/${file_id}/generated/${type}`);
+    }
+    /**
+     * Gets a generated file raw contents
+     *
+     * On node this returns an {@link ArrayBuffer} not a blob
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to query
+     * @param type Type of the generated file
+     * @returns The Blob/ArrayBuffer content of the file (Blob within a browser, ArrayBuffer on node)
+     */
+    generatedRaw(scope, file_id, type) {
+        return this.client.httpGet(this.generatedRawURL(scope, file_id, type), {
+            responseType: typeof window === 'undefined' ? 'arraybuffer' : 'blob',
+        });
+    }
+    /**
+     * Gets a generated file raw contents
+     *
+     * This function is the same as {@link FileService.generatedRaw} just
+     * it has the correct return type for Node and will only return an
+     * ArrayBuffer
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to query
+     * @param type Type of the generated file
+     * @returns The ArrayBuffer content of the generated file
+     */
+    generatedRawNode(scope, file_id, type) {
+        return this.client.httpGet(this.generatedRawURL(scope, file_id, type), {
+            responseType: 'arraybuffer',
+        });
+    }
+    /**
+     * Gets a generated file raw contents as text
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to query
+     * @param type Type of the generated file
+     * @returns The text content of the generated file
+     */
+    generatedText(scope, file_id, type) {
+        return this.client.httpGet(this.generatedRawURL(scope, file_id, type), {
+            responseType: 'text',
+        });
+    }
+    /**
+     * Gets a generated file raw contents as JSON
+     *
+     * @param scope Scope the file resides within
+     * @param file_id ID of the file to query
+     * @param type Type of the generated file
+     * @returns The JSON content of the generated file
+     */
+    generatedJson(scope, file_id, type) {
+        return this.client.httpGet(this.generatedRawURL(scope, file_id, type), {
+            responseType: 'json',
+        });
+    }
+}
+
+class BoxService {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get a document box for a scope
+     *
+     * @param scope Scope of the document box to get
+     * @param createIfMissing Whether to create the document box if it doesn't exist
+     */
+    get(scope_1) {
+        return __awaiter(this, arguments, void 0, function* (scope, createIfMissing = false) {
+            var _a;
+            try {
+                return yield this.client.httpGet(`box/${scope}`);
+            }
+            catch (err) {
+                // Handle a document box not being created yet
+                if (createIfMissing && axios.isAxiosError(err) && ((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                    // Attempt to create the document box
+                    return this.create(scope, false);
+                }
+                throw err;
+            }
+        });
+    }
+    /**
+     * Creates a new document box optional returning an existing one if there is one available
+     *
+     * @param scope Scope for the document box to create
+     * @param allowExisting Whether to allow returning an existing document box (If one is present)
+     * @returns The created document box
+     */
+    create(scope_1) {
+        return __awaiter(this, arguments, void 0, function* (scope, allowExisting = true) {
+            var _a;
+            try {
+                return yield this.client.httpPost('box', { scope });
+            }
+            catch (err) {
+                // Handle document box already exists response
+                if (allowExisting && axios.isAxiosError(err) && ((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 409) {
+                    return this.get(scope);
+                }
+                throw err;
+            }
+        });
+    }
+    /**
+     * Delete a specific document vox
+     *
+     * @param scope Scope of the document box to delete
+     * @returns
+     */
+    delete(scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                return this.client.httpDelete(`box/${scope}`);
+            }
+            catch (err) {
+                // Handle document box never existed
+                if (axios.isAxiosError(err) && ((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                    return {};
+                }
+                throw err;
+            }
+        });
+    }
+    /**
+     * Search within the provided document box
+     *
+     * @param scope The scope of the document box to search
+     * @param data Search request data
+     * @returns The search results
+     */
+    search(scope, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.client.httpPost(`box/${scope}/search`, data);
+        });
+    }
+    /**
+     * Get statistics for the provided document box
+     *
+     * @param scope The scope of the document box
+     * @returns The box stats
+     */
+    stats(scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.client.httpGet(`box/${scope}/stats`);
+        });
+    }
+}
+
+class LinkService {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get a link to the favicon image for the provided link
+     *
+     * @param scope Scope the link resides within
+     * @param id ID of the link to request
+     * @returns The favicon image URL
+     */
+    faviconURL(scope, id) {
+        return `box/${scope}/link/${id}/favicon`;
+    }
+    /**
+     * Get a link to the OGP image for the provided link
+     *
+     * @param scope Scope the link resides within
+     * @param id ID of the link to request
+     * @returns The OGP image URL
+     */
+    imageURL(scope, id) {
+        return `box/${scope}/link/${id}/image`;
+    }
+    /**
+     * Creates a new link within the provided document box
+     *
+     * @param scope Scope to create the link within
+     * @param data Link creation data
+     * @returns The created link
+     */
+    create(scope, data) {
+        return this.client.httpPost(`box/${scope}/link`, data);
+    }
+    /**
+     * Request a specific link by ID
+     *
+     * @param scope Scope the link resides within
+     * @param link_id ID of the link to request
+     * @returns The requested link
+     */
+    get(scope, link_id) {
+        return this.client.httpGet(`box/${scope}/link/${link_id}`);
+    }
+    /**
+     * Requests metadata for the link. This will make a request to the site at
+     * the link value to extract metadata from the website itself such as title,
+     * and OGP metadata
+     *
+     * @param scope Scope the link resides within
+     * @param link_id ID of the link to request
+     * @returns The link website metadata
+     */
+    metadata(scope, link_id) {
+        return this.client.httpGet(`box/${scope}/link/${link_id}/metadata`);
+    }
+    /**
+     * Get the raw favicon content for a link
+     *
+     * On node this returns an {@link ArrayBuffer} not a blob
+     *
+     * @param scope Scope the link resides within
+     * @param link_id ID of the link to request
+     * @returns The link raw favicon
+     */
+    favicon(scope, link_id) {
+        return this.client.httpGet(this.faviconURL(scope, link_id), {
+            responseType: typeof window === 'undefined' ? 'arraybuffer' : 'blob',
+        });
+    }
+    /**
+     * Get the raw favicon content for a link
+     *
+     * This function is the same as {@link LinkService.favicon} just
+     * it has the correct return type for Node and will only return an
+     * ArrayBuffer
+     *
+     * @param scope Scope the link resides within
+     * @param link_id ID of the link to request
+     * @returns The link raw favicon
+     */
+    faviconNode(scope, link_id) {
+        return this.client.httpGet(this.faviconURL(scope, link_id), {
+            responseType: 'arraybuffer',
+        });
+    }
+    /**
+     * Get the raw social image for a link
+     *
+     * On node this returns an {@link ArrayBuffer} not a blob
+     *
+     * @param scope Scope the link resides within
+     * @param link_id ID of the link to request
+     * @returns The link raw social image
+     */
+    image(scope, link_id) {
+        return this.client.httpGet(this.imageURL(scope, link_id), {
+            responseType: typeof window === 'undefined' ? 'arraybuffer' : 'blob',
+        });
+    }
+    /**
+     * Get the raw social image for a link
+     *
+     * This function is the same as {@link LinkService.image} just
+     * it has the correct return type for Node and will only return an
+     * ArrayBuffer
+     *
+     * @param scope Scope the link resides within
+     * @param link_id ID of the link to request
+     * @returns
+     */
+    imageNode(scope, link_id) {
+        return this.client.httpGet(this.imageURL(scope, link_id), {
+            responseType: 'arraybuffer',
+        });
+    }
+    /**
+     * Get the edit history for a link
+     *
+     * @param scope Scope the link resides within
+     * @param link_id ID of the link to request
+     * @returns Edit history for the link
+     */
+    editHistory(scope, link_id) {
+        return this.client.httpGet(`box/${scope}/link/${link_id}/edit-history`);
+    }
+    /**
+     * Updates a link
+     *
+     * @param scope Scope the link resides within
+     * @param link_id ID of the link to request
+     * @param data The update request
+     */
+    update(scope, link_id, data) {
+        return this.client.httpPut(`box/${scope}/link/${link_id}`, data);
+    }
+    /**
+     * Deletes the provided link
+     *
+     * @param scope Scope the link resides within
+     * @param link_id ID of the link to request
+     */
+    delete(scope, link_id) {
+        return this.client.httpDelete(`box/${scope}/link/${link_id}`);
+    }
+}
+
+class FolderService {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create a new folder
+     *
+     * @param scope Scope to create the folder within
+     * @param data Configuration for creating the folder
+     * @returns The created folder
+     */
+    create(scope, data) {
+        return this.client.httpPost(`box/${scope}/folder`, data);
+    }
+    /**
+     * Loads a specific folder
+     *
+     * @param scope Scope the folder resides within
+     * @param folder_id ID of the folder to request
+     * @returns The resolved folder
+     */
+    get(scope, folder_id) {
+        return this.client.httpGet(`box/${scope}/folder/${folder_id}`);
+    }
+    /**
+     * Update a folder details
+     *
+     * @param scope Scope the folder resides within
+     * @param folder_id ID of the folder to update
+     * @param data The folder update data
+     */
+    update(scope, folder_id, data) {
+        return this.client.httpPut(`box/${scope}/folder/${folder_id}`, data);
+    }
+    /**
+     * Deletes the provided folder
+     *
+     * @param scope Scope the folder resides within
+     * @param folder_id ID of the folder to delete
+     */
+    delete(scope, folder_id) {
+        return this.client.httpDelete(`box/${scope}/folder/${folder_id}`);
+    }
+    /**
+     * Load the edit history of a folder
+     *
+     * @param scope Scope the folder resides within
+     * @param folder_id ID of the folder to query
+     * @returns The folder edit history
+     */
+    editHistory(scope, folder_id) {
+        return this.client.httpGet(`box/${scope}/folder/${folder_id}/edit-history`);
+    }
+}
+
+class TaskService {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get the current status of a specific task
+     *
+     * @param scope
+     * @param task_id
+     * @returns
+     */
+    get(scope, task_id, abort) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.httpGet(`box/${scope}/task/${task_id}`, {
+                signal: abort === null || abort === void 0 ? void 0 : abort.signal,
+            });
+        });
+    }
+    /**
+     * Polls for the completion of a task
+     *
+     * @param scope
+     * @param task_id
+     * @param abort
+     * @returns
+     */
+    finished(scope_1, task_id_1) {
+        return __awaiter(this, arguments, void 0, function* (scope, task_id, interval = 1000, abort) {
+            var _a, _b;
+            while (abort === undefined ? true : !abort.signal.aborted) {
+                const task = yield this.get(scope, task_id, abort);
+                if (task.status === exports.DocboxTaskStatus.Completed) {
+                    const response = task.output_data;
+                    return response;
+                }
+                if (task.status === exports.DocboxTaskStatus.Failed) {
+                    const error = (_b = (_a = task.output_data) === null || _a === void 0 ? void 0 : _a.error) !== null && _b !== void 0 ? _b : 'Unknown Error';
+                    throw new Error(error);
+                }
+                yield sleep(interval);
+            }
+            throw new Error('upload tracking aborted');
+        });
+    }
+}
+
+class AdminService {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Perform an admin search across multiple document boxes.
+     *
+     * This function will only work on your server handling authentication
+     * you should not allow the frontend to access these endpoints
+     *
+     * @param data Search request data
+     * @returns The search results
+     */
+    search(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.client.httpPost(`admin/search`, data);
+        });
+    }
+}
+
+class DocboxClient {
+    /**
+     * Creates a new docbox
+     *
+     * @param client
+     */
+    constructor(client) {
+        this.client = client;
+        this.documentBox = new BoxService(this);
+        this.task = new TaskService(this);
+        this.file = new FileService(this);
+        this.link = new LinkService(this);
+        this.folder = new FolderService(this);
+        this.admin = new AdminService(this);
+    }
+    httpGet(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.get(url, config);
+            return data;
+        });
+    }
+    httpPost(url, data, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data: responseData } = yield this.client.post(url, data, config);
+            return responseData;
+        });
+    }
+    httpPut(url, data, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data: responseData } = yield this.client.put(url, data, config);
+            return responseData;
+        });
+    }
+    httpPatch(url, data, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data: responseData } = yield this.client.patch(url, data, config);
+            return responseData;
+        });
+    }
+    httpDelete(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data: responseData } = yield this.client.delete(url, config);
+            return responseData;
+        });
+    }
+}
+
+let FileGlobal = File;
+// Node targets don't have this available, just mock it.
+// this type should not be used in a node env
+if (FileGlobal === undefined) {
+    class MockFile {
+        constructor(name, fileParts, options) {
+            this.name = name;
+            this.fileParts = fileParts;
+            this.options = options;
+        }
+    }
+    FileGlobal = MockFile;
+}
+/**
+ * Wrapper around the browser File type to allow using a docbox file
+ * in place when handling already uploaded files in a form
+ */
+class DocboxFile extends FileGlobal {
+    get size() {
+        return this.file.size;
+    }
+    constructor(file) {
+        super([], file.name, { type: file.mime });
+        this.file = file;
+    }
+}
+
+exports.DocboxClient = DocboxClient;
+exports.DocboxFile = DocboxFile;
+exports.sleep = sleep;
+//# sourceMappingURL=index.browser.cjs.map