@verdocs/web-sdk 1.0.25 → 1.4.0

package/dist/{cjs/Content-e1c04dfa.js → esm/Token-29eea56d.js}

@@ -1,3 +1,6 @@
+import { p as process_1 } from './index-97ec070b.js';
+import { B as Buffer } from './buffer-es6-5cef4368.js';
+
 'use strict';
 
 var bind = function bind(fn, thisArg) {
@@ -10,10 +13,30 @@ var bind = function bind(fn, thisArg) {
   };
 };
 
+'use strict';
+
+
+
 // utils is a library of generic helper functions non-specific to axios
 
 var toString = Object.prototype.toString;
 
+// eslint-disable-next-line func-names
+var kindOf = (function(cache) {
+  // eslint-disable-next-line func-names
+  return function(thing) {
+    var str = toString.call(thing);
+    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
+  };
+})(Object.create(null));
+
+function kindOfTest(type) {
+  type = type.toLowerCase();
+  return function isKindOf(thing) {
+    return kindOf(thing) === type;
+  };
+}
+
 /**
  * Determine if a value is an Array
  *
@@ -21,7 +44,7 @@ var toString = Object.prototype.toString;
  * @returns {boolean} True if value is an Array, otherwise false
  */
 function isArray(val) {
-  return toString.call(val) === '[object Array]';
+  return Array.isArray(val);
 }
 
 /**
@@ -48,22 +71,12 @@ function isBuffer(val) {
 /**
  * Determine if a value is an ArrayBuffer
  *
+ * @function
  * @param {Object} val The value to test
  * @returns {boolean} True if value is an ArrayBuffer, otherwise false
  */
-function isArrayBuffer(val) {
-  return toString.call(val) === '[object ArrayBuffer]';
-}
+var isArrayBuffer = kindOfTest('ArrayBuffer');
 
-/**
- * Determine if a value is a FormData
- *
- * @param {Object} val The value to test
- * @returns {boolean} True if value is an FormData, otherwise false
- */
-function isFormData(val) {
-  return (typeof FormData !== 'undefined') && (val instanceof FormData);
-}
 
 /**
  * Determine if a value is a view on an ArrayBuffer
@@ -76,7 +89,7 @@ function isArrayBufferView(val) {
   if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
     result = ArrayBuffer.isView(val);
   } else {
-    result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
+    result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));
   }
   return result;
 }
@@ -118,7 +131,7 @@ function isObject(val) {
  * @return {boolean} True if value is a plain Object, otherwise false
  */
 function isPlainObject(val) {
-  if (toString.call(val) !== '[object Object]') {
+  if (kindOf(val) !== 'object') {
     return false;
   }
 
@@ -129,32 +142,38 @@ function isPlainObject(val) {
 /**
  * Determine if a value is a Date
  *
+ * @function
  * @param {Object} val The value to test
  * @returns {boolean} True if value is a Date, otherwise false
  */
-function isDate(val) {
-  return toString.call(val) === '[object Date]';
-}
+var isDate = kindOfTest('Date');
 
 /**
  * Determine if a value is a File
  *
+ * @function
  * @param {Object} val The value to test
  * @returns {boolean} True if value is a File, otherwise false
  */
-function isFile(val) {
-  return toString.call(val) === '[object File]';
-}
+var isFile = kindOfTest('File');
 
 /**
  * Determine if a value is a Blob
  *
+ * @function
  * @param {Object} val The value to test
  * @returns {boolean} True if value is a Blob, otherwise false
  */
-function isBlob(val) {
-  return toString.call(val) === '[object Blob]';
-}
+var isBlob = kindOfTest('Blob');
+
+/**
+ * Determine if a value is a FileList
+ *
+ * @function
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a File, otherwise false
+ */
+var isFileList = kindOfTest('FileList');
 
 /**
  * Determine if a value is a Function
@@ -177,14 +196,27 @@ function isStream(val) {
 }
 
 /**
- * Determine if a value is a URLSearchParams object
+ * Determine if a value is a FormData
  *
+ * @param {Object} thing The value to test
+ * @returns {boolean} True if value is an FormData, otherwise false
+ */
+function isFormData(thing) {
+  var pattern = '[object FormData]';
+  return thing && (
+    (typeof FormData === 'function' && thing instanceof FormData) ||
+    toString.call(thing) === pattern ||
+    (isFunction(thing.toString) && thing.toString() === pattern)
+  );
+}
+
+/**
+ * Determine if a value is a URLSearchParams object
+ * @function
  * @param {Object} val The value to test
  * @returns {boolean} True if value is a URLSearchParams object, otherwise false
  */
-function isURLSearchParams(val) {
-  return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
-}
+var isURLSearchParams = kindOfTest('URLSearchParams');
 
 /**
  * Trim excess whitespace off the beginning and end of a string
@@ -331,6 +363,94 @@ function stripBOM(content) {
   return content;
 }
 
+/**
+ * Inherit the prototype methods from one constructor into another
+ * @param {function} constructor
+ * @param {function} superConstructor
+ * @param {object} [props]
+ * @param {object} [descriptors]
+ */
+
+function inherits(constructor, superConstructor, props, descriptors) {
+  constructor.prototype = Object.create(superConstructor.prototype, descriptors);
+  constructor.prototype.constructor = constructor;
+  props && Object.assign(constructor.prototype, props);
+}
+
+/**
+ * Resolve object with deep prototype chain to a flat object
+ * @param {Object} sourceObj source object
+ * @param {Object} [destObj]
+ * @param {Function} [filter]
+ * @returns {Object}
+ */
+
+function toFlatObject(sourceObj, destObj, filter) {
+  var props;
+  var i;
+  var prop;
+  var merged = {};
+
+  destObj = destObj || {};
+
+  do {
+    props = Object.getOwnPropertyNames(sourceObj);
+    i = props.length;
+    while (i-- > 0) {
+      prop = props[i];
+      if (!merged[prop]) {
+        destObj[prop] = sourceObj[prop];
+        merged[prop] = true;
+      }
+    }
+    sourceObj = Object.getPrototypeOf(sourceObj);
+  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
+
+  return destObj;
+}
+
+/*
+ * determines whether a string ends with the characters of a specified string
+ * @param {String} str
+ * @param {String} searchString
+ * @param {Number} [position= 0]
+ * @returns {boolean}
+ */
+function endsWith(str, searchString, position) {
+  str = String(str);
+  if (position === undefined || position > str.length) {
+    position = str.length;
+  }
+  position -= searchString.length;
+  var lastIndex = str.indexOf(searchString, position);
+  return lastIndex !== -1 && lastIndex === position;
+}
+
+
+/**
+ * Returns new array from array like object
+ * @param {*} [thing]
+ * @returns {Array}
+ */
+function toArray(thing) {
+  if (!thing) return null;
+  var i = thing.length;
+  if (isUndefined(i)) return null;
+  var arr = new Array(i);
+  while (i-- > 0) {
+    arr[i] = thing[i];
+  }
+  return arr;
+}
+
+// eslint-disable-next-line func-names
+var isTypedArray = (function(TypedArray) {
+  // eslint-disable-next-line func-names
+  return function(thing) {
+    return TypedArray && thing instanceof TypedArray;
+  };
+})(typeof Uint8Array !== 'undefined' && Object.getPrototypeOf(Uint8Array));
+
 var utils = {
   isArray: isArray,
   isArrayBuffer: isArrayBuffer,
@@ -353,9 +473,21 @@ var utils = {
   merge: merge,
   extend: extend,
   trim: trim,
-  stripBOM: stripBOM
+  stripBOM: stripBOM,
+  inherits: inherits,
+  toFlatObject: toFlatObject,
+  kindOf: kindOf,
+  kindOfTest: kindOfTest,
+  endsWith: endsWith,
+  toArray: toArray,
+  isTypedArray: isTypedArray,
+  isFileList: isFileList
 };
 
+'use strict';
+
+
+
 function encode(val) {
   return encodeURIComponent(val).
     replace(/%3A/gi, ':').
@@ -423,6 +555,10 @@ var buildURL = function buildURL(url, params, paramsSerializer) {
   return url;
 };
 
+'use strict';
+
+
+
 function InterceptorManager() {
   this.handlers = [];
 }
@@ -474,6 +610,10 @@ InterceptorManager.prototype.forEach = function forEach(fn) {
 
 var InterceptorManager_1 = InterceptorManager;
 
+'use strict';
+
+
+
 var normalizeHeaderName = function normalizeHeaderName(headers, normalizedName) {
   utils.forEach(headers, function processHeader(value, name) {
     if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
@@ -483,27 +623,32 @@ var normalizeHeaderName = function normalizeHeaderName(headers, normalizedName)
   });
 };
 
+'use strict';
+
+
+
 /**
- * Update an Error with the specified config, error code, and response.
+ * Create an Error with the specified message, config, error code, request and response.
  *
- * @param {Error} error The error to update.
- * @param {Object} config The config.
+ * @param {string} message The error message.
  * @param {string} [code] The error code (for example, 'ECONNABORTED').
+ * @param {Object} [config] The config.
  * @param {Object} [request] The request.
  * @param {Object} [response] The response.
- * @returns {Error} The error.
+ * @returns {Error} The created error.
  */
-var enhanceError = function enhanceError(error, config, code, request, response) {
-  error.config = config;
-  if (code) {
-    error.code = code;
-  }
-
-  error.request = request;
-  error.response = response;
-  error.isAxiosError = true;
+function AxiosError(message, code, config, request, response) {
+  Error.call(this);
+  this.message = message;
+  this.name = 'AxiosError';
+  code && (this.code = code);
+  config && (this.config = config);
+  request && (this.request = request);
+  response && (this.response = response);
+}
 
-  error.toJSON = function toJSON() {
+utils.inherits(AxiosError, Error, {
+  toJSON: function toJSON() {
     return {
       // Standard
       message: this.message,
@@ -518,27 +663,138 @@ var enhanceError = function enhanceError(error, config, code, request, response)
       stack: this.stack,
       // Axios
       config: this.config,
-      code: this.code
+      code: this.code,
+      status: this.response && this.response.status ? this.response.status : null
     };
-  };
-  return error;
+  }
+});
+
+var prototype = AxiosError.prototype;
+var descriptors = {};
+
+[
+  'ERR_BAD_OPTION_VALUE',
+  'ERR_BAD_OPTION',
+  'ECONNABORTED',
+  'ETIMEDOUT',
+  'ERR_NETWORK',
+  'ERR_FR_TOO_MANY_REDIRECTS',
+  'ERR_DEPRECATED',
+  'ERR_BAD_RESPONSE',
+  'ERR_BAD_REQUEST',
+  'ERR_CANCELED'
+// eslint-disable-next-line func-names
+].forEach(function(code) {
+  descriptors[code] = {value: code};
+});
+
+Object.defineProperties(AxiosError, descriptors);
+Object.defineProperty(prototype, 'isAxiosError', {value: true});
+
+// eslint-disable-next-line func-names
+AxiosError.from = function(error, code, config, request, response, customProps) {
+  var axiosError = Object.create(prototype);
+
+  utils.toFlatObject(error, axiosError, function filter(obj) {
+    return obj !== Error.prototype;
+  });
+
+  AxiosError.call(axiosError, error.message, code, config, request, response);
+
+  axiosError.name = error.name;
+
+  customProps && Object.assign(axiosError, customProps);
+
+  return axiosError;
 };
 
-/**
- * Create an Error with the specified message, config, error code, request and response.
- *
- * @param {string} message The error message.
- * @param {Object} config The config.
- * @param {string} [code] The error code (for example, 'ECONNABORTED').
- * @param {Object} [request] The request.
- * @param {Object} [response] The response.
- * @returns {Error} The created error.
- */
-var createError = function createError(message, config, code, request, response) {
-  var error = new Error(message);
-  return enhanceError(error, config, code, request, response);
+var AxiosError_1 = AxiosError;
+
+'use strict';
+
+var transitional = {
+  silentJSONParsing: true,
+  forcedJSONParsing: true,
+  clarifyTimeoutError: false
 };
 
+'use strict';
+
+
+
+/**
+ * Convert a data object to FormData
+ * @param {Object} obj
+ * @param {?Object} [formData]
+ * @returns {Object}
+ **/
+
+function toFormData(obj, formData) {
+  // eslint-disable-next-line no-param-reassign
+  formData = formData || new FormData();
+
+  var stack = [];
+
+  function convertValue(value) {
+    if (value === null) return '';
+
+    if (utils.isDate(value)) {
+      return value.toISOString();
+    }
+
+    if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {
+      return typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);
+    }
+
+    return value;
+  }
+
+  function build(data, parentKey) {
+    if (utils.isPlainObject(data) || utils.isArray(data)) {
+      if (stack.indexOf(data) !== -1) {
+        throw Error('Circular reference detected in ' + parentKey);
+      }
+
+      stack.push(data);
+
+      utils.forEach(data, function each(value, key) {
+        if (utils.isUndefined(value)) return;
+        var fullKey = parentKey ? parentKey + '.' + key : key;
+        var arr;
+
+        if (value && !parentKey && typeof value === 'object') {
+          if (utils.endsWith(key, '{}')) {
+            // eslint-disable-next-line no-param-reassign
+            value = JSON.stringify(value);
+          } else if (utils.endsWith(key, '[]') && (arr = utils.toArray(value))) {
+            // eslint-disable-next-line func-names
+            arr.forEach(function(el) {
+              !utils.isUndefined(el) && formData.append(fullKey, convertValue(el));
+            });
+            return;
+          }
+        }
+
+        build(value, fullKey);
+      });
+
+      stack.pop();
+    } else {
+      formData.append(parentKey, convertValue(data));
+    }
+  }
+
+  build(obj);
+
+  return formData;
+}
+
+var toFormData_1 = toFormData;
+
+'use strict';
+
+
+
 /**
  * Resolve or reject a Promise based on response status.
  *
@@ -551,16 +807,20 @@ var settle = function settle(resolve, reject, response) {
   if (!response.status || !validateStatus || validateStatus(response.status)) {
     resolve(response);
   } else {
-    reject(createError(
+    reject(new AxiosError_1(
       'Request failed with status code ' + response.status,
+      [AxiosError_1.ERR_BAD_REQUEST, AxiosError_1.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
       response.config,
-      null,
       response.request,
       response
     ));
   }
 };
 
+'use strict';
+
+
+
 var cookies = (
   utils.isStandardBrowserEnv() ?
 
@@ -611,6 +871,8 @@ var cookies = (
     })()
 );
 
+'use strict';
+
 /**
  * Determines whether the specified URL is absolute
  *
@@ -621,9 +883,11 @@ var isAbsoluteURL = function isAbsoluteURL(url) {
   // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
   // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
   // by any combination of letters, digits, plus, period, or hyphen.
-  return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
 };
 
+'use strict';
+
 /**
  * Creates a new URL by combining the specified URLs
  *
@@ -637,6 +901,11 @@ var combineURLs = function combineURLs(baseURL, relativeURL) {
     : baseURL;
 };
 
+'use strict';
+
+
+
+
 /**
  * Creates a new URL by combining the baseURL with the requestedURL,
  * only when the requestedURL is not already an absolute URL.
@@ -653,6 +922,10 @@ var buildFullPath = function buildFullPath(baseURL, requestedURL) {
   return requestedURL;
 };
 
+'use strict';
+
+
+
 // Headers whose duplicates are ignored by node
 // c.f. https://nodejs.org/api/http.html#http_message_headers
 var ignoreDuplicateOf = [
@@ -703,6 +976,10 @@ var parseHeaders = function parseHeaders(headers) {
   return parsed;
 };
 
+'use strict';
+
+
+
 var isURLSameOrigin = (
   utils.isStandardBrowserEnv() ?
 
@@ -768,13 +1045,67 @@ var isURLSameOrigin = (
     })()
 );
 
+'use strict';
+
+
+
+
+/**
+ * A `CanceledError` is an object that is thrown when an operation is canceled.
+ *
+ * @class
+ * @param {string=} message The message.
+ */
+function CanceledError(message) {
+  // eslint-disable-next-line no-eq-null,eqeqeq
+  AxiosError_1.call(this, message == null ? 'canceled' : message, AxiosError_1.ERR_CANCELED);
+  this.name = 'CanceledError';
+}
+
+utils.inherits(CanceledError, AxiosError_1, {
+  __CANCEL__: true
+});
+
+var CanceledError_1 = CanceledError;
+
+'use strict';
+
+var parseProtocol = function parseProtocol(url) {
+  var match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+  return match && match[1] || '';
+};
+
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+
+
 var xhr = function xhrAdapter(config) {
   return new Promise(function dispatchXhrRequest(resolve, reject) {
     var requestData = config.data;
     var requestHeaders = config.headers;
     var responseType = config.responseType;
+    var onCanceled;
+    function done() {
+      if (config.cancelToken) {
+        config.cancelToken.unsubscribe(onCanceled);
+      }
 
-    if (utils.isFormData(requestData)) {
+      if (config.signal) {
+        config.signal.removeEventListener('abort', onCanceled);
+      }
+    }
+
+    if (utils.isFormData(requestData) && utils.isStandardBrowserEnv()) {
       delete requestHeaders['Content-Type']; // Let the browser set it
     }
 
@@ -788,6 +1119,7 @@ var xhr = function xhrAdapter(config) {
     }
 
     var fullPath = buildFullPath(config.baseURL, config.url);
+
     request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
 
     // Set the request timeout in MS
@@ -810,7 +1142,13 @@ var xhr = function xhrAdapter(config) {
         request: request
       };
 
-      settle(resolve, reject, response);
+      settle(function _resolve(value) {
+        resolve(value);
+        done();
+      }, function _reject(err) {
+        reject(err);
+        done();
+      }, response);
 
       // Clean up request
       request = null;
@@ -845,7 +1183,7 @@ var xhr = function xhrAdapter(config) {
         return;
       }
 
-      reject(createError('Request aborted', config, 'ECONNABORTED', request));
+      reject(new AxiosError_1('Request aborted', AxiosError_1.ECONNABORTED, config, request));
 
       // Clean up request
       request = null;
@@ -855,7 +1193,7 @@ var xhr = function xhrAdapter(config) {
     request.onerror = function handleError() {
       // Real errors are hidden from us by the browser
       // onerror should only fire if it's a network error
-      reject(createError('Network Error', config, null, request));
+      reject(new AxiosError_1('Network Error', AxiosError_1.ERR_NETWORK, config, request, request));
 
       // Clean up request
       request = null;
@@ -863,14 +1201,15 @@ var xhr = function xhrAdapter(config) {
 
     // Handle timeout
     request.ontimeout = function handleTimeout() {
-      var timeoutErrorMessage = 'timeout of ' + config.timeout + 'ms exceeded';
+      var timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';
+      var transitional$1 = config.transitional || transitional;
       if (config.timeoutErrorMessage) {
         timeoutErrorMessage = config.timeoutErrorMessage;
       }
-      reject(createError(
+      reject(new AxiosError_1(
         timeoutErrorMessage,
+        transitional$1.clarifyTimeoutError ? AxiosError_1.ETIMEDOUT : AxiosError_1.ECONNABORTED,
         config,
-        config.transitional && config.transitional.clarifyTimeoutError ? 'ETIMEDOUT' : 'ECONNABORTED',
         request));
 
       // Clean up request
@@ -924,29 +1263,52 @@ var xhr = function xhrAdapter(config) {
       request.upload.addEventListener('progress', config.onUploadProgress);
     }
 
-    if (config.cancelToken) {
+    if (config.cancelToken || config.signal) {
       // Handle cancellation
-      config.cancelToken.promise.then(function onCanceled(cancel) {
+      // eslint-disable-next-line func-names
+      onCanceled = function(cancel) {
         if (!request) {
           return;
         }
-
+        reject(!cancel || (cancel && cancel.type) ? new CanceledError_1() : cancel);
         request.abort();
-        reject(cancel);
-        // Clean up request
         request = null;
-      });
+      };
+
+      config.cancelToken && config.cancelToken.subscribe(onCanceled);
+      if (config.signal) {
+        config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);
+      }
     }
 
     if (!requestData) {
       requestData = null;
     }
 
+    var protocol = parseProtocol(fullPath);
+
+    if (protocol && [ 'http', 'https', 'file' ].indexOf(protocol) === -1) {
+      reject(new AxiosError_1('Unsupported protocol ' + protocol + ':', AxiosError_1.ERR_BAD_REQUEST, config));
+      return;
+    }
+
+
     // Send the request
     request.send(requestData);
   });
 };
 
+// eslint-disable-next-line strict
+var _null = null;
+
+'use strict';
+
+
+
+
+
+
+
 var DEFAULT_CONTENT_TYPE = {
   'Content-Type': 'application/x-www-form-urlencoded'
 };
@@ -962,7 +1324,7 @@ function getDefaultAdapter() {
   if (typeof XMLHttpRequest !== 'undefined') {
     // For browsers use XHR adapter
     adapter = xhr;
-  } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
+  } else if (typeof process_1 !== 'undefined' && Object.prototype.toString.call(process_1) === '[object process]') {
     // For node use HTTP adapter
     adapter = xhr;
   }
@@ -986,11 +1348,7 @@ function stringifySafely(rawValue, parser, encoder) {
 
 var defaults = {
 
-  transitional: {
-    silentJSONParsing: true,
-    forcedJSONParsing: true,
-    clarifyTimeoutError: false
-  },
+  transitional: transitional,
 
   adapter: getDefaultAdapter(),
 
@@ -1014,15 +1372,25 @@ var defaults = {
       setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
       return data.toString();
     }
-    if (utils.isObject(data) || (headers && headers['Content-Type'] === 'application/json')) {
+
+    var isObjectPayload = utils.isObject(data);
+    var contentType = headers && headers['Content-Type'];
+
+    var isFileList;
+
+    if ((isFileList = utils.isFileList(data)) || (isObjectPayload && contentType === 'multipart/form-data')) {
+      var _FormData = this.env && this.env.FormData;
+      return toFormData_1(isFileList ? {'files[]': data} : data, _FormData && new _FormData());
+    } else if (isObjectPayload || contentType === 'application/json') {
       setContentTypeIfUnset(headers, 'application/json');
       return stringifySafely(data);
     }
+
     return data;
   }],
 
   transformResponse: [function transformResponse(data) {
-    var transitional = this.transitional;
+    var transitional = this.transitional || defaults.transitional;
     var silentJSONParsing = transitional && transitional.silentJSONParsing;
     var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
     var strictJSONParsing = !silentJSONParsing && this.responseType === 'json';
@@ -1033,7 +1401,7 @@ var defaults = {
       } catch (e) {
         if (strictJSONParsing) {
           if (e.name === 'SyntaxError') {
-            throw enhanceError(e, this, 'E_JSON_PARSE');
+            throw AxiosError_1.from(e, AxiosError_1.ERR_BAD_RESPONSE, this, null, this.response);
           }
           throw e;
         }
@@ -1055,14 +1423,18 @@ var defaults = {
   maxContentLength: -1,
   maxBodyLength: -1,
 
+  env: {
+    FormData: _null
+  },
+
   validateStatus: function validateStatus(status) {
     return status >= 200 && status < 300;
-  }
-};
+  },
 
-defaults.headers = {
-  common: {
-    'Accept': 'application/json, text/plain, */*'
+  headers: {
+    common: {
+      'Accept': 'application/json, text/plain, */*'
+    }
   }
 };
 
@@ -1076,6 +1448,11 @@ utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
 
 var defaults_1 = defaults;
 
+'use strict';
+
+
+
+
 /**
  * Transform the data for a request or a response
  *
@@ -1094,17 +1471,31 @@ var transformData = function transformData(data, headers, fns) {
   return data;
 };
 
+'use strict';
+
 var isCancel = function isCancel(value) {
   return !!(value && value.__CANCEL__);
 };
 
+'use strict';
+
+
+
+
+
+
+
 /**
- * Throws a `Cancel` if cancellation has been requested.
+ * Throws a `CanceledError` if cancellation has been requested.
  */
 function throwIfCancellationRequested(config) {
   if (config.cancelToken) {
     config.cancelToken.throwIfRequested();
   }
+
+  if (config.signal && config.signal.aborted) {
+    throw new CanceledError_1();
+  }
 }
 
 /**
@@ -1174,6 +1565,10 @@ var dispatchRequest = function dispatchRequest(config) {
   });
 };
 
+'use strict';
+
+
+
 /**
  * Config-specific merge-function which creates a new config-object
  * by merging two configuration objects together.
@@ -1187,17 +1582,6 @@ var mergeConfig = function mergeConfig(config1, config2) {
   config2 = config2 || {};
   var config = {};
 
-  var valueFromConfig2Keys = ['url', 'method', 'data'];
-  var mergeDeepPropertiesKeys = ['headers', 'auth', 'proxy', 'params'];
-  var defaultToConfig2Keys = [
-    'baseURL', 'transformRequest', 'transformResponse', 'paramsSerializer',
-    'timeout', 'timeoutMessage', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName',
-    'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress', 'decompress',
-    'maxContentLength', 'maxBodyLength', 'maxRedirects', 'transport', 'httpAgent',
-    'httpsAgent', 'cancelToken', 'socketPath', 'responseEncoding'
-  ];
-  var directMergeKeys = ['validateStatus'];
-
   function getMergedValue(target, source) {
     if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
       return utils.merge(target, source);
@@ -1209,200 +1593,88 @@ var mergeConfig = function mergeConfig(config1, config2) {
     return source;
   }
 
+  // eslint-disable-next-line consistent-return
   function mergeDeepProperties(prop) {
     if (!utils.isUndefined(config2[prop])) {
-      config[prop] = getMergedValue(config1[prop], config2[prop]);
+      return getMergedValue(config1[prop], config2[prop]);
     } else if (!utils.isUndefined(config1[prop])) {
-      config[prop] = getMergedValue(undefined, config1[prop]);
+      return getMergedValue(undefined, config1[prop]);
     }
   }
 
-  utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
+  // eslint-disable-next-line consistent-return
+  function valueFromConfig2(prop) {
     if (!utils.isUndefined(config2[prop])) {
-      config[prop] = getMergedValue(undefined, config2[prop]);
+      return getMergedValue(undefined, config2[prop]);
     }
-  });
-
-  utils.forEach(mergeDeepPropertiesKeys, mergeDeepProperties);
+  }
 
-  utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
+  // eslint-disable-next-line consistent-return
+  function defaultToConfig2(prop) {
     if (!utils.isUndefined(config2[prop])) {
-      config[prop] = getMergedValue(undefined, config2[prop]);
+      return getMergedValue(undefined, config2[prop]);
     } else if (!utils.isUndefined(config1[prop])) {
-      config[prop] = getMergedValue(undefined, config1[prop]);
+      return getMergedValue(undefined, config1[prop]);
     }
-  });
+  }
 
-  utils.forEach(directMergeKeys, function merge(prop) {
+  // eslint-disable-next-line consistent-return
+  function mergeDirectKeys(prop) {
     if (prop in config2) {
-      config[prop] = getMergedValue(config1[prop], config2[prop]);
+      return getMergedValue(config1[prop], config2[prop]);
     } else if (prop in config1) {
-      config[prop] = getMergedValue(undefined, config1[prop]);
+      return getMergedValue(undefined, config1[prop]);
     }
-  });
-
-  var axiosKeys = valueFromConfig2Keys
-    .concat(mergeDeepPropertiesKeys)
-    .concat(defaultToConfig2Keys)
-    .concat(directMergeKeys);
+  }
 
-  var otherKeys = Object
-    .keys(config1)
-    .concat(Object.keys(config2))
-    .filter(function filterAxiosKeys(key) {
-      return axiosKeys.indexOf(key) === -1;
-    });
+  var mergeMap = {
+    'url': valueFromConfig2,
+    'method': valueFromConfig2,
+    'data': valueFromConfig2,
+    'baseURL': defaultToConfig2,
+    'transformRequest': defaultToConfig2,
+    'transformResponse': defaultToConfig2,
+    'paramsSerializer': defaultToConfig2,
+    'timeout': defaultToConfig2,
+    'timeoutMessage': defaultToConfig2,
+    'withCredentials': defaultToConfig2,
+    'adapter': defaultToConfig2,
+    'responseType': defaultToConfig2,
+    'xsrfCookieName': defaultToConfig2,
+    'xsrfHeaderName': defaultToConfig2,
+    'onUploadProgress': defaultToConfig2,
+    'onDownloadProgress': defaultToConfig2,
+    'decompress': defaultToConfig2,
+    'maxContentLength': defaultToConfig2,
+    'maxBodyLength': defaultToConfig2,
+    'beforeRedirect': defaultToConfig2,
+    'transport': defaultToConfig2,
+    'httpAgent': defaultToConfig2,
+    'httpsAgent': defaultToConfig2,
+    'cancelToken': defaultToConfig2,
+    'socketPath': defaultToConfig2,
+    'responseEncoding': defaultToConfig2,
+    'validateStatus': mergeDirectKeys
+  };
 
-  utils.forEach(otherKeys, mergeDeepProperties);
+  utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
+    var merge = mergeMap[prop] || mergeDeepProperties;
+    var configValue = merge(prop);
+    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
+  });
 
   return config;
 };
 
-const _from = "axios@^0.21.1";
-const _id = "axios@0.21.4";
-const _inBundle = false;
-const _integrity = "sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==";
-const _location = "/axios";
-const _phantomChildren = {
-};
-const _requested = {
-	type: "range",
-	registry: true,
-	raw: "axios@^0.21.1",
-	name: "axios",
-	escapedName: "axios",
-	rawSpec: "^0.21.1",
-	saveSpec: null,
-	fetchSpec: "^0.21.1"
-};
-const _requiredBy = [
-	"/@verdocs/js-sdk"
-];
-const _resolved = "https://registry.npmjs.org/axios/-/axios-0.21.4.tgz";
-const _shasum = "c67b90dc0568e5c1cf2b0b858c43ba28e2eda575";
-const _spec = "axios@^0.21.1";
-const _where = "/Users/chad/projects/verdocs/web-sdk/verdocs-web-sdk/node_modules/@verdocs/js-sdk";
-const author = {
-	name: "Matt Zabriskie"
-};
-const browser = {
-	"./lib/adapters/http.js": "./lib/adapters/xhr.js"
-};
-const bugs = {
-	url: "https://github.com/axios/axios/issues"
-};
-const bundleDependencies = false;
-const bundlesize = [
-	{
-		path: "./dist/axios.min.js",
-		threshold: "5kB"
-	}
-];
-const dependencies = {
-	"follow-redirects": "^1.14.0"
-};
-const deprecated = false;
-const description = "Promise based HTTP client for the browser and node.js";
-const devDependencies = {
-	coveralls: "^3.0.0",
-	"es6-promise": "^4.2.4",
-	grunt: "^1.3.0",
-	"grunt-banner": "^0.6.0",
-	"grunt-cli": "^1.2.0",
-	"grunt-contrib-clean": "^1.1.0",
-	"grunt-contrib-watch": "^1.0.0",
-	"grunt-eslint": "^23.0.0",
-	"grunt-karma": "^4.0.0",
-	"grunt-mocha-test": "^0.13.3",
-	"grunt-ts": "^6.0.0-beta.19",
-	"grunt-webpack": "^4.0.2",
-	"istanbul-instrumenter-loader": "^1.0.0",
-	"jasmine-core": "^2.4.1",
-	karma: "^6.3.2",
-	"karma-chrome-launcher": "^3.1.0",
-	"karma-firefox-launcher": "^2.1.0",
-	"karma-jasmine": "^1.1.1",
-	"karma-jasmine-ajax": "^0.1.13",
-	"karma-safari-launcher": "^1.0.0",
-	"karma-sauce-launcher": "^4.3.6",
-	"karma-sinon": "^1.0.5",
-	"karma-sourcemap-loader": "^0.3.8",
-	"karma-webpack": "^4.0.2",
-	"load-grunt-tasks": "^3.5.2",
-	minimist: "^1.2.0",
-	mocha: "^8.2.1",
-	sinon: "^4.5.0",
-	"terser-webpack-plugin": "^4.2.3",
-	typescript: "^4.0.5",
-	"url-search-params": "^0.10.0",
-	webpack: "^4.44.2",
-	"webpack-dev-server": "^3.11.0"
-};
-const homepage = "https://axios-http.com";
-const jsdelivr = "dist/axios.min.js";
-const keywords = [
-	"xhr",
-	"http",
-	"ajax",
-	"promise",
-	"node"
-];
-const license = "MIT";
-const main = "index.js";
-const name = "axios";
-const repository = {
-	type: "git",
-	url: "git+https://github.com/axios/axios.git"
-};
-const scripts = {
-	build: "NODE_ENV=production grunt build",
-	coveralls: "cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
-	examples: "node ./examples/server.js",
-	fix: "eslint --fix lib/**/*.js",
-	postversion: "git push && git push --tags",
-	preversion: "npm test",
-	start: "node ./sandbox/server.js",
-	test: "grunt test",
-	version: "npm run build && grunt version && git add -A dist && git add CHANGELOG.md bower.json package.json"
-};
-const typings = "./index.d.ts";
-const unpkg = "dist/axios.min.js";
-const version = "0.21.4";
-const pkg = {
-	_from: _from,
-	_id: _id,
-	_inBundle: _inBundle,
-	_integrity: _integrity,
-	_location: _location,
-	_phantomChildren: _phantomChildren,
-	_requested: _requested,
-	_requiredBy: _requiredBy,
-	_resolved: _resolved,
-	_shasum: _shasum,
-	_spec: _spec,
-	_where: _where,
-	author: author,
-	browser: browser,
-	bugs: bugs,
-	bundleDependencies: bundleDependencies,
-	bundlesize: bundlesize,
-	dependencies: dependencies,
-	deprecated: deprecated,
-	description: description,
-	devDependencies: devDependencies,
-	homepage: homepage,
-	jsdelivr: jsdelivr,
-	keywords: keywords,
-	license: license,
-	main: main,
-	name: name,
-	repository: repository,
-	scripts: scripts,
-	typings: typings,
-	unpkg: unpkg,
-	version: version
+var data = {
+  "version": "0.27.2"
 };
 
+'use strict';
+
+var VERSION = data.version;
+
+
 var validators$1 = {};
 
 // eslint-disable-next-line func-names
@@ -1413,48 +1685,29 @@ var validators$1 = {};
 });
 
 var deprecatedWarnings = {};
-var currentVerArr = pkg.version.split('.');
-
-/**
- * Compare package versions
- * @param {string} version
- * @param {string?} thanVersion
- * @returns {boolean}
- */
-function isOlderVersion(version, thanVersion) {
-  var pkgVersionArr = thanVersion ? thanVersion.split('.') : currentVerArr;
-  var destVer = version.split('.');
-  for (var i = 0; i < 3; i++) {
-    if (pkgVersionArr[i] > destVer[i]) {
-      return true;
-    } else if (pkgVersionArr[i] < destVer[i]) {
-      return false;
-    }
-  }
-  return false;
-}
 
 /**
  * Transitional option validator
- * @param {function|boolean?} validator
- * @param {string?} version
- * @param {string} message
+ * @param {function|boolean?} validator - set to false if the transitional option has been removed
+ * @param {string?} version - deprecated version / removed since version
+ * @param {string?} message - some message with additional info
  * @returns {function}
  */
 validators$1.transitional = function transitional(validator, version, message) {
-  var isDeprecated = version && isOlderVersion(version);
-
   function formatMessage(opt, desc) {
-    return '[Axios v' + pkg.version + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : '');
+    return '[Axios v' + VERSION + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : '');
   }
 
   // eslint-disable-next-line func-names
   return function(value, opt, opts) {
     if (validator === false) {
-      throw new Error(formatMessage(opt, ' has been removed in ' + version));
+      throw new AxiosError_1(
+        formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),
+        AxiosError_1.ERR_DEPRECATED
+      );
     }
 
-    if (isDeprecated && !deprecatedWarnings[opt]) {
+    if (version && !deprecatedWarnings[opt]) {
       deprecatedWarnings[opt] = true;
       // eslint-disable-next-line no-console
       console.warn(
@@ -1478,7 +1731,7 @@ validators$1.transitional = function transitional(validator, version, message) {
 
 function assertOptions(options, schema, allowUnknown) {
   if (typeof options !== 'object') {
-    throw new TypeError('options must be an object');
+    throw new AxiosError_1('options must be an object', AxiosError_1.ERR_BAD_OPTION_VALUE);
   }
   var keys = Object.keys(options);
   var i = keys.length;
@@ -1489,22 +1742,31 @@ function assertOptions(options, schema, allowUnknown) {
       var value = options[opt];
       var result = value === undefined || validator(value, opt, options);
       if (result !== true) {
-        throw new TypeError('option ' + opt + ' must be ' + result);
+        throw new AxiosError_1('option ' + opt + ' must be ' + result, AxiosError_1.ERR_BAD_OPTION_VALUE);
       }
       continue;
     }
     if (allowUnknown !== true) {
-      throw Error('Unknown option ' + opt);
+      throw new AxiosError_1('Unknown option ' + opt, AxiosError_1.ERR_BAD_OPTION);
     }
   }
 }
 
 var validator = {
-  isOlderVersion: isOlderVersion,
   assertOptions: assertOptions,
   validators: validators$1
 };
 
+'use strict';
+
+
+
+
+
+
+
+
+
 var validators = validator.validators;
 /**
  * Create a new instance of Axios
@@ -1524,14 +1786,14 @@ function Axios(instanceConfig) {
  *
  * @param {Object} config The config specific for this request (merged with this.defaults)
  */
-Axios.prototype.request = function request(config) {
+Axios.prototype.request = function request(configOrUrl, config) {
   /*eslint no-param-reassign:0*/
   // Allow for axios('example/url'[, config]) a la fetch API
-  if (typeof config === 'string') {
-    config = arguments[1] || {};
-    config.url = arguments[0];
-  } else {
+  if (typeof configOrUrl === 'string') {
     config = config || {};
+    config.url = configOrUrl;
+  } else {
+    config = configOrUrl || {};
   }
 
   config = mergeConfig(this.defaults, config);
@@ -1549,9 +1811,9 @@ Axios.prototype.request = function request(config) {
 
   if (transitional !== undefined) {
     validator.assertOptions(transitional, {
-      silentJSONParsing: validators.transitional(validators.boolean, '1.0.0'),
-      forcedJSONParsing: validators.transitional(validators.boolean, '1.0.0'),
-      clarifyTimeoutError: validators.transitional(validators.boolean, '1.0.0')
+      silentJSONParsing: validators.transitional(validators.boolean),
+      forcedJSONParsing: validators.transitional(validators.boolean),
+      clarifyTimeoutError: validators.transitional(validators.boolean)
     }, false);
   }
 
@@ -1617,7 +1879,8 @@ Axios.prototype.request = function request(config) {
 
 Axios.prototype.getUri = function getUri(config) {
   config = mergeConfig(this.defaults, config);
-  return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, '');
+  var fullPath = buildFullPath(config.baseURL, config.url);
+  return buildURL(fullPath, config.params, config.paramsSerializer);
 };
 
 // Provide aliases for supported request methods
@@ -1634,34 +1897,30 @@ utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData
 
 utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
   /*eslint func-names:0*/
-  Axios.prototype[method] = function(url, data, config) {
-    return this.request(mergeConfig(config || {}, {
-      method: method,
-      url: url,
-      data: data
-    }));
-  };
+
+  function generateHTTPMethod(isForm) {
+    return function httpMethod(url, data, config) {
+      return this.request(mergeConfig(config || {}, {
+        method: method,
+        headers: isForm ? {
+          'Content-Type': 'multipart/form-data'
+        } : {},
+        url: url,
+        data: data
+      }));
+    };
+  }
+
+  Axios.prototype[method] = generateHTTPMethod();
+
+  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);
 });
 
 var Axios_1 = Axios;
 
-/**
- * A `Cancel` is an object that is thrown when an operation is canceled.
- *
- * @class
- * @param {string=} message The message.
- */
-function Cancel(message) {
-  this.message = message;
-}
-
-Cancel.prototype.toString = function toString() {
-  return 'Cancel' + (this.message ? ': ' + this.message : '');
-};
+'use strict';
 
-Cancel.prototype.__CANCEL__ = true;
 
-var Cancel_1 = Cancel;
 
 /**
  * A `CancelToken` is an object that can be used to request cancellation of an operation.
@@ -1675,24 +1934,55 @@ function CancelToken(executor) {
   }
 
   var resolvePromise;
+
   this.promise = new Promise(function promiseExecutor(resolve) {
     resolvePromise = resolve;
   });
 
   var token = this;
+
+  // eslint-disable-next-line func-names
+  this.promise.then(function(cancel) {
+    if (!token._listeners) return;
+
+    var i;
+    var l = token._listeners.length;
+
+    for (i = 0; i < l; i++) {
+      token._listeners[i](cancel);
+    }
+    token._listeners = null;
+  });
+
+  // eslint-disable-next-line func-names
+  this.promise.then = function(onfulfilled) {
+    var _resolve;
+    // eslint-disable-next-line func-names
+    var promise = new Promise(function(resolve) {
+      token.subscribe(resolve);
+      _resolve = resolve;
+    }).then(onfulfilled);
+
+    promise.cancel = function reject() {
+      token.unsubscribe(_resolve);
+    };
+
+    return promise;
+  };
+
   executor(function cancel(message) {
     if (token.reason) {
       // Cancellation has already been requested
       return;
     }
 
-    token.reason = new Cancel_1(message);
+    token.reason = new CanceledError_1(message);
     resolvePromise(token.reason);
   });
 }
 
 /**
- * Throws a `Cancel` if cancellation has been requested.
+ * Throws a `CanceledError` if cancellation has been requested.
  */
 CancelToken.prototype.throwIfRequested = function throwIfRequested() {
   if (this.reason) {
@@ -1700,6 +1990,37 @@ CancelToken.prototype.throwIfRequested = function throwIfRequested() {
   }
 };
 
+/**
+ * Subscribe to the cancel signal
+ */
+
+CancelToken.prototype.subscribe = function subscribe(listener) {
+  if (this.reason) {
+    listener(this.reason);
+    return;
+  }
+
+  if (this._listeners) {
+    this._listeners.push(listener);
+  } else {
+    this._listeners = [listener];
+  }
+};
+
+/**
+ * Unsubscribe from the cancel signal
+ */
+
+CancelToken.prototype.unsubscribe = function unsubscribe(listener) {
+  if (!this._listeners) {
+    return;
+  }
+  var index = this._listeners.indexOf(listener);
+  if (index !== -1) {
+    this._listeners.splice(index, 1);
+  }
+};
+
 /**
  * Returns an object that contains a new `CancelToken` and a function that, when called,
  * cancels the `CancelToken`.
@@ -1717,6 +2038,8 @@ CancelToken.source = function source() {
 
 var CancelToken_1 = CancelToken;
 
+'use strict';
+
 /**
  * Syntactic sugar for invoking a function and expanding an array for arguments.
  *
@@ -1743,6 +2066,10 @@ var spread = function spread(callback) {
   };
 };
 
+'use strict';
+
+
+
 /**
  * Determines whether the payload is an error thrown by Axios
  *
@@ -1750,9 +2077,17 @@ var spread = function spread(callback) {
  * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
  */
 var isAxiosError = function isAxiosError(payload) {
-  return (typeof payload === 'object') && (payload.isAxiosError === true);
+  return utils.isObject(payload) && (payload.isAxiosError === true);
 };
 
+'use strict';
+
+
+
+
+
+
+
 /**
  * Create an instance of Axios
  *
@@ -1769,6 +2104,11 @@ function createInstance(defaultConfig) {
   // Copy context to instance
   utils.extend(instance, context);
 
+  // Factory for creating new instances
+  instance.create = function create(instanceConfig) {
+    return createInstance(mergeConfig(defaultConfig, instanceConfig));
+  };
+
   return instance;
 }
 
@@ -1778,15 +2118,18 @@ var axios$1 = createInstance(defaults_1);
 // Expose Axios class to allow class inheritance
 axios$1.Axios = Axios_1;
 
-// Factory for creating new instances
-axios$1.create = function create(instanceConfig) {
-  return createInstance(mergeConfig(axios$1.defaults, instanceConfig));
-};
-
 // Expose Cancel & CancelToken
-axios$1.Cancel = Cancel_1;
+axios$1.CanceledError = CanceledError_1;
 axios$1.CancelToken = CancelToken_1;
 axios$1.isCancel = isCancel;
+axios$1.VERSION = data.version;
+axios$1.toFormData = toFormData_1;
+
+// Expose AxiosError class
+axios$1.AxiosError = AxiosError_1;
+
+// alias for CanceledError for backward compatibility
+axios$1.Cancel = axios$1.CanceledError;
 
 // Expose all/spread
 axios$1.all = function all(promises) {
@@ -1805,6 +2148,147 @@ axios_1.default = _default;
 
 var axios = axios_1;
 
+var requestLogger = function (r) {
+    // tslint:disable-next-line
+    console.debug("[JS-SDK] ".concat(r.method.toUpperCase(), " ").concat(r.baseURL).concat(r.url), r.data ? JSON.stringify(r.data) : '');
+    return r;
+};
+/**
+ * VerdocsEndpoint is a class wrapper for a specific connection and authorization context for calling the Verdocs APIs.
+ * Endpoints can be used for isolated session tasks.
+ * For instance, ephemeral signing sessions may be created independently of a caller's status as an authenticated user.
+ * In that case, an Endpoint can be created and authenticated, used for calls related to signing operations, then
+ * discarded once signing is complete.
+ *
+ * Note that endpoint configuration functions return the instance, so they can be chained, e.g.
+ *
+ * ```typescript
+ * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+ *
+ * const endpoint = new VerdocsEndpoint();
+ * endpoint
+ *     .logRequests(true)
+ *     .setClientID('1234)
+ *     .setTimeout(5000);
+ * ```
+ */
+var VerdocsEndpoint = /** @class */ (function () {
+    /**
+     * Create a new VerdocsEndpoint to call Verdocs platform services.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     * const endpoint = new VerdocsEndpoint();
+     * ```
+     */
+    function VerdocsEndpoint() {
+        this.requestLoggerId = null;
+        this.api = axios.create({ baseURL: 'https://api.verdocs.com', timeout: 3000 });
+    }
+    /**
+     * Set the timeout for API calls in milliseconds. 2000-4000ms is recommended for most purposes. 3000ms is the default.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setTimeout(3000);
+     * ```
+     */
+    VerdocsEndpoint.prototype.setTimeout = function (timeout) {
+        this.api.defaults.timeout = timeout;
+        return this;
+    };
+    /**
+     * Set the Client ID for Verdocs API calls.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setClientID('1234);
+     * ```
+     */
+    VerdocsEndpoint.prototype.setClientID = function (clientID) {
+        this.api.defaults.headers.common['X-Client-ID'] = clientID;
+        return this;
+    };
+    /**
+     * Set the auth token that will be used for Verdocs API calls.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setAuthorization(accessToken);
+     * ```
+     */
+    VerdocsEndpoint.prototype.setAuthorization = function (accessToken) {
+        if (accessToken) {
+            this.api.defaults.headers.common.Authorization = "Bearer ".concat(accessToken);
+        }
+        else {
+            delete this.api.defaults.headers.common.Authorization;
+        }
+        return this;
+    };
+    /**
+     * Set the auth token used for signing sessions. Separating user from signing auth allows the same endpoint to be
+     * used for multiple operations, although it is recommended that a separate endpoint be created for each operation.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setSigningAuthorization(accessToken);
+     * ```
+     */
+    VerdocsEndpoint.prototype.setSigningAuthorization = function (accessToken) {
+        if (accessToken) {
+            this.api.defaults.headers.common.signer = "Bearer ".concat(accessToken);
+        }
+        else {
+            delete this.api.defaults.headers.common.signer;
+        }
+        return this;
+    };
+    /**
+     * Set the base URL for API calls. May also be set via the constructor.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setBaseURL('https://api.verdocs.com');
+     * ```
+     */
+    VerdocsEndpoint.prototype.setBaseURL = function (url) {
+        this.api.defaults.baseURL = url;
+        return this;
+    };
+    /**
+     * Enable or disable request logging. This may expose sensitive data in the console log, so it should only be used for debugging.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.logRequests(true);
+     * ```
+     */
+    VerdocsEndpoint.prototype.logRequests = function (enable) {
+        if (enable && this.requestLoggerId === null) {
+            this.requestLoggerId = this.api.interceptors.request.use(requestLogger);
+        }
+        else if (!enable && this.requestLoggerId !== null) {
+            this.api.interceptors.request.eject(this.requestLoggerId);
+        }
+        return this;
+    };
+    return VerdocsEndpoint;
+}());
+
+"use strict";
 // This file provides a polyfill for managing globals in both NodeJS and browser environments. This is
 // an anti-pattern we'd hoped to avoid, but we have several projects dependending on one common library
 // (this js-sdk) and we want that library to provide a common endpoint to all callers (so authentication
@@ -1858,23 +2342,20 @@ var globalThis_1 = (function () {
 })();
 
 /**
- * The Transport Endpoint is a global singleton used to call Verdocs APIs. There can only be one Endpoint per application, and
- * its configuration settings are shared for all callers.
+ * The Transport is a global singleton used to call Verdocs APIs. There can only be one Transport per application, and
+ * its configuration settings are shared for all callers. This is a simplified form of the Endpoint class where most
+ * tasks such as general session-token-management are handled automatically for the caller.
  *
  * @module
  */
-var DEFAULTS = {
-    baseURL: 'https://api.verdocs.com/',
-    timeout: 6000,
-    headers: { 'X-Client-ID': 'NONE' },
-};
 // @credit https://derickbailey.com/2016/03/09/creating-a-true-singleton-in-node-js-with-es6-symbols/
 // Also see globalThis for comments about why we're doing this in the first place.
 var ENDPOINT_KEY = Symbol.for('verdocs-api-endpoint');
 if (!globalThis_1[ENDPOINT_KEY]) {
-    globalThis_1[ENDPOINT_KEY] = axios.create(DEFAULTS);
+    globalThis_1[ENDPOINT_KEY] = new VerdocsEndpoint();
 }
-var endpoint = globalThis_1[ENDPOINT_KEY];
+var globalEndpoint = globalThis_1[ENDPOINT_KEY];
+var activeEndpoint = globalEndpoint;
 /**
  * Helper to get the endpoint for direct access to HTTP functions.
  *
@@ -1885,68 +2366,93 @@ var endpoint = globalThis_1[ENDPOINT_KEY];
  * ```
  */
 var getEndpoint = function () {
-    return endpoint;
+    return activeEndpoint;
 };
-
 /**
- * Verdocs provides a range of search functions to help find and retrieve content. This module provides generic functions intended
- * to locate items across all content types. More specific retrievals may be performed using the various "list" endpoints within
- * each collection (e.g. {@link Documents.Documents.searchDocuments} or {@link Templates.Templates.searchTemplates}).
+ * Change the endpoint that will be used when making calls to Verdocs. Only one endpoint may be active at a time.
+ * Authorization and other configuration data is specific to each endpoint, and will not be carried over when the
+ * endpoint is changed. The typical use-case is to change to a sandboxed endpoint for signing sessions, then revert
+ * to the global endpoint when the signing session is complete. To revert, pass `null` as the endpoint to use.
  *
- * @module
+ * ```typescript
+ * import {Transport} from '@verdocs/js-sdk/HTTP';
+ *
+ * const mySigningEndpoint = new VerdocsEndpoint();
+ * setActiveEndpoint(mySigningEndpoint);
+ * ... [Perform signing operations]
+ * setActiveEndpoint(null);
+ * ```
  */
-var __awaiter = (undefined && undefined.__awaiter) || function (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());
-    });
+var setActiveEndpoint = function (e) {
+    activeEndpoint = e || globalEndpoint;
 };
-var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+
+/* tslint:disable:no-bitwise */
+var b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+// Regular expression to check formal correctness of base64 encoded strings
+var b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
+/**
+ * Simplified, Node/Browser-safe alternative to atob() for base64 decoding.
+ * Modified from https://github.com/MaxArt2501/base64-js/blob/master/base64.js
+ */
+var AtoB = function (str) {
+    // atob can work with strings with whitespaces, even inside the encoded part,
+    // but only \t, \n, \f, \r and ' ', which can be stripped.
+    str = String(str).replace(/[\t\n\f\r ]+/g, '');
+    if (!b64re.test(str))
+        throw new TypeError("Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.");
+    // Adding the padding if missing, for semplicity
+    str += '=='.slice(2 - (str.length & 3));
+    var bitmap;
+    var result = '';
+    var r1;
+    var r2;
+    var i = 0;
+    for (; i < str.length;) {
+        bitmap =
+            (b64.indexOf(str.charAt(i++)) << 18) |
+                (b64.indexOf(str.charAt(i++)) << 12) |
+                ((r1 = b64.indexOf(str.charAt(i++))) << 6) |
+                (r2 = b64.indexOf(str.charAt(i++)));
+        result +=
+            r1 === 64
+                ? String.fromCharCode((bitmap >> 16) & 255)
+                : r2 === 64
+                    ? String.fromCharCode((bitmap >> 16) & 255, (bitmap >> 8) & 255)
+                    : String.fromCharCode((bitmap >> 16) & 255, (bitmap >> 8) & 255, bitmap & 255);
     }
+    return result;
 };
 /**
- * Retrieve recent and saved searches. Note that result counts will be limited to a maximum of 20 entries for each
- * type but this may be expanded in the future. Client UI's should self-limit display counts as needed.
- *
- * ```typescript
- * import {Content} from '@verdocs/js-sdk/Search';
- *
- * const {recent, saved} = await Content.getSearchHistory();
- * ```
+ * Decode the body of a JWT. This helper may allow front-end applications to avoid a dependency on `jsonwebtoken` in
+ * many cases. Note that this should only be used for true JWTs. Opaque tokens will cause this to throw.
+ */
+var decodeTokenBody = function (token) { return JSON.parse(AtoB((token || '').split('.')[1] || '')); };
+/**
+ * Decode the body of an Verdocs access token. Note that raw tokens contain namespaced fields, e.g.
+ * `https://verdocs.com/profile_id`. To make these tokens easier to use in front-end code, this name-spacing
+ * will be removed. Note that user and signing sessions have different access token formats. The calling
+ * application should distinguish between the two based on the context of the authenticated session, or by
+ * the presence of the `document_id` field, which will only be present for signing sessions.
  */
-var getSearchHistory = function () { return __awaiter(void 0, void 0, void 0, function () {
-    return __generator(this, function (_a) {
-        return [2 /*return*/, getEndpoint()
-                .get('/search/history')
-                .then(function (r) { return r.data; })];
+var decodeAccessTokenBody = function (token) {
+    var decoded;
+    try {
+        decoded = decodeTokenBody(token);
+        if (decoded === null) {
+            return null;
+        }
+    }
+    catch (e) {
+        return null;
+    }
+    Object.keys(decoded).forEach(function (key) {
+        if (typeof key === 'string' && key.startsWith('https://verdocs.com/')) {
+            decoded[key.replace('https://verdocs.com/', '')] = decoded[key];
+            delete decoded[key];
+        }
     });
-}); };
+    return decoded;
+};
 
-exports.getSearchHistory = getSearchHistory;
+export { VerdocsEndpoint as V, decodeAccessTokenBody as d, getEndpoint as g, setActiveEndpoint as s };