extractia-sdk 1.3.0 → 1.4.0

package/dist/extractia-sdk.cjs.js

@@ -85,30 +85,42 @@ var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")])
 var index_exports = {};
 __export(index_exports, {
   AuthError: () => AuthError,
+  ConflictError: () => ConflictError,
   ExtractiaError: () => ExtractiaError,
   ForbiddenError: () => ForbiddenError,
+  NetworkError: () => NetworkError,
   NotFoundError: () => NotFoundError,
+  QuotaError: () => QuotaError,
   RateLimitError: () => RateLimitError,
+  ServerError: () => ServerError,
   TierError: () => TierError,
+  TimeoutError: () => TimeoutError,
+  ValidationError: () => ValidationError,
   bulkPreconform: () => bulkPreconform,
+  clearToken: () => clearToken,
   configure: () => configure,
   createOcrTool: () => createOcrTool,
   createSubUser: () => createSubUser,
   createTemplate: () => createTemplate,
   default: () => index_default,
+  delay: () => delay,
   deleteAllTemplateDocuments: () => deleteAllTemplateDocuments,
   deleteDocument: () => deleteDocument,
   deleteOcrTool: () => deleteOcrTool,
   deleteSubUser: () => deleteSubUser,
   deleteTemplate: () => deleteTemplate,
+  ensureBase64: () => ensureBase64,
   exportDocumentsCsv: () => exportDocumentsCsv,
   exportDocumentsJson: () => exportDocumentsJson,
+  fileToBase64: () => fileToBase64,
   generateDocumentSummary: () => generateDocumentSummary,
+  getConfig: () => getConfig,
   getCreditsBalance: () => getCreditsBalance,
   getCreditsHistory: () => getCreditsHistory,
   getDocumentById: () => getDocumentById,
   getDocumentHistory: () => getDocumentHistory,
   getDocumentsByTemplateId: () => getDocumentsByTemplateId,
+  getMimeType: () => getMimeType,
   getMyProfile: () => getMyProfile,
   getOcrTools: () => getOcrTools,
   getRecentDocuments: () => getRecentDocuments,
@@ -116,10 +128,17 @@ __export(index_exports, {
   getTemplateById: () => getTemplateById,
   getTemplateByName: () => getTemplateByName,
   getTemplates: () => getTemplates,
+  getToken: () => getToken,
+  hasToken: () => hasToken,
+  isBase64: () => isBase64,
+  mapAxiosError: () => mapAxiosError,
+  paginate: () => paginate,
+  paginateAll: () => paginateAll,
   processImage: () => processImage,
   processImagesMultipage: () => processImagesMultipage,
   runOcrTool: () => runOcrTool,
   setToken: () => setToken,
+  stripDataUrlPrefix: () => stripDataUrlPrefix,
   suggestFields: () => suggestFields,
   toggleSuspendSubUser: () => toggleSuspendSubUser,
   updateDocumentData: () => updateDocumentData,
@@ -128,7 +147,8 @@ __export(index_exports, {
   updateOcrTool: () => updateOcrTool,
   updateSubUser: () => updateSubUser,
   updateTemplate: () => updateTemplate,
-  updateWebhook: () => updateWebhook
+  updateWebhook: () => updateWebhook,
+  withRetry: () => withRetry
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -436,15 +456,15 @@ var _setImmediate = ((setImmediateSupported, postMessageSupported) => {
   if (setImmediateSupported) {
     return setImmediate;
   }
-  return postMessageSupported ? ((token2, callbacks) => {
+  return postMessageSupported ? ((token, callbacks) => {
     _global.addEventListener("message", ({ source, data }) => {
-      if (source === _global && data === token2) {
+      if (source === _global && data === token) {
         callbacks.length && callbacks.shift()();
       }
     }, false);
     return (cb) => {
       callbacks.push(cb);
-      _global.postMessage(token2, "*");
+      _global.postMessage(token, "*");
     };
   })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
 })(
@@ -600,9 +620,9 @@ function removeBrackets(key) {
 }
 function renderKey(path, key, dots) {
   if (!path) return key;
-  return path.concat(key).map(function each(token2, i) {
-    token2 = removeBrackets(token2);
-    return !dots && i ? "[" + token2 + "]" : token2;
+  return path.concat(key).map(function each(token, i) {
+    token = removeBrackets(token);
+    return !dots && i ? "[" + token + "]" : token;
   }).join(dots ? "." : "");
 }
 function isFlatArray(arr) {
@@ -1645,7 +1665,7 @@ var resolveConfig_default = (config) => {
     if (platform_default.hasStandardBrowserEnv || platform_default.hasStandardBrowserWebWorkerEnv) {
       headers.setContentType(void 0);
     } else if ((contentType = headers.getContentType()) !== false) {
-      const [type, ...tokens] = contentType ? contentType.split(";").map((token2) => token2.trim()).filter(Boolean) : [];
+      const [type, ...tokens] = contentType ? contentType.split(";").map((token) => token.trim()).filter(Boolean) : [];
       headers.setContentType([type || "multipart/form-data", ...tokens].join("; "));
     }
   }
@@ -1665,22 +1685,22 @@ var resolveConfig_default = (config) => {
 var isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
 var xhr_default = isXHRAdapterSupported && function(config) {
   return new Promise(function dispatchXhrRequest(resolve, reject) {
-    const _config = resolveConfig_default(config);
-    let requestData = _config.data;
-    const requestHeaders = AxiosHeaders_default.from(_config.headers).normalize();
-    let { responseType, onUploadProgress, onDownloadProgress } = _config;
+    const _config2 = resolveConfig_default(config);
+    let requestData = _config2.data;
+    const requestHeaders = AxiosHeaders_default.from(_config2.headers).normalize();
+    let { responseType, onUploadProgress, onDownloadProgress } = _config2;
     let onCanceled;
     let uploadThrottled, downloadThrottled;
     let flushUpload, flushDownload;
     function done() {
       flushUpload && flushUpload();
       flushDownload && flushDownload();
-      _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
-      _config.signal && _config.signal.removeEventListener("abort", onCanceled);
+      _config2.cancelToken && _config2.cancelToken.unsubscribe(onCanceled);
+      _config2.signal && _config2.signal.removeEventListener("abort", onCanceled);
     }
     let request = new XMLHttpRequest();
-    request.open(_config.method.toUpperCase(), _config.url, true);
-    request.timeout = _config.timeout;
+    request.open(_config2.method.toUpperCase(), _config2.url, true);
+    request.timeout = _config2.timeout;
     function onloadend() {
       if (!request) {
         return;
@@ -1731,10 +1751,10 @@ var xhr_default = isXHRAdapterSupported && function(config) {
       request = null;
     };
     request.ontimeout = function handleTimeout() {
-      let timeoutErrorMessage = _config.timeout ? "timeout of " + _config.timeout + "ms exceeded" : "timeout exceeded";
-      const transitional2 = _config.transitional || transitional_default;
-      if (_config.timeoutErrorMessage) {
-        timeoutErrorMessage = _config.timeoutErrorMessage;
+      let timeoutErrorMessage = _config2.timeout ? "timeout of " + _config2.timeout + "ms exceeded" : "timeout exceeded";
+      const transitional2 = _config2.transitional || transitional_default;
+      if (_config2.timeoutErrorMessage) {
+        timeoutErrorMessage = _config2.timeoutErrorMessage;
       }
       reject(new AxiosError_default(
         timeoutErrorMessage,
@@ -1750,11 +1770,11 @@ var xhr_default = isXHRAdapterSupported && function(config) {
         request.setRequestHeader(key, val);
       });
     }
-    if (!utils_default.isUndefined(_config.withCredentials)) {
-      request.withCredentials = !!_config.withCredentials;
+    if (!utils_default.isUndefined(_config2.withCredentials)) {
+      request.withCredentials = !!_config2.withCredentials;
     }
     if (responseType && responseType !== "json") {
-      request.responseType = _config.responseType;
+      request.responseType = _config2.responseType;
     }
     if (onDownloadProgress) {
       [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);
@@ -1765,7 +1785,7 @@ var xhr_default = isXHRAdapterSupported && function(config) {
       request.upload.addEventListener("progress", uploadThrottled);
       request.upload.addEventListener("loadend", flushUpload);
     }
-    if (_config.cancelToken || _config.signal) {
+    if (_config2.cancelToken || _config2.signal) {
       onCanceled = (cancel) => {
         if (!request) {
           return;
@@ -1774,12 +1794,12 @@ var xhr_default = isXHRAdapterSupported && function(config) {
         request.abort();
         request = null;
       };
-      _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
-      if (_config.signal) {
-        _config.signal.aborted ? onCanceled() : _config.signal.addEventListener("abort", onCanceled);
+      _config2.cancelToken && _config2.cancelToken.subscribe(onCanceled);
+      if (_config2.signal) {
+        _config2.signal.aborted ? onCanceled() : _config2.signal.addEventListener("abort", onCanceled);
       }
     }
-    const protocol = parseProtocol(_config.url);
+    const protocol = parseProtocol(_config2.url);
     if (protocol && platform_default.protocols.indexOf(protocol) === -1) {
       reject(new AxiosError_default("Unsupported protocol " + protocol + ":", AxiosError_default.ERR_BAD_REQUEST, config));
       return;
@@ -2429,32 +2449,32 @@ var CancelToken = class _CancelToken {
     this.promise = new Promise(function promiseExecutor(resolve) {
       resolvePromise = resolve;
     });
-    const token2 = this;
+    const token = this;
     this.promise.then((cancel) => {
-      if (!token2._listeners) return;
-      let i = token2._listeners.length;
+      if (!token._listeners) return;
+      let i = token._listeners.length;
       while (i-- > 0) {
-        token2._listeners[i](cancel);
+        token._listeners[i](cancel);
       }
-      token2._listeners = null;
+      token._listeners = null;
     });
     this.promise.then = (onfulfilled) => {
       let _resolve;
       const promise = new Promise((resolve) => {
-        token2.subscribe(resolve);
+        token.subscribe(resolve);
         _resolve = resolve;
       }).then(onfulfilled);
       promise.cancel = function reject() {
-        token2.unsubscribe(_resolve);
+        token.unsubscribe(_resolve);
       };
       return promise;
     };
     executor(function cancel(message, config, request) {
-      if (token2.reason) {
+      if (token.reason) {
         return;
       }
-      token2.reason = new CanceledError_default(message, config, request);
-      resolvePromise(token2.reason);
+      token.reason = new CanceledError_default(message, config, request);
+      resolvePromise(token.reason);
     });
   }
   /**
@@ -2506,11 +2526,11 @@ var CancelToken = class _CancelToken {
    */
   static source() {
     let cancel;
-    const token2 = new _CancelToken(function executor(c) {
+    const token = new _CancelToken(function executor(c) {
       cancel = c;
     });
     return {
-      token: token2,
+      token,
       cancel
     };
   }
@@ -2654,93 +2674,347 @@ var {
 } = axios_default;
 
 // src/errors.js
+var STATUS_MESSAGES = {
+  400: "The request contains invalid data. Please check your input.",
+  401: "Your API token is invalid or has expired. Please check your credentials.",
+  402: "Your current plan does not support this feature or your document quota is exhausted.",
+  403: "You do not have permission to perform this action.",
+  404: "The requested resource could not be found.",
+  409: "A resource with this identifier already exists.",
+  429: "Too many requests. Please wait a moment and try again.",
+  500: "The server encountered an unexpected error. Please try again in a moment.",
+  502: "The server received an unexpected response. Please try again.",
+  503: "The service is temporarily unavailable. Please try again in a few minutes.",
+  504: "The server timed out while processing the request. Please try again."
+};
 var ExtractiaError = class extends Error {
-  /** @param {string} message @param {number} status */
-  constructor(message, status) {
+  /**
+   * @param {string} message    — Technical detail string.
+   * @param {number} [status]   — HTTP status code (0 = no response).
+   * @param {string} [userMessage] — Human-friendly sentence shown to end users.
+   * @param {string} [code]     — Machine-readable error code.
+   */
+  constructor(message, status = 0, userMessage = null, code = "SDK_ERROR") {
     super(message);
     this.name = "ExtractiaError";
     this.status = status;
+    this.userMessage = userMessage != null ? userMessage : message;
+    this.code = code;
+    this.requestId = null;
+  }
+  /** Returns true if automatically retrying the same request may succeed. */
+  isRetryable() {
+    return this.status === 429 || this.status >= 500;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      status: this.status,
+      message: this.message,
+      userMessage: this.userMessage,
+      requestId: this.requestId
+    };
   }
 };
 var AuthError = class extends ExtractiaError {
-  constructor(message = "Unauthorized. Check your API token.") {
-    super(message, 401);
+  constructor(message = STATUS_MESSAGES[401]) {
+    super(message, 401, STATUS_MESSAGES[401], "AUTH_ERROR");
     this.name = "AuthError";
   }
 };
 var ForbiddenError = class extends ExtractiaError {
-  constructor(message = "Forbidden. Insufficient permissions.") {
-    super(message, 403);
+  constructor(message = STATUS_MESSAGES[403]) {
+    super(message, 403, STATUS_MESSAGES[403], "FORBIDDEN");
     this.name = "ForbiddenError";
   }
 };
 var TierError = class extends ExtractiaError {
-  constructor(message = "Tier limit reached. Upgrade your plan.", status = 402) {
-    super(message, status);
+  constructor(message = STATUS_MESSAGES[402], status = 402) {
+    super(message, status, STATUS_MESSAGES[402], "TIER_LIMIT");
     this.name = "TierError";
   }
 };
+var QuotaError = class extends ExtractiaError {
+  constructor(message = "You have reached your document processing quota for this billing period. Please upgrade or wait for the next cycle.") {
+    super(message, 402, message, "QUOTA_EXCEEDED");
+    this.name = "QuotaError";
+  }
+};
 var RateLimitError = class extends ExtractiaError {
-  constructor(message = "Too many requests. Please slow down.") {
-    super(message, 429);
+  /**
+   * @param {string} [message]
+   * @param {number|null} [retryAfter] — Seconds to wait before retrying (from Retry-After header).
+   */
+  constructor(message = STATUS_MESSAGES[429], retryAfter = null) {
+    super(message, 429, STATUS_MESSAGES[429], "RATE_LIMITED");
     this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+  isRetryable() {
+    return true;
   }
 };
 var NotFoundError = class extends ExtractiaError {
-  constructor(message = "Resource not found.") {
-    super(message, 404);
+  constructor(message = STATUS_MESSAGES[404]) {
+    super(message, 404, STATUS_MESSAGES[404], "NOT_FOUND");
     this.name = "NotFoundError";
   }
 };
+var ValidationError = class extends ExtractiaError {
+  /**
+   * @param {string}                    [message]
+   * @param {Record<string,string>|null} [fields] — Field-level errors, if the server provides them.
+   */
+  constructor(message = STATUS_MESSAGES[400], fields = null) {
+    super(message, 400, STATUS_MESSAGES[400], "VALIDATION_ERROR");
+    this.name = "ValidationError";
+    this.fields = fields;
+  }
+};
+var ConflictError = class extends ExtractiaError {
+  constructor(message = STATUS_MESSAGES[409]) {
+    super(message, 409, STATUS_MESSAGES[409], "CONFLICT");
+    this.name = "ConflictError";
+  }
+};
+var ServerError = class extends ExtractiaError {
+  constructor(message = STATUS_MESSAGES[500], status = 500) {
+    var _a;
+    super(
+      message,
+      status,
+      (_a = STATUS_MESSAGES[status]) != null ? _a : STATUS_MESSAGES[500],
+      "SERVER_ERROR"
+    );
+    this.name = "ServerError";
+  }
+  isRetryable() {
+    return true;
+  }
+};
+var NetworkError = class extends ExtractiaError {
+  constructor(message = "Unable to reach the Extractia API. Please check your network connection and try again.") {
+    super(message, 0, message, "NETWORK_ERROR");
+    this.name = "NetworkError";
+  }
+  isRetryable() {
+    return true;
+  }
+};
+var TimeoutError = class extends ExtractiaError {
+  constructor(message = "The request timed out. The server may be under heavy load \u2014 please try again in a moment.") {
+    super(message, 0, message, "TIMEOUT");
+    this.name = "TimeoutError";
+  }
+  isRetryable() {
+    return true;
+  }
+};
+function extractServerDetail(data) {
+  var _a, _b, _c, _d, _e;
+  if (!data) return null;
+  if (typeof data === "string" && data.trim()) return data.trim();
+  if (typeof data === "object") {
+    const msg = (_c = (_b = (_a = data.message) != null ? _a : data.error) != null ? _b : data.detail) != null ? _c : data.title;
+    if (msg && typeof msg === "string") return msg.trim();
+    if (Array.isArray(data.errors) && data.errors.length > 0) {
+      const first = data.errors[0];
+      return typeof first === "string" ? first : (_e = (_d = first.message) != null ? _d : first.msg) != null ? _e : JSON.stringify(first);
+    }
+    if (Array.isArray(data.fieldErrors) && data.fieldErrors.length > 0) {
+      return data.fieldErrors.map((e) => {
+        var _a2, _b2;
+        return `${(_a2 = e.field) != null ? _a2 : "field"}: ${(_b2 = e.message) != null ? _b2 : e.defaultMessage}`;
+      }).join("; ");
+    }
+  }
+  return null;
+}
 function mapAxiosError(err) {
-  var _a, _b;
-  const status = (_a = err.response) == null ? void 0 : _a.status;
-  const serverMessage = (_b = err.response) == null ? void 0 : _b.data;
-  const detail = typeof serverMessage === "string" ? serverMessage : void 0;
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  if (!err.response) {
+    if (err.code === "ECONNABORTED" || err.code === "ETIMEDOUT" || err.message && err.message.toLowerCase().includes("timeout")) {
+      return new TimeoutError();
+    }
+    return new NetworkError(err.message || void 0);
+  }
+  const status = err.response.status;
+  const detail = extractServerDetail(err.response.data);
+  const userMessage = (_a = STATUS_MESSAGES[status]) != null ? _a : status >= 500 ? STATUS_MESSAGES[500] : "Something went wrong. Please try again.";
+  let error;
   switch (status) {
+    case 400: {
+      const body = err.response.data;
+      const fields = (_b = body == null ? void 0 : body.fields) != null ? _b : Array.isArray(body == null ? void 0 : body.fieldErrors) ? Object.fromEntries(
+        body.fieldErrors.map((f) => {
+          var _a2;
+          return [f.field, (_a2 = f.message) != null ? _a2 : f.defaultMessage];
+        })
+      ) : null;
+      error = new ValidationError(detail != null ? detail : STATUS_MESSAGES[400], fields);
+      break;
+    }
     case 401:
-      return new AuthError(detail);
+      error = new AuthError(detail != null ? detail : void 0);
+      break;
     case 402:
-      return new TierError(detail);
+      if (detail && (detail.toLowerCase().includes("quota") || detail.toLowerCase().includes("document") || detail.toLowerCase().includes("limit reached"))) {
+        error = new QuotaError(detail);
+      } else {
+        error = new TierError(detail != null ? detail : void 0);
+      }
+      break;
     case 403:
-      return new ForbiddenError(detail);
+      error = new ForbiddenError(detail != null ? detail : void 0);
+      break;
     case 404:
-      return new NotFoundError(detail);
-    case 429:
-      return new RateLimitError(detail);
+      error = new NotFoundError(detail != null ? detail : void 0);
+      break;
+    case 409:
+      error = new ConflictError(detail != null ? detail : void 0);
+      break;
+    case 429: {
+      const retryAfterHeader = (_c = err.response.headers) == null ? void 0 : _c["retry-after"];
+      const retryAfter = retryAfterHeader != null ? parseInt(retryAfterHeader, 10) : null;
+      error = new RateLimitError(detail != null ? detail : void 0, isNaN(retryAfter) ? null : retryAfter);
+      break;
+    }
     default:
-      return new ExtractiaError(detail != null ? detail : err.message, status != null ? status : 0);
+      if (status >= 500) {
+        error = new ServerError((_d = detail != null ? detail : STATUS_MESSAGES[status]) != null ? _d : STATUS_MESSAGES[500], status);
+      } else {
+        error = new ExtractiaError(
+          detail != null ? detail : err.message,
+          status,
+          userMessage,
+          `HTTP_${status}`
+        );
+      }
   }
+  error.userMessage = userMessage;
+  const reqId = (_h = (_g = (_e = err.response.headers) == null ? void 0 : _e["x-request-id"]) != null ? _g : (_f = err.response.headers) == null ? void 0 : _f["x-correlation-id"]) != null ? _h : null;
+  if (reqId) error.requestId = reqId;
+  return error;
 }
 
 // src/apiClient.js
-var token = null;
-var DEFAULT_BASE_URL = "https://api.extractia.info/api/public";
-var api = axios_default.create({
-  baseURL: DEFAULT_BASE_URL,
-  timeout: 6e4
-  // 60s — AI processing can take 10–30s
+var _token = null;
+var _config = {
+  baseURL: "https://api.extractia.info/api/public",
+  timeout: 6e4,
+  retries: 1,
+  retryDelay: 1e3,
+  debug: false,
+  defaultHeaders: {},
+  onBeforeRequest: null,
+  onAfterResponse: null,
+  onError: null
+};
+var _api = axios_default.create({
+  baseURL: _config.baseURL,
+  timeout: _config.timeout
 });
-api.interceptors.request.use((config) => {
-  if (!token) {
-    throw new Error(
-      "API token is required. Call setToken(yourApiToken) before making requests."
+_api.interceptors.request.use((config) => {
+  var _a, _b, _c, _d, _e;
+  if (!_token) {
+    const err = new ExtractiaError(
+      "API token not set. Call setToken(token) before making requests.",
+      0,
+      "API token not set. Call setToken(token) before making requests.",
+      "TOKEN_MISSING"
     );
+    return Promise.reject(err);
+  }
+  config.headers = (_a = config.headers) != null ? _a : {};
+  config.headers["Authorization"] = `Bearer ${_token}`;
+  Object.assign(config.headers, _config.defaultHeaders);
+  if (_config.debug) {
+    console.debug(
+      `[ExtractIA SDK] \u2192 ${((_b = config.method) != null ? _b : "GET").toUpperCase()} ${(_c = config.baseURL) != null ? _c : ""}${(_d = config.url) != null ? _d : ""}`,
+      (_e = config.params) != null ? _e : ""
+    );
+  }
+  if (typeof _config.onBeforeRequest === "function") {
+    const modified = _config.onBeforeRequest(config);
+    return modified != null ? modified : config;
   }
-  config.headers.Authorization = `Bearer ${token}`;
   return config;
 });
-api.interceptors.response.use(
-  (response) => response,
-  (err) => Promise.reject(mapAxiosError(err))
+_api.interceptors.response.use(
+  (response) => {
+    var _a, _b;
+    if (_config.debug) {
+      console.debug(
+        `[ExtractIA SDK] \u2190 ${response.status} ${(_b = (_a = response.config) == null ? void 0 : _a.url) != null ? _b : ""}`
+      );
+    }
+    if (typeof _config.onAfterResponse === "function") {
+      _config.onAfterResponse(response);
+    }
+    return response;
+  },
+  async (err) => {
+    var _a, _b;
+    if (err instanceof ExtractiaError) {
+      if (typeof _config.onError === "function") _config.onError(err);
+      return Promise.reject(err);
+    }
+    const mapped = mapAxiosError(err);
+    const cfg = err.config;
+    if (cfg && mapped.isRetryable() && ((_a = cfg._retryCount) != null ? _a : 0) < _config.retries) {
+      cfg._retryCount = ((_b = cfg._retryCount) != null ? _b : 0) + 1;
+      const delayMs = mapped.retryAfter != null ? mapped.retryAfter * 1e3 : _config.retryDelay * cfg._retryCount;
+      if (_config.debug) {
+        console.debug(
+          `[ExtractIA SDK] retrying (${cfg._retryCount}/${_config.retries}) in ${delayMs}ms\u2026`
+        );
+      }
+      await new Promise((r) => setTimeout(r, delayMs));
+      return _api(cfg);
+    }
+    if (typeof _config.onError === "function") _config.onError(mapped);
+    return Promise.reject(mapped);
+  }
 );
-function setToken(newToken) {
-  token = newToken;
+function setToken(token) {
+  if (!token || typeof token !== "string" || !token.trim()) {
+    throw new Error("setToken: token must be a non-empty string.");
+  }
+  _token = token.trim();
+}
+function getToken() {
+  return _token;
+}
+function hasToken() {
+  return Boolean(_token);
 }
-function configure({ baseURL } = {}) {
-  if (baseURL) api.defaults.baseURL = baseURL;
+function clearToken() {
+  _token = null;
 }
-var apiClient_default = api;
+function configure(opts = {}) {
+  if (opts.baseURL) {
+    _config.baseURL = opts.baseURL;
+    _api.defaults.baseURL = opts.baseURL;
+  }
+  if (opts.timeout != null) {
+    _config.timeout = opts.timeout;
+    _api.defaults.timeout = opts.timeout;
+  }
+  if (opts.retries != null) _config.retries = opts.retries;
+  if (opts.retryDelay != null) _config.retryDelay = opts.retryDelay;
+  if (opts.debug != null) _config.debug = Boolean(opts.debug);
+  if (opts.defaultHeaders) {
+    _config.defaultHeaders = __spreadValues(__spreadValues({}, _config.defaultHeaders), opts.defaultHeaders);
+  }
+  if (opts.onBeforeRequest) _config.onBeforeRequest = opts.onBeforeRequest;
+  if (opts.onAfterResponse) _config.onAfterResponse = opts.onAfterResponse;
+  if (opts.onError) _config.onError = opts.onError;
+}
+function getConfig() {
+  return __spreadValues({}, _config);
+}
+var apiClient_default = _api;
 
 // src/auth.js
 async function getMyProfile() {
@@ -2969,8 +3243,17 @@ async function getSubUsers() {
   const res = await apiClient_default.get("/me/subusers");
   return res.data;
 }
-async function createSubUser({ username, password, permissions }) {
-  const res = await apiClient_default.post("/me/subusers", { username, password, permissions });
+async function createSubUser({
+  username,
+  password,
+  permissions,
+  allowedFormIds
+}) {
+  const res = await apiClient_default.post("/me/subusers", __spreadValues({
+    username,
+    password,
+    permissions
+  }, allowedFormIds !== void 0 ? { allowedFormIds } : {}));
   return res.data;
 }
 async function deleteSubUser(username) {
@@ -2978,15 +3261,144 @@ async function deleteSubUser(username) {
   return res.data;
 }
 async function updateSubUser(username, updates = {}) {
-  const res = await apiClient_default.put(`/me/subusers/${encodeURIComponent(username)}`, updates);
+  const res = await apiClient_default.put(
+    `/me/subusers/${encodeURIComponent(username)}`,
+    updates
+  );
   return res.data;
 }
 async function toggleSuspendSubUser(username) {
-  const res = await apiClient_default.put(`/me/subusers/${encodeURIComponent(username)}/suspend`);
+  const res = await apiClient_default.put(
+    `/me/subusers/${encodeURIComponent(username)}/suspend`
+  );
   return res.data;
 }
 
+// src/utils.js
+var utils_exports2 = {};
+__export(utils_exports2, {
+  delay: () => delay,
+  ensureBase64: () => ensureBase64,
+  fileToBase64: () => fileToBase64,
+  getMimeType: () => getMimeType,
+  isBase64: () => isBase64,
+  paginate: () => paginate,
+  paginateAll: () => paginateAll,
+  stripDataUrlPrefix: () => stripDataUrlPrefix,
+  withRetry: () => withRetry
+});
+function fileToBase64(file) {
+  if (typeof FileReader === "undefined") {
+    return Promise.reject(
+      new Error(
+        "fileToBase64: FileReader is not available in this environment. In Node.js, read the file manually and encode it with Buffer.from(data).toString('base64')."
+      )
+    );
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(
+      /** @type {string} */
+      reader.result
+    );
+    reader.onerror = () => {
+      var _a;
+      return reject(new Error(`fileToBase64: failed to read file "${(_a = file.name) != null ? _a : "unknown"}".`));
+    };
+    reader.readAsDataURL(file);
+  });
+}
+function stripDataUrlPrefix(base64OrDataUrl) {
+  if (typeof base64OrDataUrl !== "string") {
+    throw new TypeError(
+      "stripDataUrlPrefix: argument must be a string."
+    );
+  }
+  const idx = base64OrDataUrl.indexOf(";base64,");
+  return idx !== -1 ? base64OrDataUrl.slice(idx + 8) : base64OrDataUrl;
+}
+function getMimeType(dataUrl) {
+  if (typeof dataUrl !== "string") return null;
+  const match = dataUrl.match(/^data:([^;]+);base64,/);
+  return match ? match[1] : null;
+}
+function isBase64(str) {
+  if (typeof str !== "string" || !str.trim()) return false;
+  const raw = stripDataUrlPrefix(str);
+  return raw.length > 0 && raw.length % 4 === 0 && /^[A-Za-z0-9+/]*={0,2}$/.test(raw);
+}
+async function ensureBase64(fileOrBase64) {
+  if (typeof fileOrBase64 === "string") return fileOrBase64;
+  if (typeof File !== "undefined" && fileOrBase64 instanceof File || typeof Blob !== "undefined" && fileOrBase64 instanceof Blob) {
+    return fileToBase64(fileOrBase64);
+  }
+  throw new TypeError(
+    "ensureBase64: argument must be a File, Blob, or a base64 string."
+  );
+}
+function paginate(_0) {
+  return __asyncGenerator(this, arguments, function* (fn, { size = 50, startPage = 0, maxPages = 1e3 } = {}) {
+    var _a;
+    let page = startPage;
+    let pagesRead = 0;
+    while (pagesRead < maxPages) {
+      const result = yield new __await(fn({ page, size }));
+      const items = Array.isArray(result == null ? void 0 : result.content) ? result.content : [];
+      for (const item of items) yield item;
+      const totalPages = (_a = result == null ? void 0 : result.totalPages) != null ? _a : 1;
+      if (items.length === 0 || page + 1 >= totalPages) break;
+      page++;
+      pagesRead++;
+    }
+  });
+}
+async function paginateAll(fn, opts) {
+  const items = [];
+  try {
+    for (var iter = __forAwait(paginate(fn, opts)), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+      const item = temp.value;
+      items.push(item);
+    }
+  } catch (temp) {
+    error = [temp];
+  } finally {
+    try {
+      more && (temp = iter.return) && await temp.call(iter);
+    } finally {
+      if (error)
+        throw error[0];
+    }
+  }
+  return items;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, { retries = 3, initialDelay = 500, shouldRetry } = {}) {
+  const isRetryable = shouldRetry != null ? shouldRetry : (err) => typeof err.isRetryable === "function" && err.isRetryable();
+  let lastErr;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (attempt < retries && isRetryable(err)) {
+        const wait = err.retryAfter != null ? err.retryAfter * 1e3 : initialDelay * 2 ** attempt;
+        await delay(wait);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastErr;
+}
+
 // src/index.js
-var extractia = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, auth_exports), templates_exports), documents_exports), analytics_exports), ocrTools_exports), subusers_exports);
+var extractia = __spreadProps(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, auth_exports), templates_exports), documents_exports), analytics_exports), ocrTools_exports), subusers_exports), utils_exports2), {
+  getToken,
+  hasToken,
+  clearToken,
+  getConfig
+});
 var index_default = extractia;
 //# sourceMappingURL=extractia-sdk.cjs.js.map