@qlik/api 1.22.0 → 1.24.0

package/chunks/7BDAXGID.js

@@ -0,0 +1,116 @@
+import {
+  isBrowser
+} from "./2ZQ3ZX7F.js";
+
+// src/interceptors/interceptors.ts
+var GLOBAL_INTERCEPTORS;
+function createInterceptors() {
+  const startingInterceptors = GLOBAL_INTERCEPTORS?.getInterceptors() || [];
+  const interceptors2 = [...startingInterceptors];
+  return {
+    /**
+     * Adds an interceptor to the global interceptor stack
+     * Returns the newly added interceptor
+     * @param interceptor the interceptor to add
+     * @returns the newly added interceptor
+     */
+    addInterceptor: (interceptor) => {
+      interceptors2.push(interceptor);
+      return interceptor;
+    },
+    /**
+     * Removes an interceptor from the global interceptor stack
+     * Returns null if the interceptor was not found
+     * @param interceptor the interceptor remove
+     * @returns the removed interceptor or null if not found
+     */
+    removeInterceptor: (interceptor) => {
+      const index = interceptors2.indexOf(interceptor);
+      let removed;
+      if (index !== -1) {
+        removed = interceptors2.splice(index, 1)[0];
+      }
+      return removed || null;
+    },
+    /**
+     * Gets all registered interceptors
+     */
+    getInterceptors: () => interceptors2
+  };
+}
+var addDefaultInterceptorsRun = false;
+function addDefaultInterceptors() {
+  if (addDefaultInterceptorsRun) {
+    return;
+  }
+  if (isBrowser()) {
+    const readFlagsFromUrlQuery = () => {
+      const params = new URLSearchParams(window.location.search);
+      const featuresParam = params.get("features");
+      if (!featuresParam) {
+        return {};
+      }
+      const features = featuresParam.split(",").map((item) => item.trim());
+      const urlFeatures = features.reduce(
+        (map, obj) => {
+          const value = !obj.startsWith("!");
+          const key = value ? obj : obj.substring(1);
+          map[key] = value;
+          return map;
+        },
+        {}
+      );
+      return urlFeatures;
+    };
+    const readFlagsFromLocalStorage = () => {
+      try {
+        const featuresParam = localStorage.getItem("qcs-features");
+        if (featuresParam) {
+          return JSON.parse(featuresParam);
+        }
+        return {};
+      } catch {
+        return {};
+      }
+    };
+    const flagsFromUrl = readFlagsFromUrlQuery();
+    const flagsFromLocalStorage = readFlagsFromLocalStorage();
+    const interceptor = async (request, proceed) => {
+      let resultPromise;
+      if (request.pathTemplate === "/api/v1/features") {
+        resultPromise = proceed(request);
+        const result = await resultPromise;
+        return { ...result, data: { ...result.data || {}, ...flagsFromLocalStorage, ...flagsFromUrl } };
+      }
+      return proceed(request);
+    };
+    GLOBAL_INTERCEPTORS.addInterceptor(interceptor);
+  }
+  addDefaultInterceptorsRun = true;
+}
+GLOBAL_INTERCEPTORS = createInterceptors();
+function addInterceptor(interceptor) {
+  return GLOBAL_INTERCEPTORS.addInterceptor(interceptor);
+}
+function removeInterceptor(interceptor) {
+  return GLOBAL_INTERCEPTORS.removeInterceptor(interceptor);
+}
+function getInterceptors() {
+  return GLOBAL_INTERCEPTORS.getInterceptors();
+}
+var interceptors = {
+  addInterceptor,
+  removeInterceptor,
+  getInterceptors,
+  createInterceptors
+};
+var interceptors_default = interceptors;
+
+export {
+  createInterceptors,
+  addDefaultInterceptors,
+  addInterceptor,
+  removeInterceptor,
+  getInterceptors,
+  interceptors_default
+};

package/chunks/{TGDZVKG2.js → BL5PJM4B.js}

@@ -1,6 +1,6 @@
 import {
   getAuthRuntimeModule
-} from "./SNQHDUYY.js";
+} from "./CZC7KEJN.js";
 
 // src/public/auth.ts
 function registerAuthModule(name, authModule) {

package/chunks/{SNQHDUYY.js → CZC7KEJN.js}

@@ -1,21 +1,21 @@
 // src/public/public-runtime-modules.ts
 function getAuthRuntimeModule(hostConfig) {
   const isNode = !!globalThis.process?.argv;
-  return isNode ? import("./SEBN4KFZ.js") : import("./EUWNVVK5.js").then(
+  return isNode ? import("./6DEESTGF.js") : import("./VX3MQBE7.js").then(
     (mod) => mod.importRuntimeModule("auth@v1", hostConfig)
   );
 }
 async function getQixRuntimeModule(hostConfig) {
   await getAuthRuntimeModule(hostConfig);
   const isNode = !!globalThis.process?.argv;
-  return isNode ? import("./KBR7JBWC.js") : import("./EUWNVVK5.js").then(
+  return isNode ? import("./N3ZFICDU.js") : import("./VX3MQBE7.js").then(
     (mod) => mod.importRuntimeModule("qix@v1", hostConfig)
   );
 }
 async function getInvokeFetchRuntimeModule(hostConfig) {
   await getAuthRuntimeModule(hostConfig);
   const isNode = !!globalThis.process?.argv;
-  return isNode ? import("./GZRY5VHW.js") : import("./EUWNVVK5.js").then(
+  return isNode ? import("./3DYV7KOJ.js") : import("./VX3MQBE7.js").then(
     (mod) => mod.importRuntimeModule("invoke-fetch@v1", hostConfig)
   );
 }

package/chunks/{OEVNZ5IQ.js → I5UOE4ZZ.js}

@@ -1,3 +1,6 @@
+import {
+  getInterceptors
+} from "./7BDAXGID.js";
 import {
   isBrowser,
   isNode
@@ -1142,19 +1145,27 @@ async function getCsrfToken(hostConfig, noCache) {
     pathTemplate = "/api/v1/csrf-token";
   }
   const fetchCsrfToken = async () => {
-    const res = await invokeFetch("csrf-token", {
-      method: "get",
-      pathTemplate,
-      options: {
-        hostConfig,
-        noCache: true
+    try {
+      const res = await invokeFetch("csrf-token", {
+        method: "get",
+        pathTemplate,
+        options: {
+          hostConfig,
+          noCache: true
+        }
+      });
+      const csrfToken = res.headers.get(QLIK_CSRF_TOKEN);
+      if (!csrfToken) {
+        return "";
       }
-    });
-    const csrfToken = res.headers.get(QLIK_CSRF_TOKEN);
-    if (!csrfToken) {
-      return "";
+      return csrfToken;
+    } catch (e) {
+      const error = e;
+      if (error.status === 404) {
+        return "";
+      }
+      throw e;
     }
-    return csrfToken;
   };
   if (noCache) {
     csrfTokens[locationUrl] = fetchCsrfToken();
@@ -1403,10 +1414,10 @@ function getXrfKey(hostConfig) {
 }
 
 // src/auth/internal/default-auth-modules/windows-cookie.ts
-function getRestCallAuthParams7({
+async function getRestCallAuthParams7({
   hostConfig
 }) {
-  return Promise.resolve({
+  return {
     headers: {
       "X-Qlik-XrfKey": getXrfKey(hostConfig)
     },
@@ -1414,16 +1425,17 @@ function getRestCallAuthParams7({
       xrfkey: getXrfKey(hostConfig)
     },
     credentials: getCredentialsForCookieAuth(hostConfig)
-  });
+  };
 }
-function getWebSocketAuthParams7({
+async function getWebSocketAuthParams7({
   hostConfig
 }) {
-  return Promise.resolve({
+  return {
     queryParams: {
-      xrfkey: getXrfKey(hostConfig)
+      xrfkey: getXrfKey(hostConfig),
+      "qlik-csrf-token": await getCsrfToken(hostConfig, true)
     }
-  });
+  };
 }
 async function handleAuthenticationError7({
   hostConfig
@@ -1635,10 +1647,10 @@ async function fetchAndTransformExceptions(input, init) {
   try {
     return await fetch(input, init);
   } catch (e) {
-    return Promise.reject(new InvokeFetchError(getErrorMessage(e), 0, new Headers(), {}));
+    return Promise.reject(new InvokeFetchError2(getErrorMessage(e), 0, new Headers(), {}));
   }
 }
-async function performActualHttpFetch(method, completeUrl, unencodedBody, contentType, options, interceptors, authHeaders, credentials, userAgent) {
+async function performActualHttpFetch(method, completeUrl, unencodedBody, contentType, options, authHeaders, credentials, userAgent) {
   const { body, contentTypeHeader, requestOptions } = encodeBody(unencodedBody, contentType ?? "");
   const headers = {
     ...contentTypeHeader,
@@ -1650,12 +1662,13 @@ async function performActualHttpFetch(method, completeUrl, unencodedBody, conten
     headers["User-Agent"] = userAgent;
   }
   const isCrossOrigin = isHostCrossOrigin(options?.hostConfig);
-  let request = {
+  const request = {
     method,
     credentials,
     mode: isCrossOrigin ? "cors" : "same-origin",
     headers,
     redirect: await isWindows(options?.hostConfig) ? "manual" : "follow",
+    keepalive: options?.keepalive,
     body,
     // body data type must match "Content-Type" header
     ...requestOptions
@@ -1671,17 +1684,11 @@ async function performActualHttpFetch(method, completeUrl, unencodedBody, conten
     }, options.timeoutMs);
     request.signal = controller.signal;
   }
-  if (interceptors?.request.hasInterceptors()) {
-    request = await interceptors.request.apply(completeUrl, request);
-  }
   const fetchResponse = await fetchAndTransformExceptions(completeUrl, request);
   if (fetchTimeoutId) {
     clearTimeout(fetchTimeoutId);
   }
-  let invokeFetchResponse = await parseFetchResponse(fetchResponse, completeUrl);
-  if (interceptors?.response.hasInterceptors()) {
-    invokeFetchResponse = await interceptors.response.apply(invokeFetchResponse);
-  }
+  const invokeFetchResponse = await parseFetchResponse(fetchResponse, completeUrl);
   return invokeFetchResponse;
 }
 function encodeBody(unencodedBody, contentType) {
@@ -1798,23 +1805,17 @@ async function getInvokeFetchUrlParams({
   const cacheKey = toCacheKey(url, queryString, serializeHostConfig(options?.hostConfig), options?.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, options: { ...props.options, noCache: true } },
-        // don't cache the retry
-        void 0,
-        // only retry once
-        interceptors
-      );
-    },
-    interceptors
-  );
+function invokeFetchWithUrl(api, props) {
+  return invokeFetchWithUrlAndRetry(api, props, async () => {
+    const { cacheKey, authHeaders, credentials } = await getInvokeFetchUrlParams(props);
+    return invokeFetchWithUrlAndRetry(
+      api,
+      { ...props, cacheKey, authHeaders, credentials, options: { ...props.options, noCache: true } },
+      // don't cache the retry
+      void 0
+      // only retry once
+    );
+  });
 }
 function invokeFetchWithUrlAndRetry(api, {
   method,
@@ -1826,7 +1827,7 @@ function invokeFetchWithUrlAndRetry(api, {
   credentials,
   contentType,
   userAgent
-}, performRetry, interceptors) {
+}, performRetry) {
   if (!cache[api]) {
     cache[api] = {};
   }
@@ -1846,7 +1847,6 @@ function invokeFetchWithUrlAndRetry(api, {
     body,
     contentType,
     options,
-    interceptors,
     authHeaders,
     credentials,
     userAgent
@@ -1862,7 +1862,6 @@ function invokeFetchWithUrlAndRetry(api, {
     method,
     body,
     options,
-    interceptors,
     authHeaders,
     credentials
   );
@@ -1881,7 +1880,7 @@ function invokeFetchWithUrlAndRetry(api, {
   }
   return cloneResultPromise(resultPromiseAfterCacheClearing);
 }
-function addPagingFunctions(api, value, method, body, options, interceptors, authHeaders, credentials) {
+function addPagingFunctions(api, value, method, body, options, authHeaders, credentials) {
   const serializedHostConfig = serializeHostConfig(options?.hostConfig);
   return value.then((resp) => {
     const dataWithPotentialLinks = resp.data;
@@ -1891,34 +1890,26 @@ function addPagingFunctions(api, value, method, body, options, interceptors, aut
     const prevUrl = dataWithPotentialLinks.links?.prev?.href;
     const nextUrl = dataWithPotentialLinks.links?.next?.href;
     if (prevUrl) {
-      resp.prev = (prevOptions) => invokeFetchWithUrl(
-        api,
-        {
-          method,
-          completeUrl: prevUrl,
-          body,
-          options: prevOptions || options,
-          cacheKey: toCacheKey(prevUrl, "", serializedHostConfig, options?.headers),
-          authHeaders,
-          credentials
-        },
-        interceptors
-      );
+      resp.prev = (prevOptions) => invokeFetchWithUrl(api, {
+        method,
+        completeUrl: prevUrl,
+        body,
+        options: prevOptions || options,
+        cacheKey: toCacheKey(prevUrl, "", serializedHostConfig, options?.headers),
+        authHeaders,
+        credentials
+      });
     }
     if (nextUrl) {
-      resp.next = (nextOptions) => invokeFetchWithUrl(
-        api,
-        {
-          method,
-          completeUrl: nextUrl,
-          body,
-          options: nextOptions || options,
-          cacheKey: toCacheKey(nextUrl, "", serializedHostConfig, options?.headers),
-          authHeaders,
-          credentials
-        },
-        interceptors
-      );
+      resp.next = (nextOptions) => invokeFetchWithUrl(api, {
+        method,
+        completeUrl: nextUrl,
+        body,
+        options: nextOptions || options,
+        cacheKey: toCacheKey(nextUrl, "", serializedHostConfig, options?.headers),
+        authHeaders,
+        credentials
+      });
     }
     return resp;
   });
@@ -1990,7 +1981,7 @@ async function download(blob, filename) {
 }
 
 // src/invoke-fetch/invoke-fetch-error.ts
-var InvokeFetchError = class extends Error {
+var InvokeFetchError2 = class extends Error {
   status;
   headers;
   data;
@@ -2036,6 +2027,15 @@ function cleanStack(stack) {
 // src/invoke-fetch/invoke-fetch-functions.ts
 var defaultUserAgent = "qmfe-api/latest";
 async function invokeFetch(api, props, interceptors) {
+  interceptors = interceptors || getInterceptors();
+  const invokeFetchFinal = (reqeust) => invokeFetchIntercepted(api, reqeust);
+  const withInterceptors = (interceptors || []).reduce(
+    (proceed, interceptor) => (request) => interceptor(request, proceed),
+    invokeFetchFinal
+  );
+  return withInterceptors(props);
+}
+async function invokeFetchIntercepted(api, props) {
   checkForCrossDomainRequest(props.options?.hostConfig);
   let userAgent;
   if (props?.userAgent) {
@@ -2046,11 +2046,15 @@ async function invokeFetch(api, props, interceptors) {
     userAgent = defaultUserAgent;
   }
   const { completeUrl, cacheKey, authHeaders, credentials } = await getInvokeFetchUrlParams(props);
-  return invokeFetchWithUrl(
-    api,
-    { ...props, method: props.method.toUpperCase(), completeUrl, cacheKey, authHeaders, credentials, userAgent },
-    interceptors
-  );
+  return invokeFetchWithUrl(api, {
+    ...props,
+    method: props.method.toUpperCase(),
+    completeUrl,
+    cacheKey,
+    authHeaders,
+    credentials,
+    userAgent
+  });
 }
 function clearApiCache(api) {
   clearApiCacheInternal(api);
@@ -2072,6 +2076,7 @@ async function parseFetchResponse(fetchResponse, url) {
     resultData = toDownloadableBlob(await fetchResponse.blob(), filename);
   } else {
     switch (contentType) {
+      // Note: This list is by no means exhaustive, populate with more types as needed.
       case "image/png":
       case "image/jpeg":
       case "image/x-icon":
@@ -2079,6 +2084,7 @@ async function parseFetchResponse(fetchResponse, url) {
       case "application/octet-stream":
       case "application/zip":
       case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
+      case "application/pdf":
         resultData = toDownloadableBlob(await fetchResponse.blob());
         break;
       case "text/event-stream":
@@ -2096,10 +2102,10 @@ async function parseFetchResponse(fetchResponse, url) {
   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);
+    throw new InvokeFetchError2(errorMsg, status, headers, resultData);
   }
   if (status === 0) {
-    throw new InvokeFetchError(errorMsg, 302, headers, resultData);
+    throw new InvokeFetchError2(errorMsg, 302, headers, resultData);
   }
   const invokeFetchResponse = {
     status,
@@ -2139,12 +2145,11 @@ export {
   checkForCrossDomainRequest,
   logout,
   generateRandomString,
-  InvokeFetchError,
+  InvokeFetchError2 as InvokeFetchError,
   EncodingError,
   invokeFetch,
   clearApiCache,
   parseFetchResponse,
   invoke_fetch_default,
-  getCsrfToken,
   auth_default
 };

package/chunks/{KBR7JBWC.js → N3ZFICDU.js}

@@ -4,8 +4,8 @@ import {
   invokeFetch,
   isWindows,
   toValidWebsocketLocationUrl
-} from "./OEVNZ5IQ.js";
-import "./7RHSSS4W.js";
+} from "./I5UOE4ZZ.js";
+import "./7BDAXGID.js";
 import {
   isBrowser
 } from "./2ZQ3ZX7F.js";
@@ -88,7 +88,8 @@ function toGlobalAppSessionId({
   hostConfig,
   withoutData,
   useReloadEngine,
-  ttlSeconds
+  ttlSeconds,
+  workloadType
 }) {
   const locationUrl = toValidWebsocketLocationUrl(hostConfig);
   let url = `${locationUrl}/${appId}`;
@@ -104,6 +105,9 @@ function toGlobalAppSessionId({
   if (withoutData) {
     url += "/withoutData";
   }
+  if (workloadType) {
+    url += `?workloadType=${workloadType}`;
+  }
   return url;
 }
 async function runPendingInitialActions(initialActionsForApp, sharedSession, doc) {
@@ -114,7 +118,7 @@ async function runPendingInitialActions(initialActionsForApp, sharedSession, doc
     }
   }
 }
-async function addInitialSharedSessionCreationAction(openAppSessionProps, action) {
+function addInitialSharedSessionCreationAction(openAppSessionProps, action) {
   const key = toGlobalAppSessionId(openAppSessionProps);
   let initialActionArray = initialActions[key];
   if (!initialActionArray) {
@@ -123,11 +127,18 @@ async function addInitialSharedSessionCreationAction(openAppSessionProps, action
   initialActionArray.push(action);
   const existingSharedSession = sharedSessions[key];
   if (existingSharedSession) {
-    const doc = await existingSharedSession.docPromise;
-    if (doc) {
-      runPendingInitialActions(initialActionArray, existingSharedSession, doc);
-    }
+    existingSharedSession.docPromise.then((doc) => {
+      if (doc) {
+        runPendingInitialActions(initialActionArray, existingSharedSession, doc);
+      }
+    });
   }
+  return () => {
+    const index = initialActionArray.indexOf(action);
+    if (index > -1) {
+      initialActionArray.splice(index, 1);
+    }
+  };
 }
 function listenForWindowsAuthenticationInformation(session) {
   let resolveAuthSuggestedInWebsocket;
@@ -150,7 +161,7 @@ function listenForWindowsAuthenticationInformation(session) {
   return authSuggestedInWebsocket;
 }
 async function createAndSetupEnigmaSession(props, canRetry) {
-  const { createEnigmaSession } = await import("./PR52AAWU.js");
+  const { createEnigmaSession } = await import("./6QRR5VUM.js");
   const session = await createEnigmaSession(props);
   setupSessionListeners(session, props);
   let global;
@@ -444,7 +455,18 @@ function resumeShouldRejectPromiseIfNotReattached(bool) {
 }
 async function checkConnectivity(hostConfig) {
   let status = "online";
-  const catchFunc = (err) => {
+  const method = "get";
+  const options = {
+    hostConfig,
+    timeoutMs: 4e3,
+    noCache: true
+  };
+  try {
+    const result = await invokeFetch("", { method, pathTemplate: "/api/v1/user-locale", options });
+    if (!result.headers.get("content-type")?.includes("application/json")) {
+      status = "unauthorized";
+    }
+  } catch (err) {
     const fetchErr = err;
     switch (fetchErr.status) {
       case 0:
@@ -454,16 +476,7 @@ async function checkConnectivity(hostConfig) {
         status = "unauthorized";
         break;
     }
-  };
-  const method = "get";
-  const options = {
-    hostConfig,
-    timeoutMs: 2e3,
-    noCache: true
-  };
-  const fetchRoot = invokeFetch("", { method, pathTemplate: "", options }).catch(catchFunc);
-  const fetchMe = invokeFetch("", { method, pathTemplate: "/api/v1/users/me", options }).catch(catchFunc);
-  await Promise.all([fetchRoot, fetchMe]);
+  }
   return Promise.resolve(status);
 }
 async function sessionResumeWithRetry(session, hostConfig) {
@@ -571,15 +584,16 @@ function getExternalSession(externalApp, appSessionProps) {
 }
 
 // src/qix/qix-functions.ts
-async function createSessionApp(ttlSeconds) {
+async function createSessionApp(ttlSeconds, workloadType) {
   let sharedSession;
   if ((await getPlatform()).isCloud) {
-    sharedSession = await getOrCreateSharedSession({ appId: `SessionApp_${Date.now()}`, ttlSeconds });
+    sharedSession = await getOrCreateSharedSession({ appId: `SessionApp_${Date.now()}`, ttlSeconds, workloadType });
   } else {
     sharedSession = await getOrCreateSharedSession({
       appId: `%3Ftransient%3D/identity/${Date.now()}`,
       useSessionApp: true,
-      ttlSeconds
+      ttlSeconds,
+      workloadType
     });
   }
   let alreadyClosed = false;
@@ -663,7 +677,7 @@ function useAppHook(react) {
   };
 }
 function addInitialAppAction(openAppSessionProps, action) {
-  addInitialSharedSessionCreationAction(openAppSessionProps, action);
+  return addInitialSharedSessionCreationAction(openAppSessionProps, action);
 }
 function onWebSocketEvent(fn) {
   return globalOnWebSocketEvent(fn);

package/chunks/{VHPC6L7L.js → OIQ5ELGS.js}

@@ -1,6 +1,6 @@
 import {
   getQixRuntimeModule
-} from "./SNQHDUYY.js";
+} from "./CZC7KEJN.js";
 
 // src/public/qix.ts
 function openAppSession(appSessionProps) {

package/chunks/{TUPLQG25.js → UA6BE3VB.js}

@@ -1,12 +1,12 @@
 import {
   getInvokeFetchRuntimeModule
-} from "./SNQHDUYY.js";
+} from "./CZC7KEJN.js";
 import {
   isBrowser
 } from "./2ZQ3ZX7F.js";
 
 // src/public/invoke-fetch.ts
-var defaultUserAgent = "qlik-api/1.22.0";
+var defaultUserAgent = "qlik-api/1.24.0";
 async function invokeFetch(api, props) {
   const hostConfig = props.options?.hostConfig;
   let userAgent;

package/chunks/{EUWNVVK5.js → VX3MQBE7.js}

@@ -1,4 +1,4 @@
-// node_modules/.pnpm/@qlik+runtime-module-loader@1.0.13/node_modules/@qlik/runtime-module-loader/dist/index.js
+// node_modules/.pnpm/@qlik+runtime-module-loader@1.0.14/node_modules/@qlik/runtime-module-loader/dist/index.js
 window.__qlikMainPrivateResolvers = window.__qlikMainPrivateResolvers || {};
 window.__qlikMainPrivateResolvers.mainUrlPromise = window.__qlikMainPrivateResolvers.mainUrlPromise || new Promise((resolve) => {
   window.__qlikMainPrivateResolvers.resolveMainJsUrl = (value) => resolve(value);

package/collections.d.ts

@@ -1,4 +1,4 @@
-import { A as ApiCallOptions } from './global.types-qsBNouXJ.js';
+import { A as ApiCallOptions } from './invoke-fetch-types-BLrpeZOL.js';
 import './auth-types-PkN9CAF_.js';
 
 type CollectionByIdPatch = {

package/collections.js

@@ -1,8 +1,8 @@
 import {
   clearApiCache,
   invokeFetch
-} from "./chunks/TUPLQG25.js";
-import "./chunks/SNQHDUYY.js";
+} from "./chunks/UA6BE3VB.js";
+import "./chunks/CZC7KEJN.js";
 import "./chunks/2ZQ3ZX7F.js";
 
 // src/public/rest/collections.ts

package/csp-origins.d.ts

@@ -1,4 +1,4 @@
-import { A as ApiCallOptions } from './global.types-qsBNouXJ.js';
+import { A as ApiCallOptions } from './invoke-fetch-types-BLrpeZOL.js';
 import './auth-types-PkN9CAF_.js';
 
 type CSPEntry = {