@qlik/api 0.0.16 → 0.1.1

package/chunks/WOYJLK4Y.js

@@ -1,1623 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-var _4HB3TAEOjs = require('./4HB3TAEO.js');
-
-// src/platform/platform-functions.ts
-var getPlatform = async (options = {}) => {
-  const isNodeEnvironment = typeof window === "undefined";
-  if (isNodeEnvironment) {
-    return result({ isNodeEnv: true });
-  }
-  const { data: productInfo, status } = await getProductInfo(options);
-  if (status === 404) {
-    return result({ isUnknown: true });
-  }
-  if (!productInfo || status <= 399 && status >= 300) {
-    return result({ isQSE: true, isWindows: true });
-  }
-  const deploymentType = (_optionalChain([productInfo, 'access', _ => _.composition, 'optionalAccess', _2 => _2.deploymentType]) || "").toLowerCase();
-  if (deploymentType === "qliksenseserver") {
-    return result({ isQSE: true, isWindows: true });
-  }
-  if (deploymentType === "qliksensedesktop") {
-    return result({ isQSD: true, isWindows: true });
-  }
-  if (_optionalChain([productInfo, 'access', _3 => _3.composition, 'optionalAccess', _4 => _4.provider]) === "fedramp") {
-    return result({ isCloud: true, isQCG: true });
-  }
-  return result({ isCloud: true, isQCS: true });
-};
-var productInfoPromises = {};
-function templateUrl(baseUrl) {
-  return `${baseUrl}/resources/autogenerated/product-info.json`;
-}
-var getProductInfo = async ({ hostConfig, noCache } = {}) => {
-  const url = toValidLocationUrl(hostConfig);
-  const completeUrl = templateUrl(url);
-  try {
-    if (!(completeUrl in productInfoPromises)) {
-      const fetchOptions = {};
-      if (globalThis.QlikMain && globalThis.QlikMain.resourceNeedsCredentials(completeUrl)) {
-        fetchOptions.credentials = "include";
-      }
-      const productInfoPromise = fetch(completeUrl, fetchOptions).then(async (res) => {
-        if (res.ok) {
-          return { data: await res.json(), status: res.status };
-        }
-        return { data: void 0, status: res.status };
-      });
-      productInfoPromises[completeUrl] = productInfoPromise;
-    }
-    const response = await productInfoPromises[completeUrl];
-    if (response.status >= 400 || !response.data) {
-      delete productInfoPromises[completeUrl];
-    }
-    return response;
-  } catch (err) {
-    delete productInfoPromises[completeUrl];
-    return { data: void 0, status: 500 };
-  } finally {
-    if (noCache) {
-      delete productInfoPromises[completeUrl];
-    }
-  }
-};
-var result = (data) => ({
-  isNodeEnv: false,
-  isCloud: false,
-  isQCS: false,
-  isQCG: false,
-  isWindows: false,
-  isQSE: false,
-  isQSD: false,
-  isUnknown: false,
-  ...data
-});
-
-// src/auth/internal/default-host-config.ts
-var defaultHostConfig = {};
-function setDefaultHostConfig(hostConfig) {
-  defaultHostConfig = hostConfig || {};
-}
-function withDefaultHostConfig(hostConfig) {
-  return hostConfig || defaultHostConfig;
-}
-
-// src/auth/internal/auth-module-registry.ts
-var authModules = {};
-var ongoingAuthModuleLoading = Promise.resolve();
-function registerAuthModule(name, authModule) {
-  authModules[name.toLowerCase()] = authModule;
-}
-function getRegisteredAuthModules() {
-  return Object.keys(authModules);
-}
-function getRegisteredAuthModule(authType) {
-  return authModules[authType.toLowerCase()];
-}
-async function getAuthModule(hostConfig) {
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
-  const authType = await guessAuthTypeIfMissing(hostConfigToUse);
-  if (ongoingAuthModuleLoading) {
-    await ongoingAuthModuleLoading;
-  }
-  let authModule = getRegisteredAuthModule(authType);
-  if (!authModule) {
-    ongoingAuthModuleLoading = (async () => {
-      authModule = await resolveGloballyDefinedAuthModule(authType);
-      if (authModule) {
-        registerAuthModule(authType, authModule);
-      }
-    })();
-    await ongoingAuthModuleLoading;
-  }
-  if (!authModule) {
-    throw new InvalidAuthTypeError(authType);
-  }
-  if (authModule.validateHostConfig) {
-    authModule.validateHostConfig({ authType, ...hostConfigToUse });
-  }
-  return authModule;
-}
-async function guessAuthTypeIfMissing(hostConfig) {
-  if (hostConfig.authType) {
-    return hostConfig.authType;
-  }
-  if (hostConfig.apiKey) {
-    return "apikey";
-  }
-  if (hostConfig.clientId) {
-    return "oauth2";
-  }
-  if (hostConfig.webIntegrationId) {
-    return "cookie";
-  }
-  if (await isWindows(hostConfig)) {
-    return "windowscookie";
-  }
-  return "cookie";
-}
-async function resolveGloballyDefinedAuthModule(authType) {
-  const globalWindow = globalThis;
-  const globalVariable = globalWindow[authType];
-  if (globalVariable) {
-    let potentialAuthModule;
-    if (typeof globalVariable === "function") {
-      potentialAuthModule = await globalVariable();
-    } else {
-      potentialAuthModule = globalVariable;
-    }
-    if (potentialAuthModule && potentialAuthModule.getRestCallAuthParams && potentialAuthModule.getWebSocketAuthParams && potentialAuthModule.handleAuthenticationError) {
-      return potentialAuthModule;
-    }
-    console.error("Not a valid auth module", potentialAuthModule);
-    throw new InvalidAuthTypeError(authType);
-  }
-  return Promise.resolve(void 0);
-}
-
-// src/auth/auth-errors.ts
-var InvalidHostConfigError = class extends Error {
-  constructor(message) {
-    super(`Invalid host config: ${message}`);
-    this.name = "InvalidHostConfigError";
-  }
-};
-var UnexpectedAuthTypeError = class extends Error {
-  constructor(...expectedAuthTypes) {
-    const ors = expectedAuthTypes.map((item, index) => index === 0 ? `"${item}"` : `or "${item}"`).join(" ");
-    super(`HostConfig is not properly configured. authType is expected to be ${ors}`);
-    this.name = "UnexpectedAuthTypeError";
-  }
-};
-var InvalidAuthTypeError = class extends Error {
-  constructor(authType) {
-    const validAuthModules = getRegisteredAuthModules();
-    super(
-      `Not a valid auth type: ${authType}, valid auth types are; '${validAuthModules.filter((name) => name !== "QmfeEmbedFramerAuthModule").join("', '")}'`
-    );
-    this.name = "InvalidAuthTypeError";
-  }
-};
-var AuthorizationError = class extends Error {
-  constructor(errors) {
-    const errorArray = Array.isArray(errors) ? errors : [errors];
-    super(
-      errorArray.map(
-        (error) => `
-Code: ${error.code}
-Status: ${error.status}
-${error.title}:
-${error.detail}
-`
-      ).join(",\n")
-    );
-  }
-};
-
-// src/auth/auth-functions.ts
-function isHostCrossOrigin(hostConfig) {
-  if (!_optionalChain([globalThis, 'access', _5 => _5.location, 'optionalAccess', _6 => _6.origin])) {
-    return true;
-  }
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
-  if (Object.keys(hostConfigToUse).length === 0) {
-    return false;
-  }
-  try {
-    const locationUrl = new URL(toValidLocationUrl(hostConfigToUse));
-    return locationUrl.origin !== globalThis.location.origin;
-  } catch (e2) {
-  }
-  return false;
-}
-async function isWindows(hostConfig) {
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
-  if (hostConfigToUse.authType === "cookie") {
-    return false;
-  }
-  if (hostConfigToUse.authType === "windowscookie") {
-    return true;
-  }
-  return (await getPlatform({ hostConfig })).isWindows;
-}
-function toValidLocationUrl(hostConfig) {
-  const url = _optionalChain([withDefaultHostConfig, 'call', _7 => _7(hostConfig), 'optionalAccess', _8 => _8.host]);
-  let locationUrl;
-  if (!url) {
-    locationUrl = "";
-  } else if (url.toLowerCase().startsWith("https://") || url.toLowerCase().startsWith("http://")) {
-    locationUrl = url;
-  } else {
-    locationUrl = `https://${url}`;
-  }
-  while (locationUrl[locationUrl.length - 1] === "/") {
-    locationUrl = locationUrl.substring(0, locationUrl.length - 1);
-  }
-  return locationUrl;
-}
-function toValidEnigmaLocationUrl(hostConfig) {
-  return toValidWebsocketLocationUrl(hostConfig);
-}
-function toValidWebsocketLocationUrl(hostConfig) {
-  const url = _optionalChain([withDefaultHostConfig, 'call', _9 => _9(hostConfig), 'optionalAccess', _10 => _10.host]);
-  let locationUrl;
-  if (!url) {
-    locationUrl = globalThis.location.origin;
-  } else if (url.toLowerCase().startsWith("https://") || url.toLowerCase().startsWith("http://")) {
-    locationUrl = url;
-  } else {
-    locationUrl = `https://${url}`;
-  }
-  while (locationUrl[locationUrl.length - 1] === "/") {
-    locationUrl = locationUrl.substring(0, locationUrl.length - 1);
-  }
-  return locationUrl.replace(leadingHttp, "ws");
-}
-async function getWebSocketAuthParams(props) {
-  const hostConfigToUse = withDefaultHostConfig(props.hostConfig);
-  return (await getAuthModule(hostConfigToUse)).getWebSocketAuthParams({
-    ...props,
-    hostConfig: hostConfigToUse
-  });
-}
-async function getWebResourceAuthParams(props) {
-  const hostConfigToUse = withDefaultHostConfig(props.hostConfig);
-  return await _asyncOptionalChain([(await getAuthModule(hostConfigToUse)), 'access', async _11 => _11.getWebResourceAuthParams, 'optionalCall', async _12 => _12({
-    ...props,
-    hostConfig: hostConfigToUse
-  })]) || { queryParams: {} };
-}
-async function handleAuthenticationError(props) {
-  const hostConfigToUse = withDefaultHostConfig(props.hostConfig);
-  return (await getAuthModule(hostConfigToUse)).handleAuthenticationError({
-    ...props,
-    hostConfig: hostConfigToUse
-  });
-}
-async function getRestCallAuthParams(props) {
-  const hostConfigToUse = withDefaultHostConfig(props.hostConfig);
-  return (await getAuthModule(hostConfigToUse)).getRestCallAuthParams({
-    ...props,
-    hostConfig: hostConfigToUse
-  });
-}
-function registerAuthModule2(name, authModule) {
-  registerAuthModule(name, authModule);
-}
-function setDefaultHostConfig2(hostConfig) {
-  setDefaultHostConfig(hostConfig);
-}
-function checkForCrossDomainRequest(hostConfig) {
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
-  if (isHostCrossOrigin(hostConfigToUse)) {
-    if (Object.keys(hostConfigToUse).length === 0) {
-      throw new InvalidHostConfigError("a host config must be provided when making a cross domain request");
-    }
-    if (!hostConfigToUse.host) {
-      throw new InvalidHostConfigError("A 'host' must be set in host config when making a cross domain request");
-    }
-  }
-}
-var logout = () => {
-  globalThis.loggingOut = true;
-  globalThis.location.href = "/logout";
-};
-var leadingHttp = /^http/;
-
-// src/auth/internal/auth-functions.ts
-function getCredentialsForCookieAuth(hostConfig) {
-  if (hostConfig.crossSiteCookies === false) {
-    return "same-origin";
-  }
-  if (isHostCrossOrigin(hostConfig)) {
-    return "include";
-  }
-  return "same-origin";
-}
-function internalValidateHostConfig(hostConfig, options) {
-  const missingRequiredProps = [];
-  for (const requiredProp of options.requiredProps) {
-    if (!hostConfig[requiredProp]) {
-      missingRequiredProps.push(requiredProp);
-    }
-  }
-  if (missingRequiredProps.length > 0) {
-    throw new InvalidHostConfigError(
-      `missing required properties in host config; '${missingRequiredProps.join("', '")}'`
-    );
-  }
-  const validProps = [
-    "authType",
-    "autoRedirect",
-    "authRedirectUserConfirmation",
-    "embedRuntimeUrl",
-    "host",
-    ...options.requiredProps,
-    ...options.optionalProps
-  ];
-  const invalidKeys = [];
-  Object.keys(hostConfig).forEach((key) => {
-    if (!validProps.some((k) => k === key)) {
-      invalidKeys.push(key);
-    }
-  });
-  if (invalidKeys.length > 0) {
-    throw new InvalidHostConfigError(`unknown properties in host config; '${invalidKeys.join("', '")}'`);
-  }
-  return true;
-}
-
-// src/auth/internal/default-auth-modules/apikey.ts
-function getRestCallAuthParams2({ hostConfig }) {
-  return Promise.resolve({
-    headers: {
-      Authorization: `Bearer ${_optionalChain([hostConfig, 'optionalAccess', _13 => _13.apiKey])}`
-    },
-    queryParams: {},
-    credentials: "omit"
-  });
-}
-async function getWebSocketAuthParams2() {
-  return {
-    queryParams: {
-      // accessToken: hostConfig.apiKey,
-    }
-  };
-}
-function handleAuthenticationError2() {
-  return Promise.resolve({});
-}
-var apikey_default = {
-  getRestCallAuthParams: getRestCallAuthParams2,
-  getWebSocketAuthParams: getWebSocketAuthParams2,
-  handleAuthenticationError: handleAuthenticationError2,
-  validateHostConfig: (hostConfig) => internalValidateHostConfig(hostConfig, { requiredProps: ["apiKey"], optionalProps: [] })
-};
-
-// src/http/http-functions.ts
-var QLIK_CSRF_TOKEN = "qlik-csrf-token";
-function clearCsrfToken(hostConfig) {
-  const locationUrl = toValidLocationUrl(hostConfig);
-  delete csrfTokens[locationUrl];
-}
-async function getCsrfToken(hostConfig, noCache) {
-  const locationUrl = toValidLocationUrl(hostConfig);
-  const fetchCsrfToken = async () => {
-    const res = await invokeFetch("csrf-token", {
-      method: "get",
-      pathTemplate: "/api/v1/csrf-token",
-      options: {
-        hostConfig,
-        noCache: true
-      }
-    });
-    const csrfToken = res.headers.get(QLIK_CSRF_TOKEN);
-    if (!csrfToken) {
-      return "";
-    }
-    return csrfToken;
-  };
-  if (noCache) {
-    csrfTokens[locationUrl] = fetchCsrfToken();
-    return csrfTokens[locationUrl];
-  }
-  csrfTokens[locationUrl] = csrfTokens[locationUrl] || fetchCsrfToken();
-  return csrfTokens[locationUrl];
-}
-var csrfTokens = {};
-
-// src/auth/internal/default-auth-modules/cookie.ts
-function isModifyingVerb(verb) {
-  return !(verb === "get" || verb === "GET");
-}
-async function getRestCallAuthParams3({
-  hostConfig,
-  method
-}) {
-  const headers = {};
-  if (isModifyingVerb(method)) {
-    headers["qlik-csrf-token"] = await getCsrfToken(hostConfig);
-  }
-  if (hostConfig.webIntegrationId) {
-    headers["qlik-web-integration-id"] = hostConfig.webIntegrationId;
-  }
-  return { headers, queryParams: {}, credentials: getCredentialsForCookieAuth(hostConfig) };
-}
-async function getWebSocketAuthParams3({
-  hostConfig
-}) {
-  const params = {
-    // Bypass the cache to get one rest call out the door that can catch a 401 since the websocket only returns a general error
-    "qlik-csrf-token": await getCsrfToken(hostConfig, true)
-  };
-  if (hostConfig.webIntegrationId) {
-    params["qlik-web-integration-id"] = hostConfig.webIntegrationId;
-  }
-  return { queryParams: params };
-}
-async function handleAuthenticationError3({
-  hostConfig,
-  status,
-  errorBody = {}
-}) {
-  clearCsrfToken(hostConfig);
-  if (status === 403) {
-    return {
-      preventDefault: false,
-      // Only retry if the csrf token has expired
-      retry: _optionalChain([errorBody, 'optionalAccess', _14 => _14.code]) === "CSRF-TOKEN-2"
-    };
-  }
-  const webIntegrationParam = hostConfig.webIntegrationId ? `qlik-web-integration-id=${_optionalChain([hostConfig, 'optionalAccess', _15 => _15.webIntegrationId])}&` : "";
-  const locationUrl = toValidLocationUrl(hostConfig);
-  if (hostConfig.authRedirectUserConfirmation) {
-    await hostConfig.authRedirectUserConfirmation();
-  }
-  globalThis.location.replace(
-    `${locationUrl}/login?${webIntegrationParam}returnto=${encodeURIComponent(globalThis.location.href)}`
-  );
-  return {
-    preventDefault: true
-  };
-}
-var cookie_default = {
-  getRestCallAuthParams: getRestCallAuthParams3,
-  getWebSocketAuthParams: getWebSocketAuthParams3,
-  handleAuthenticationError: handleAuthenticationError3,
-  validateHostConfig: (hostConfig) => internalValidateHostConfig(hostConfig, {
-    requiredProps: [],
-    optionalProps: ["webIntegrationId", "crossSiteCookies"]
-  })
-};
-
-// src/auth/internal/default-auth-modules/none.ts
-function getRestCallAuthParams4() {
-  return Promise.resolve({ headers: {}, queryParams: {}, credentials: "same-origin" });
-}
-function getWebSocketAuthParams4() {
-  return Promise.resolve({ queryParams: {} });
-}
-function handleAuthenticationError4() {
-  return Promise.resolve({});
-}
-var none_default = {
-  getRestCallAuthParams: getRestCallAuthParams4,
-  getWebSocketAuthParams: getWebSocketAuthParams4,
-  handleAuthenticationError: handleAuthenticationError4,
-  validateHostConfig: (hostConfig) => internalValidateHostConfig(hostConfig, { requiredProps: [], optionalProps: [] })
-};
-
-// src/utils/utils.ts
-var _nanoid = require('nanoid');
-function isBrowser() {
-  return typeof window === "object" && typeof window.document === "object";
-}
-function isNode() {
-  return typeof process === "object" && typeof _4HB3TAEOjs.__require === "function";
-}
-function generateRandomString(targetLength) {
-  return _nanoid.nanoid.call(void 0, targetLength);
-}
-
-// src/auth/internal/default-auth-modules/oauth/storage-helpers.ts
-var storagePrefix = "qlik-qmfe-api";
-function getTopicFromHostConfig(hostConfig) {
-  return hostConfig.clientId + (hostConfig.scope ? `_${hostConfig.scope}` : "_user_default");
-}
-var cachedTokens = {};
-function saveInLocalStorage(topic, name, value) {
-  localStorage.setItem(`${storagePrefix}-${topic}-${name}`, value);
-}
-function saveInSessionStorage(topic, name, value) {
-  sessionStorage.setItem(`${storagePrefix}-${topic}-${name}`, value);
-}
-function loadFromLocalStorage(topic, name) {
-  return localStorage.getItem(`${storagePrefix}-${topic}-${name}`) || void 0;
-}
-function loadFromSessionStorage(topic, name) {
-  return sessionStorage.getItem(`${storagePrefix}-${topic}-${name}`) || void 0;
-}
-function deleteFromLocalStorage(topic, names) {
-  names.forEach((name) => localStorage.removeItem(`${storagePrefix}-${topic}-${name}`));
-}
-function deleteFromSessionStorage(topic, names) {
-  names.forEach((name) => sessionStorage.removeItem(`${storagePrefix}-${topic}-${name}`));
-}
-function loadAndDeleteFromSessionStorage(topic, name) {
-  const id = `${storagePrefix}-${topic}-${name}`;
-  const result2 = sessionStorage.getItem(id) || void 0;
-  sessionStorage.removeItem(id);
-  return result2;
-}
-function loadOauthTokensFromStorage(hostConfig) {
-  if (!hostConfig.clientId) {
-    return void 0;
-  }
-  let accessToken;
-  let refreshToken;
-  if (hostConfig.accessTokenStorage === "local") {
-    accessToken = loadFromLocalStorage(getTopicFromHostConfig(hostConfig), "access-token");
-    refreshToken = loadFromLocalStorage(getTopicFromHostConfig(hostConfig), "refresh-token");
-  } else if (hostConfig.accessTokenStorage === "session") {
-    accessToken = loadFromSessionStorage(getTopicFromHostConfig(hostConfig), "access-token");
-    refreshToken = loadFromSessionStorage(getTopicFromHostConfig(hostConfig), "refresh-token");
-  }
-  if (accessToken) {
-    return {
-      accessToken,
-      refreshToken
-    };
-  }
-  return void 0;
-}
-async function loadCachedOauthTokens(hostConfig) {
-  return cachedTokens[getTopicFromHostConfig(hostConfig)];
-}
-async function loadOrAcquireAccessToken(hostConfig, acquireTokens) {
-  if (!hostConfig.clientId) {
-    throw new InvalidHostConfigError('A host config with authType set to "oauth2" has to also provide a clientId');
-  }
-  const mayUseStorage = isBrowser();
-  const storedOauthTokens = cachedTokens[getTopicFromHostConfig(hostConfig)] || (mayUseStorage ? loadOauthTokensFromStorage(hostConfig) : void 0);
-  if (storedOauthTokens) {
-    return Promise.resolve(storedOauthTokens);
-  }
-  const tokensPromise = acquireTokens();
-  cachedTokens[getTopicFromHostConfig(hostConfig)] = tokensPromise;
-  if (mayUseStorage) {
-    const tokens = await tokensPromise;
-    if (hostConfig.accessTokenStorage === "local" && tokens) {
-      if (tokens.accessToken) {
-        saveInLocalStorage(getTopicFromHostConfig(hostConfig), "access-token", tokens.accessToken);
-      }
-      if (tokens.refreshToken) {
-        saveInLocalStorage(getTopicFromHostConfig(hostConfig), "refresh-token", tokens.refreshToken);
-      }
-    } else if (hostConfig.accessTokenStorage === "session" && tokens) {
-      if (tokens.accessToken) {
-        saveInSessionStorage(getTopicFromHostConfig(hostConfig), "access-token", tokens.accessToken);
-      }
-      if (tokens.refreshToken) {
-        saveInSessionStorage(getTopicFromHostConfig(hostConfig), "refresh-token", tokens.refreshToken);
-      }
-    }
-  }
-  return tokensPromise;
-}
-function clearStoredOauthTokens(hostConfig) {
-  if (!hostConfig.clientId) {
-    throw new InvalidHostConfigError('A host config with authType set to "oauth2" has to also provide a clientId');
-  }
-  delete cachedTokens[getTopicFromHostConfig(hostConfig)];
-  if (isBrowser()) {
-    deleteFromLocalStorage(getTopicFromHostConfig(hostConfig), ["access-token", "refresh-token"]);
-    deleteFromSessionStorage(getTopicFromHostConfig(hostConfig), ["access-token", "refresh-token"]);
-  }
-}
-
-// src/auth/internal/default-auth-modules/oauth/callback.ts
-function handleOAuthCallback() {
-  const urlParams = new URLSearchParams(globalThis.location.search);
-  const callbackCode = urlParams.get("code") || void 0;
-  const callbackState = urlParams.get("state") || void 0;
-  if (urlParams.get("error")) {
-    const element = document.createElement("pre");
-    element.innerText = `<code>${JSON.stringify({
-      error: urlParams.get("error"),
-      error_code: urlParams.get("error_code"),
-      error_description: urlParams.get("error_description"),
-      error_detail: urlParams.get("error_detail"),
-      error_uri: urlParams.get("error_uri")
-    })}</code>`;
-    document.body.prepend(element);
-  }
-  const topic = loadAndDeleteFromSessionStorage("", "client-in-progress");
-  if (topic && callbackCode && callbackState) {
-    const stateFromLocalStorage = loadAndDeleteFromSessionStorage(topic, "state");
-    const finalRedirectUri = loadAndDeleteFromSessionStorage(topic, "href");
-    if (stateFromLocalStorage && stateFromLocalStorage === callbackState && finalRedirectUri) {
-      saveInSessionStorage(topic, "code", callbackCode);
-      if (finalRedirectUri !== globalThis.location.href) {
-        globalThis.location.replace(finalRedirectUri);
-      }
-    }
-  }
-}
-
-// src/auth/internal/default-auth-modules/oauth/oauth-utils.ts
-function handlePossibleErrors(data) {
-  if (data.errors) {
-    throw new AuthorizationError(data.errors);
-  }
-}
-function toQueryString(queryParams) {
-  const queryParamsKeys = Object.keys(queryParams);
-  queryParamsKeys.sort();
-  const query = queryParamsKeys.map((k) => `${k}=${queryParams[k]}`).join("&");
-  return query;
-}
-function byteArrayToBase64(hashArray) {
-  let result2 = "";
-  if (isBrowser()) {
-    const byteArrayToString = String.fromCharCode.apply(null, hashArray);
-    result2 = btoa(byteArrayToString);
-  } else if (isNode()) {
-    result2 = Buffer.from(hashArray).toString("base64");
-  } else {
-    throw new Error("Environment not supported for oauth2 authentication");
-  }
-  return result2;
-}
-async function sha256(message) {
-  const msgBuffer = new TextEncoder().encode(message);
-  const hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", msgBuffer);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  const hashBase64 = byteArrayToBase64(hashArray);
-  return hashBase64.replaceAll(/\+/g, "-").replaceAll(/\//g, "_").replace(/=+$/, "");
-}
-async function startFullPageLoginFlow(hostConfig) {
-  const clientId = hostConfig.clientId || "";
-  const locationUrl = toValidLocationUrl(hostConfig);
-  const verifier = generateRandomString(128);
-  const state = generateRandomString(43);
-  const codeChallenge = await sha256(verifier);
-  const redirectUri = hostConfig.redirectUri || globalThis.location.href;
-  clearStoredOauthTokens(hostConfig);
-  saveInSessionStorage(getTopicFromHostConfig(hostConfig), "state", state);
-  saveInSessionStorage(getTopicFromHostConfig(hostConfig), "verifier", verifier);
-  saveInSessionStorage(getTopicFromHostConfig(hostConfig), "href", globalThis.location.href);
-  saveInSessionStorage("", "client-in-progress", getTopicFromHostConfig(hostConfig));
-  const queryParams = {
-    response_type: "code",
-    client_id: clientId,
-    redirect_uri: redirectUri,
-    scope: hostConfig.scope || "user_default",
-    state,
-    code_challenge: codeChallenge,
-    code_challenge_method: "S256"
-  };
-  const url = `${locationUrl}/oauth/authorize?${toQueryString(queryParams)}`;
-  globalThis.location.replace(url);
-}
-async function exchangeCodeAndVerifierForAccessTokenData(hostConfig, code, verifier, redirectUri) {
-  try {
-    const result2 = await fetch(`${toValidLocationUrl(hostConfig)}/oauth/token`, {
-      method: "POST",
-      credentials: "include",
-      mode: "cors",
-      headers: { "content-type": "application/json" },
-      redirect: "follow",
-      body: JSON.stringify({
-        grant_type: "authorization_code",
-        scope: hostConfig.scope || "user_default",
-        ...code ? { code } : {},
-        ...{ redirect_uri: redirectUri || globalThis.location.href },
-        ...verifier ? { code_verifier: verifier } : {},
-        client_id: hostConfig.clientId
-      })
-    });
-    const data = await result2.json();
-    handlePossibleErrors(data);
-    return {
-      accessToken: data.access_token,
-      refreshToken: data.refresh_token,
-      errors: data.errors
-    };
-  } catch (err) {
-    console.error(err);
-    return new Promise(() => {
-    });
-  }
-}
-async function getOauthTokensWithCredentials(baseUrl, clientId, clientSecret, scope = "user_default") {
-  const result2 = await fetch(`${baseUrl}/oauth/token`, {
-    method: "POST",
-    mode: "cors",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({
-      grant_type: "client_credentials",
-      client_id: clientId,
-      client_secret: clientSecret,
-      scope
-    })
-  });
-  const data = await result2.json();
-  return {
-    accessToken: data.access_token,
-    refreshToken: data.refresh_token,
-    errors: data.errors
-  };
-}
-async function getOauthTokensWithRefreshToken(baseUrl, refreshToken, clientSecret) {
-  const result2 = await fetch(`${baseUrl}/oauth/token`, {
-    method: "POST",
-    mode: "cors",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({
-      grant_type: "refresh_token",
-      refresh_token: refreshToken,
-      client_secret: clientSecret
-    })
-  });
-  const data = await result2.json();
-  return {
-    accessToken: data.access_token,
-    refreshToken: data.refresh_token,
-    errors: data.errors
-  };
-}
-async function getOAuthTokensForNode(hostConfig) {
-  const { clientId, clientSecret } = hostConfig;
-  if (!clientId || !clientSecret) {
-    throw new InvalidHostConfigError(
-      'A host config with authType set to "oauth2" has to provide a clientId and a clientSecret'
-    );
-  }
-  const oauthTokens = await loadOrAcquireAccessToken(hostConfig, async () => {
-    if (!hostConfig.clientId || !hostConfig.clientSecret) {
-      throw new InvalidHostConfigError(
-        'A host config with authType set to "oauth2" has to provide a clientId and a clientSecret'
-      );
-    }
-    return getOauthTokensWithCredentials(
-      toValidLocationUrl(hostConfig),
-      hostConfig.clientId,
-      hostConfig.clientSecret,
-      hostConfig.scope
-    );
-  });
-  return oauthTokens;
-}
-async function getOAuthTokensForBrowser(hostConfig) {
-  const { clientId } = hostConfig;
-  if (!clientId) {
-    throw new InvalidHostConfigError('A host config with authType set to "oauth2" has to also provide a clientId');
-  }
-  const oauthTokens = await loadOrAcquireAccessToken(hostConfig, async () => {
-    const code = loadAndDeleteFromSessionStorage(getTopicFromHostConfig(hostConfig), "code");
-    const verifier = loadAndDeleteFromSessionStorage(getTopicFromHostConfig(hostConfig), "verifier");
-    if (code && verifier) {
-      const tokenResponse = await exchangeCodeAndVerifierForAccessTokenData(
-        hostConfig,
-        code,
-        verifier,
-        hostConfig.redirectUri
-      );
-      if (tokenResponse) {
-        return tokenResponse;
-      }
-    }
-    return void 0;
-  });
-  if (oauthTokens) {
-    return oauthTokens;
-  }
-  if (hostConfig.authRedirectUserConfirmation) {
-    await hostConfig.authRedirectUserConfirmation();
-  }
-  startFullPageLoginFlow(hostConfig);
-  return new Promise(() => {
-  });
-}
-var lastOauthTokensCall = Promise.resolve("");
-async function getOAuthAccessToken(hostConfig) {
-  let getOauthTokensCall;
-  if (isNode()) {
-    getOauthTokensCall = getOAuthTokensForNode;
-  } else {
-    getOauthTokensCall = getOAuthTokensForBrowser;
-  }
-  lastOauthTokensCall = lastOauthTokensCall.then(async () => {
-    const tokens = await getOauthTokensCall(hostConfig);
-    if (tokens) {
-      handlePossibleErrors(tokens);
-      return tokens.accessToken || "";
-    }
-    return "";
-  });
-  return lastOauthTokensCall;
-}
-async function refreshAccessToken(hostConfig) {
-  const tokens = await loadCachedOauthTokens(hostConfig);
-  clearStoredOauthTokens(hostConfig);
-  if (tokens && tokens.refreshToken && hostConfig.clientSecret) {
-    const refreshedTokens = await loadOrAcquireAccessToken(hostConfig, async () => {
-      if (!tokens || !tokens.refreshToken || !hostConfig.clientSecret) {
-        throw new Error("Trying to refresh tokens without refreshToken or clientSecret");
-      }
-      return getOauthTokensWithRefreshToken(
-        toValidLocationUrl(hostConfig),
-        tokens.refreshToken,
-        hostConfig.clientSecret
-      );
-    });
-    if (refreshedTokens) {
-      handlePossibleErrors(refreshedTokens);
-    }
-  }
-}
-
-// src/auth/internal/default-auth-modules/oauth/temporary-token.ts
-async function exchangeAccessTokenForTemporaryToken(hostConfig, accessToken, purpose) {
-  const result2 = await fetch(`${toValidLocationUrl(hostConfig)}/oauth/token`, {
-    method: "POST",
-    credentials: "include",
-    mode: "cors",
-    headers: { "content-type": "application/json" },
-    redirect: "follow",
-    body: JSON.stringify({
-      subject_token: accessToken,
-      subject_token_type: "urn:ietf:params:oauth:token-type:access_token",
-      grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
-      purpose,
-      redirect_uri: _optionalChain([globalThis, 'access', _16 => _16.location, 'optionalAccess', _17 => _17.href]),
-      client_id: hostConfig.clientId
-    })
-  });
-  if (result2.status === 401) {
-    if (hostConfig.authRedirectUserConfirmation) {
-      await hostConfig.authRedirectUserConfirmation();
-    }
-    startFullPageLoginFlow(hostConfig);
-    return new Promise(() => {
-    });
-  }
-  const data = await result2.json();
-  return data.access_token;
-}
-
-// src/auth/internal/default-auth-modules/oauth.ts
-if (isBrowser()) {
-  handleOAuthCallback();
-}
-async function getRestCallAuthParams5({
-  hostConfig
-}) {
-  return {
-    headers: {
-      Authorization: `Bearer ${await getOAuthAccessToken(hostConfig)}`
-    },
-    queryParams: {},
-    credentials: "omit"
-  };
-}
-async function getWebSocketAuthParams5({
-  hostConfig
-}) {
-  const accessToken = await getOAuthAccessToken(hostConfig);
-  const websocketAccessToken = await exchangeAccessTokenForTemporaryToken(hostConfig, accessToken, "websocket");
-  return {
-    queryParams: {
-      accessToken: websocketAccessToken
-    }
-  };
-}
-async function getWebResourceAuthParams2({
-  hostConfig
-}) {
-  const accessToken = await getOAuthAccessToken(hostConfig);
-  const webResourceAccessToken = await exchangeAccessTokenForTemporaryToken(hostConfig, accessToken, "webresource");
-  return {
-    queryParams: {
-      accessToken: webResourceAccessToken
-    }
-  };
-}
-async function handleAuthenticationError5({
-  hostConfig
-}) {
-  if (isBrowser()) {
-    if (hostConfig.authRedirectUserConfirmation) {
-      await hostConfig.authRedirectUserConfirmation();
-    }
-    startFullPageLoginFlow(hostConfig);
-    return {
-      preventDefault: true
-    };
-  }
-  await refreshAccessToken(hostConfig);
-  return {
-    preventDefault: false,
-    retry: true
-  };
-}
-var oauth_default = {
-  getRestCallAuthParams: getRestCallAuthParams5,
-  getWebSocketAuthParams: getWebSocketAuthParams5,
-  getWebResourceAuthParams: getWebResourceAuthParams2,
-  handleAuthenticationError: handleAuthenticationError5,
-  validateHostConfig: (hostConfig) => internalValidateHostConfig(hostConfig, {
-    requiredProps: ["clientId"],
-    optionalProps: ["clientSecret", "redirectUri", "accessTokenStorage", "scope"]
-  })
-};
-
-// src/auth/internal/default-auth-modules/windows-cookie/xrf-keys.ts
-var xrfKeys = {};
-function createXrfKey() {
-  let result2 = "";
-  for (let i = 0; i < 16; i += 1) {
-    const j = Math.floor(Math.random() * 62);
-    if (j < 10) {
-      result2 += j;
-    } else if (j > 9 && j < 36) {
-      result2 += String.fromCharCode(j + 55);
-    } else {
-      result2 += String.fromCharCode(j + 61);
-    }
-  }
-  return result2;
-}
-function getXrfKey(hostConfig) {
-  const locationUrl = toValidLocationUrl(hostConfig);
-  xrfKeys[locationUrl] = xrfKeys[locationUrl] || createXrfKey();
-  return xrfKeys[locationUrl];
-}
-
-// src/auth/internal/default-auth-modules/windows-cookie.ts
-function getRestCallAuthParams6({
-  hostConfig
-}) {
-  return Promise.resolve({
-    headers: {
-      "X-Qlik-XrfKey": getXrfKey(hostConfig)
-    },
-    queryParams: {
-      xrfkey: getXrfKey(hostConfig)
-    },
-    credentials: getCredentialsForCookieAuth(hostConfig)
-  });
-}
-function getWebSocketAuthParams6({
-  hostConfig
-}) {
-  return Promise.resolve({
-    queryParams: {
-      xrfkey: getXrfKey(hostConfig)
-    }
-  });
-}
-async function handleAuthenticationError6({
-  hostConfig
-}) {
-  if (hostConfig.loginUri) {
-    if (hostConfig.authRedirectUserConfirmation) {
-      await hostConfig.authRedirectUserConfirmation();
-    }
-    globalThis.location.replace(
-      hostConfig.loginUri.replace("{location}", encodeURIComponent(globalThis.location.href))
-    );
-    return {
-      preventDefault: true
-    };
-  }
-  return {
-    // Do nothing, just let the error be thrown to calling code
-  };
-}
-var windows_cookie_default = {
-  getRestCallAuthParams: getRestCallAuthParams6,
-  getWebSocketAuthParams: getWebSocketAuthParams6,
-  handleAuthenticationError: handleAuthenticationError6,
-  validateHostConfig: (hostConfig) => internalValidateHostConfig(hostConfig, {
-    requiredProps: [],
-    optionalProps: ["loginUri", "crossSiteCookies"]
-  })
-};
-
-// src/auth/auth.ts
-globalThis.loggingOut = false;
-var authModulesRegistered = false;
-function registerDefaultAuthModules() {
-  if (!authModulesRegistered) {
-    registerAuthModule("apikey", apikey_default);
-    registerAuthModule("cookie", cookie_default);
-    registerAuthModule("none", none_default);
-    registerAuthModule("oauth2", oauth_default);
-    registerAuthModule("windowscookie", windows_cookie_default);
-    authModulesRegistered = true;
-  }
-}
-registerDefaultAuthModules();
-var auth = {
-  logout,
-  registerAuthModule,
-  setDefaultHostConfig: setDefaultHostConfig2,
-  getRestCallAuthParams,
-  getWebSocketAuthParams,
-  getWebResourceAuthParams,
-  handleAuthenticationError,
-  toValidLocationUrl,
-  toValidEnigmaLocationUrl,
-  toValidWebsocketLocationUrl,
-  isWindows,
-  isHostCrossOrigin
-};
-var auth_default = auth;
-
-// src/invoke-fetch/internal/invoke-fetch-helpers.ts
-function encodeQueryParams(query) {
-  if (query) {
-    return Object.entries(query).map((kv) => {
-      const [, value] = kv;
-      if (value === void 0) {
-        return void 0;
-      }
-      return kv.map(
-        (val) => (
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          encodeURIComponent(val)
-        )
-      ).join("=");
-    }).filter(Boolean).join("&");
-  }
-  return "";
-}
-function applyPathVariables(pathTemplate, pathVariables) {
-  let result2 = pathTemplate;
-  if (pathVariables) {
-    Object.keys(pathVariables).forEach((key) => {
-      result2 = result2.replace(`{${key}}`, pathVariables[key]);
-    });
-  }
-  return result2;
-}
-function toCacheKey(url, query, headers) {
-  let cacheKey = url;
-  if (query !== "") {
-    cacheKey = cacheKey.concat(`?${query}`);
-  }
-  if (headers) {
-    cacheKey = cacheKey.concat(`+headers=${JSON.stringify(headers)}`);
-  }
-  return cacheKey;
-}
-function toCompleteUrl(url, query) {
-  if (query !== "") {
-    return `${url}?${query}`;
-  }
-  return url;
-}
-function shouldUseCachedResult(options, cacheEntry, defaultMaxCacheTime) {
-  if (!cacheEntry || typeof cacheEntry.value === void 0) {
-    return false;
-  }
-  if (_optionalChain([options, 'optionalAccess', _18 => _18.noCache])) {
-    return false;
-  }
-  if (_optionalChain([options, 'optionalAccess', _19 => _19.useCacheIfAfter])) {
-    return options.useCacheIfAfter.getTime() <= cacheEntry.lastPulled;
-  }
-  const age = Date.now() - cacheEntry.lastPulled;
-  if (_optionalChain([options, 'optionalAccess', _20 => _20.maxCacheAge])) {
-    return age <= _optionalChain([options, 'optionalAccess', _21 => _21.maxCacheAge]);
-  }
-  return age < defaultMaxCacheTime;
-}
-var shouldPopulateCache = (method) => method === "get" || method === "GET";
-function clone(value) {
-  if (value && (value instanceof Blob || value instanceof Object && value.toString() === "[object Blob]")) {
-    return value;
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  return JSON.parse(JSON.stringify(value));
-}
-function isModifyingVerb2(verb) {
-  return !(verb === "get" || verb === "GET");
-}
-function cacheKeyToUrl(cachedUrl) {
-  const queryIdx = cachedUrl.indexOf("?");
-  if (queryIdx >= 0) {
-    return cachedUrl.substring(0, queryIdx);
-  }
-  const headersIdx = cachedUrl.indexOf("+headers=");
-  if (headersIdx >= 0) {
-    return cachedUrl.substring(0, headersIdx);
-  }
-  return cachedUrl;
-}
-function clearRelatedCacheEntries(cache2, cacheKey) {
-  const modifyingUrl = cacheKeyToUrl(cacheKey);
-  for (const existingCacheKey in cache2) {
-    const cleanUrl = cacheKeyToUrl(existingCacheKey);
-    if (
-      // Either up or down the path...
-      modifyingUrl.startsWith(cleanUrl) || cleanUrl.startsWith(modifyingUrl)
-    ) {
-      delete cache2[existingCacheKey];
-    }
-  }
-}
-function cloneResultPromise(value) {
-  return value.then((resp) => {
-    const result2 = {
-      data: clone(resp.data),
-      headers: resp.headers,
-      status: resp.status
-    };
-    if (resp.next) {
-      result2.next = resp.next;
-    }
-    if (resp.prev) {
-      result2.prev = resp.prev;
-    }
-    return result2;
-  });
-}
-function clearCacheOnError(cacheEntry, cacheKey, value) {
-  return value.catch((error) => {
-    delete cacheEntry[cacheKey];
-    return Promise.reject(error);
-  });
-}
-
-// src/invoke-fetch/internal/invoke-fetch-methods.ts
-var defaultCacheTime = 1e3 * 60 * 10;
-var cache = {};
-globalThis.__API_CACHE__DO_NOT_USE_OR_YOU_WILL_BE_FIRED = cache;
-function clearApiCacheInternal(api) {
-  cache[api] = {};
-}
-function getErrorMessage(error) {
-  if (error instanceof Error) {
-    if (error.cause) {
-      if (error.message) {
-        return `${error.message} - ${getErrorMessage(error.cause)}`;
-      }
-      return getErrorMessage(error.cause);
-    }
-    return error.message;
-  }
-  return String(error);
-}
-async function fetchAndTransformExceptions(input, init) {
-  try {
-    return await fetch(input, init);
-  } catch (e) {
-    return Promise.reject(new InvokeFetchError(getErrorMessage(e), 0, new Headers(), {}));
-  }
-}
-async function performActualHttpFetch(method, completeUrl, unencodedBody, contentType, options, interceptors, authHeaders, credentials) {
-  const { body, contentTypeHeader, requestOptions } = encodeBody(unencodedBody, _nullishCoalesce(contentType, () => ( "")));
-  const headers = {
-    ...contentTypeHeader,
-    ...authHeaders,
-    ..._optionalChain([options, 'optionalAccess', _22 => _22.headers])
-  };
-  const isCrossOrigin = isHostCrossOrigin(_optionalChain([options, 'optionalAccess', _23 => _23.hostConfig]));
-  let request = {
-    method,
-    credentials,
-    mode: isCrossOrigin ? "cors" : "same-origin",
-    headers,
-    redirect: await isWindows(_optionalChain([options, 'optionalAccess', _24 => _24.hostConfig])) ? "manual" : "follow",
-    body,
-    // body data type must match "Content-Type" header
-    ...requestOptions
-    // This adds 'duplex: "half"' if we're sending application/octet-stream, needed in node only.
-  };
-  let fetchTimeoutId;
-  if (_optionalChain([options, 'optionalAccess', _25 => _25.timeoutMs]) && options.timeoutMs > 0) {
-    const controller = new AbortController();
-    fetchTimeoutId = setTimeout(() => {
-      controller.abort();
-    }, options.timeoutMs);
-    request.signal = controller.signal;
-  }
-  if (_optionalChain([interceptors, 'optionalAccess', _26 => _26.request, 'access', _27 => _27.hasInterceptors, 'call', _28 => _28()])) {
-    request = await interceptors.request.apply(completeUrl, request);
-  }
-  const fetchResponse = await fetchAndTransformExceptions(completeUrl, request);
-  if (fetchTimeoutId) {
-    clearTimeout(fetchTimeoutId);
-  }
-  let invokeFetchResponse = await parseFetchResponse(fetchResponse, completeUrl);
-  if (_optionalChain([interceptors, 'optionalAccess', _29 => _29.response, 'access', _30 => _30.hasInterceptors, 'call', _31 => _31()])) {
-    invokeFetchResponse = await interceptors.response.apply(invokeFetchResponse);
-  }
-  return invokeFetchResponse;
-}
-function encodeBody(unencodedBody, contentType) {
-  if (!unencodedBody) {
-    return { body: null, contentTypeHeader: {}, requestOptions: {} };
-  }
-  const contentTypeHeader = {};
-  const requestOptions = {};
-  let body = null;
-  switch (contentType) {
-    case "":
-    case "application/json":
-      contentTypeHeader["Content-Type"] = "application/json";
-      body = JSON.stringify(unencodedBody);
-      break;
-    case "multipart/form-data":
-      body = encodeMultipartBody(unencodedBody);
-      break;
-    case "application/octet-stream":
-      contentTypeHeader["Content-Type"] = contentType;
-      requestOptions["duplex"] = "half";
-      body = unencodedBody;
-      break;
-    case "text/plain":
-      if (typeof unencodedBody === "string") {
-        contentTypeHeader["Content-Type"] = contentType;
-        body = unencodedBody;
-      } else {
-        throw new EncodingError(
-          `Cannot send ${typeof unencodedBody} as ${contentType}, body should be a string.`,
-          contentType,
-          unencodedBody
-        );
-      }
-      break;
-    default:
-      throw new EncodingError(
-        `Unsupported content-type "${contentType}", supported are: application/json, multipart/form-data, application/octet-stream and text/plain`,
-        contentType,
-        unencodedBody
-      );
-  }
-  return { body, contentTypeHeader, requestOptions };
-}
-function encodeMultipartBody(unencodedBody) {
-  const contentType = "multipart/form-data";
-  if (typeof unencodedBody !== "object") {
-    throw new EncodingError(
-      `Cannot encode ${typeof unencodedBody} as ${contentType}, body should be an object.`,
-      contentType,
-      unencodedBody
-    );
-  }
-  if (Array.isArray(unencodedBody)) {
-    throw new EncodingError(
-      `Cannot encode ${typeof unencodedBody} as ${contentType}, body should be an object.`,
-      contentType,
-      unencodedBody
-    );
-  }
-  if (unencodedBody instanceof FormData) {
-    return unencodedBody;
-  }
-  const form = new FormData();
-  Object.entries(unencodedBody).forEach((entry) => {
-    const [key, value] = entry;
-    switch (typeof value) {
-      case "boolean":
-      case "number":
-      case "string":
-        form.set(key, `${value}`);
-        break;
-      case "object":
-        if (value instanceof Blob) {
-          form.set(key, value);
-        } else if (value instanceof Uint8Array) {
-          const data = new Blob([value], { type: "application/octet-stream" });
-          form.set(key, data);
-        } else {
-          const json = JSON.stringify(value);
-          const data = new Blob([json], { type: "application/json" });
-          form.set(key, data, "");
-        }
-        break;
-      default:
-        throw new EncodingError(
-          `Cannot encode multipart-field "${key}" with value of type ${typeof value}, values must be objects, strings, numbers or boolean.`,
-          contentType,
-          unencodedBody
-        );
-    }
-  });
-  return form;
-}
-async function getInvokeFetchUrlParams({
-  method,
-  pathTemplate,
-  pathVariables,
-  query,
-  options
-}) {
-  const locationUrl = toValidLocationUrl(_optionalChain([options, 'optionalAccess', _32 => _32.hostConfig]));
-  const {
-    headers: authHeaders,
-    queryParams: authQueryParams,
-    credentials
-  } = await getRestCallAuthParams({
-    hostConfig: _optionalChain([options, 'optionalAccess', _33 => _33.hostConfig]),
-    method
-  });
-  const url = locationUrl + applyPathVariables(pathTemplate, pathVariables);
-  const queryString = encodeQueryParams({ ...query, ...authQueryParams });
-  const completeUrl = toCompleteUrl(url, queryString);
-  const cacheKey = toCacheKey(url, queryString, _optionalChain([options, 'optionalAccess', _34 => _34.headers]));
-  return { completeUrl, cacheKey, authHeaders, credentials };
-}
-function invokeFetchWithUrl(api, props, interceptors) {
-  return invokeFetchWithUrlAndRetry(
-    api,
-    props,
-    async () => {
-      const { cacheKey, authHeaders, credentials } = await getInvokeFetchUrlParams(props);
-      return invokeFetchWithUrlAndRetry(
-        api,
-        { ...props, cacheKey, authHeaders, credentials },
-        void 0,
-        // only retry once
-        interceptors
-      );
-    },
-    interceptors
-  );
-}
-function invokeFetchWithUrlAndRetry(api, { method, completeUrl, cacheKey, body, options, authHeaders, credentials, contentType }, performRetry, interceptors) {
-  if (!cache[api]) {
-    cache[api] = {};
-  }
-  const cacheEntry = isModifyingVerb2(method) ? void 0 : cache[api][cacheKey];
-  if (isModifyingVerb2(method)) {
-    clearRelatedCacheEntries(cache[api], cacheKey);
-  }
-  if (cacheEntry && shouldUseCachedResult(options, cacheEntry, defaultCacheTime)) {
-    cacheEntry.lastHit = /* @__PURE__ */ new Date();
-    cacheEntry.hitCount += 1;
-    cacheEntry.accessedPaths.add(globalThis.location ? globalThis.location.pathname : "node");
-    return cloneResultPromise(cacheEntry.value);
-  }
-  const resultPromiseFromBackend = performActualHttpFetch(
-    method,
-    completeUrl,
-    body,
-    contentType,
-    options,
-    interceptors,
-    authHeaders,
-    credentials
-  );
-  const resultAfterAuthenticationCheck = interceptAuthenticationErrors(
-    _optionalChain([options, 'optionalAccess', _35 => _35.hostConfig]),
-    resultPromiseFromBackend,
-    performRetry
-  );
-  const resultPromiseAfterPagingAddon = addPagingFunctions(
-    api,
-    resultAfterAuthenticationCheck,
-    method,
-    body,
-    options,
-    interceptors,
-    authHeaders,
-    credentials
-  );
-  const resultPromiseAfterCacheClearing = clearCacheOnError(cache[api], cacheKey, resultPromiseAfterPagingAddon);
-  if (shouldPopulateCache(method)) {
-    if (Object.hasOwn && !Object.hasOwn(cache, api) || api === "__proto__") {
-      throw new Error(`Forbidden api name: ${api}`);
-    }
-    cache[api][cacheKey] = {
-      lastPulled: Date.now(),
-      value: resultPromiseAfterCacheClearing,
-      lastHit: null,
-      hitCount: 0,
-      accessedPaths: /* @__PURE__ */ new Set()
-    };
-  }
-  return cloneResultPromise(resultPromiseAfterCacheClearing);
-}
-function addPagingFunctions(api, value, method, body, options, interceptors, authHeaders, credentials) {
-  return value.then((resp) => {
-    const dataWithPotentialLinks = resp.data;
-    if (!dataWithPotentialLinks) {
-      return resp;
-    }
-    const prevUrl = _optionalChain([dataWithPotentialLinks, 'access', _36 => _36.links, 'optionalAccess', _37 => _37.prev, 'optionalAccess', _38 => _38.href]);
-    const nextUrl = _optionalChain([dataWithPotentialLinks, 'access', _39 => _39.links, 'optionalAccess', _40 => _40.next, 'optionalAccess', _41 => _41.href]);
-    if (prevUrl) {
-      resp.prev = (prevOptions) => invokeFetchWithUrl(
-        api,
-        {
-          method,
-          completeUrl: prevUrl,
-          body,
-          options: prevOptions || options,
-          cacheKey: toCacheKey(prevUrl, "", _optionalChain([options, 'optionalAccess', _42 => _42.headers])),
-          authHeaders,
-          credentials
-        },
-        interceptors
-      );
-    }
-    if (nextUrl) {
-      resp.next = (nextOptions) => invokeFetchWithUrl(
-        api,
-        {
-          method,
-          completeUrl: nextUrl,
-          body,
-          options: nextOptions || options,
-          cacheKey: toCacheKey(nextUrl, "", _optionalChain([options, 'optionalAccess', _43 => _43.headers])),
-          authHeaders,
-          credentials
-        },
-        interceptors
-      );
-    }
-    return resp;
-  });
-}
-function neverResolvingPromise() {
-  return new Promise(() => {
-  });
-}
-async function interceptAuthenticationErrors(hostConfig, resultPromise, performRetry) {
-  try {
-    return await resultPromise;
-  } catch (error) {
-    const err = error;
-    if (err.status === 401 || err.status === 403 || (err.status === 301 || err.status === 302) && await isWindows(hostConfig)) {
-      if (globalThis.loggingOut) {
-        return await neverResolvingPromise();
-      }
-      const { retry, preventDefault } = await handleAuthenticationError({
-        hostConfig,
-        status: err.status,
-        headers: err.headers,
-        errorBody: err.data,
-        canRetry: !!performRetry
-      });
-      if (retry && performRetry) {
-        return await performRetry();
-      }
-      if (preventDefault) {
-        return neverResolvingPromise();
-      }
-    }
-    throw error;
-  }
-}
-function toDownloadableBlob(blob) {
-  const result2 = blob;
-  result2.download = (filename) => download(blob, filename);
-  return result2;
-}
-async function download(blob, filename) {
-  if (isBrowser()) {
-    const a = document.createElement("a");
-    a.href = window.URL.createObjectURL(blob);
-    a.download = filename;
-    a.click();
-  } else {
-    const { writeFileSync } = await Promise.resolve().then(() => _interopRequireWildcard(require("fs")));
-    writeFileSync(filename, Buffer.from(await blob.arrayBuffer()));
-  }
-}
-
-// src/invoke-fetch/invoke-fetch-error.ts
-var InvokeFetchError = class extends Error {
-  
-  
-  
-  constructor(errorMessage, status, headers, data) {
-    super(errorMessage);
-    this.status = status;
-    this.headers = headers;
-    this.data = data;
-    this.stack = cleanStack(this.stack);
-  }
-};
-var EncodingError = class extends Error {
-  
-  
-  constructor(errorMessage, contentType, data) {
-    super(errorMessage);
-    this.contentType = contentType;
-    this.data = data;
-    this.stack = cleanStack(this.stack);
-  }
-};
-var regex = /^.+\/qmfe-api(?:\.js)?:(\d+)(?::\d+)?$/gim;
-var isFromQmfeApi = (line) => {
-  const matches = line.match(regex);
-  return Boolean(matches && matches.length > 0);
-};
-function cleanStack(stack) {
-  if (!stack) {
-    return stack;
-  }
-  const newStack = [];
-  const lines = stack.split("\n");
-  lines.reverse();
-  for (const line of lines) {
-    if (isFromQmfeApi(line)) {
-      break;
-    }
-    newStack.unshift(line);
-  }
-  return newStack.join("\n");
-}
-
-// src/invoke-fetch/invoke-fetch-functions.ts
-async function invokeFetch(api, props, interceptors) {
-  checkForCrossDomainRequest(_optionalChain([props, 'access', _44 => _44.options, 'optionalAccess', _45 => _45.hostConfig]));
-  const { completeUrl, cacheKey, authHeaders, credentials } = await getInvokeFetchUrlParams(props);
-  return invokeFetchWithUrl(
-    api,
-    { ...props, method: props.method.toUpperCase(), completeUrl, cacheKey, authHeaders, credentials },
-    interceptors
-  );
-}
-function clearApiCache(api) {
-  clearApiCacheInternal(api);
-}
-async function parseFetchResponse(fetchResponse, url) {
-  let resultData;
-  const contentType = _optionalChain([fetchResponse, 'access', _46 => _46.headers, 'access', _47 => _47.get, 'call', _48 => _48("content-type"), 'optionalAccess', _49 => _49.split, 'call', _50 => _50(";"), 'access', _51 => _51[0]]);
-  switch (contentType) {
-    case "image/png":
-    case "image/jpeg":
-    case "image/x-icon":
-    case "application/offset+octet-stream":
-    case "application/octet-stream":
-      resultData = toDownloadableBlob(await fetchResponse.blob());
-      break;
-    default:
-      try {
-        resultData = await fetchResponse.text();
-        resultData = JSON.parse(resultData);
-      } catch (e3) {
-      }
-      break;
-  }
-  const { status, statusText, headers } = fetchResponse;
-  const errorMsg = `request to '${url}' failed with status ${status} ${statusText}.`;
-  if (status >= 300) {
-    throw new InvokeFetchError(errorMsg, status, headers, resultData);
-  }
-  if (status === 0) {
-    throw new InvokeFetchError(errorMsg, 302, headers, resultData);
-  }
-  const invokeFetchResponse = {
-    status,
-    headers,
-    data: resultData
-  };
-  return invokeFetchResponse;
-}
-
-// src/invoke-fetch/invoke-fetch.ts
-var invokeFetchExp = {
-  invokeFetch,
-  clearApiCache,
-  parseFetchResponse
-};
-var invoke_fetch_default = invokeFetchExp;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.getPlatform = getPlatform; exports.InvalidHostConfigError = InvalidHostConfigError; exports.UnexpectedAuthTypeError = UnexpectedAuthTypeError; exports.InvalidAuthTypeError = InvalidAuthTypeError; exports.AuthorizationError = AuthorizationError; exports.isHostCrossOrigin = isHostCrossOrigin; exports.isWindows = isWindows; exports.toValidLocationUrl = toValidLocationUrl; exports.toValidEnigmaLocationUrl = toValidEnigmaLocationUrl; exports.toValidWebsocketLocationUrl = toValidWebsocketLocationUrl; exports.getWebSocketAuthParams = getWebSocketAuthParams; exports.getWebResourceAuthParams = getWebResourceAuthParams; exports.handleAuthenticationError = handleAuthenticationError; exports.getRestCallAuthParams = getRestCallAuthParams; exports.registerAuthModule = registerAuthModule2; exports.setDefaultHostConfig = setDefaultHostConfig2; exports.checkForCrossDomainRequest = checkForCrossDomainRequest; exports.logout = logout; exports.generateRandomString = generateRandomString; exports.InvokeFetchError = InvokeFetchError; exports.EncodingError = EncodingError; exports.invokeFetch = invokeFetch; exports.clearApiCache = clearApiCache; exports.parseFetchResponse = parseFetchResponse; exports.invoke_fetch_default = invoke_fetch_default; exports.auth_default = auth_default;