@sanity/sdk 2.18.0 → 3.0.0-rc.1

package/dist/index.js

@@ -1,22 +1,24 @@
-import { switchMap, from, firstValueFrom, EMPTY, asapScheduler, distinctUntilChanged, map as map$1, combineLatest, of, concatMap, withLatestFrom, filter as filter$1, concat, timer, throwError, defer, Observable, first as first$1, Subject, takeUntil, share, partition, merge, shareReplay, tap as tap$1, catchError as catchError$1, startWith as startWith$1, pairwise as pairwise$1, groupBy as groupBy$1, mergeMap as mergeMap$1, retry, throttle, race, skip, NEVER, fromEvent, Subscription, debounceTime } from "rxjs";
-import { createLogger, pickProperties, insecureRandomId, getClientState, bindActionGlobally, createStateSourceAction, setCleanupTimeout, omitProperty, defineStore, authStore, getAuthLogger, AuthStateType, getCleanedUrl, getTokenFromLocation, createLoggedInAuthState, getAuthCode, REQUEST_TAG_PREFIX, DEFAULT_API_VERSION, getDefaultLocation, isDeepEqual, configureLogging as configureLogging$1, isReleasePerspective, bindActionByResource, isDatasetResource, isMediaLibraryResource, isCanvasResource, getCurrentUserState, getUsersKey, addSubscription, USERS_STATE_CLEAR_DELAY, removeSubscription, parseUsersKey, getClient, PROJECT_API_VERSION, setUsersError, setUsersData, API_VERSION as API_VERSION$8, getDashboardOrganizationId as getDashboardOrganizationId$1, updateLastLoadMoreRequest, cancelRequest, initializeRequest, getTokenState, getQueryState, resolveQuery, bindActionByResourceAndPerspective, PREVIEW_PROJECTION, transformProjectionToPreview } from "./_chunks-es/createGroqSearchFilter.js";
-import { createGroqSearchFilter, getActiveReleasesState, getAllReleasesState, getAuthState, getClientErrorApiBody, getClientErrorApiDescription, getClientErrorApiType, getIsInDashboardState, getLoginUrlState, getPerspectiveState, getQueryKey, isCanvasSource, isDatasetSource, isMediaLibrarySource, isProjectUserNotFoundClientError, isStudioConfig, parseQueryKey, setAuthToken } from "./_chunks-es/createGroqSearchFilter.js";
-import { first, switchMap as switchMap$1, groupBy, mergeMap, startWith, pairwise, filter, map, delay, tap, catchError, scan, share as share$1 } from "rxjs/operators";
+import { CorsOriginError } from "@sanity/client";
+import { switchMap, map, from, distinctUntilChanged, combineLatest, of, firstValueFrom, EMPTY, asapScheduler, concatMap, withLatestFrom, filter as filter$1, concat, timer, throwError, defer, Observable, first as first$1, Subject, takeUntil, share, partition, merge, shareReplay, tap as tap$1, catchError as catchError$1, startWith as startWith$1, pairwise as pairwise$1, groupBy as groupBy$1, mergeMap as mergeMap$1, retry, throttle, race, skip, NEVER, fromEvent, Subscription, debounceTime } from "rxjs";
+import { createLogger, pickProperties, insecureRandomId, defineFetcher, getClientState, defineMutation, bindActionGlobally, authStore, createStateSourceAction, getAuthLogger, AuthStateType, getCleanedUrl, getTokenFromLocation, createLoggedInAuthState, getAuthCode, REQUEST_TAG_PREFIX, DEFAULT_API_VERSION, getDefaultLocation, isDeepEqual, defineStore, setCleanupTimeout, configureLogging as configureLogging$1, omitProperty, isReleasePerspective, bindActionByResource, isDatasetResource, isMediaLibraryResource, isCanvasResource, getCurrentUserState, getUsersKey, addSubscription, USERS_STATE_CLEAR_DELAY, removeSubscription, parseUsersKey, getClient, PROJECT_API_VERSION, setUsersError, setUsersData, API_VERSION as API_VERSION$c, getDashboardOrganizationId as getDashboardOrganizationId$1, updateLastLoadMoreRequest, cancelRequest, initializeRequest, getTokenState, getQueryState, resolveQuery, bindActionByResourceAndPerspective, PREVIEW_PROJECTION, transformProjectionToPreview } from "./_chunks-es/createGroqSearchFilter.js";
+import { CORE_SDK_VERSION, createGroqSearchFilter, getActiveReleasesState, getAllReleasesState, getAuthState, getClientErrorApiBody, getClientErrorApiDescription, getClientErrorApiType, getIsInDashboardState, getLoginUrlState, getPerspectiveState, getQueryKey, isCanvasSource, isDatasetSource, isMediaLibrarySource, isProjectUserNotFoundClientError, isStudioConfig, parseQueryKey, setAuthToken } from "./_chunks-es/createGroqSearchFilter.js";
 import { createController, createNode } from "@sanity/comlink";
+import "zustand/middleware";
+import "zustand/vanilla";
 import { createSelector } from "reselect";
+import { first, switchMap as switchMap$1, groupBy, mergeMap, startWith, pairwise, filter, map as map$1, delay, tap, catchError, scan, share as share$1 } from "rxjs/operators";
 import { SanityEncoder } from "@sanity/mutate";
+import { createDocumentLoaderFromClient } from "@sanity/mutate/_unstable_store";
+import { isKeySegment, isKeyedObject } from "@sanity/types";
+import "groq";
 import { getVersionId, DocumentId, getPublishedId, getDraftId, isDraftId, isVersionId, isPublishedId } from "@sanity/id-utils";
 import { jsonMatch, stringifyPath, slicePath, getIndexForKey } from "@sanity/json-match";
 import { getIndexForKey as getIndexForKey2, getPathDepth, joinPaths, jsonMatch as jsonMatch2, slicePath as slicePath2, stringifyPath as stringifyPath2 } from "@sanity/json-match";
 import { evaluateSync, parse } from "groq-js";
 import { applyPatches, parsePatch } from "@sanity/diff-match-patch";
-import { isKeySegment, isKeyedObject } from "@sanity/types";
 import { diffValue } from "@sanity/diff-patch";
-import { createDocumentLoaderFromClient } from "@sanity/mutate/_unstable_store";
 import { SDK_CHANNEL_NAME, SDK_NODE_NAME } from "@sanity/message-protocol";
 import { fromUrl } from "@sanity/bifur-client";
-import { CorsOriginError } from "@sanity/client";
-import { CORE_SDK_VERSION } from "./_chunks-es/version.js";
 function createSanityInstance(config = {}) {
   const instanceId = crypto.randomUUID(), disposeListeners = /* @__PURE__ */ new Map(), disposed = { current: !1 }, instanceContext = {
     instanceId,
@@ -91,171 +93,237 @@ function createSanityInstance(config = {}) {
   };
   return instance;
 }
-const API_VERSION$7 = "vX";
+const API_VERSION$b = "v2025-07-11", checkPermissions = defineFetcher({
+  name: "checkPermissions",
+  getKey: (_instance, resourceType, resourceId, permissions) => `${resourceType}:${resourceId}:${[...permissions].sort().join(",")}`,
+  fetch: (instance) => (resourceType, resourceId, permissions) => getClientState(instance, { apiVersion: API_VERSION$b, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: `/access/${resourceType}/${resourceId}/user-permissions/me/check`,
+        query: { permissions },
+        tag: "access.check"
+      }).pipe(map((response) => response.data))
+    )
+  ),
+  tags: (_data, resourceType, resourceId) => [
+    { type: "access", id: `${resourceType}:${resourceId}` }
+  ]
+}), API_VERSION$a = "vX";
 function agentGenerate(instance, options, resource) {
-  return getClientState(instance, { apiVersion: API_VERSION$7, resource }).observable.pipe(
+  return getClientState(instance, { apiVersion: API_VERSION$a, resource }).observable.pipe(
     switchMap((client) => client.observable.agent.action.generate(options))
   );
 }
 function agentTransform(instance, options, resource) {
-  return getClientState(instance, { apiVersion: API_VERSION$7, resource }).observable.pipe(
+  return getClientState(instance, { apiVersion: API_VERSION$a, resource }).observable.pipe(
     switchMap((client) => client.observable.agent.action.transform(options))
   );
 }
 function agentTranslate(instance, options, resource) {
-  return getClientState(instance, { apiVersion: API_VERSION$7, resource }).observable.pipe(
+  return getClientState(instance, { apiVersion: API_VERSION$a, resource }).observable.pipe(
     switchMap((client) => client.observable.agent.action.translate(options))
   );
 }
 function agentPrompt(instance, options, resource) {
-  return getClientState(instance, { apiVersion: API_VERSION$7, resource }).observable.pipe(
+  return getClientState(instance, { apiVersion: API_VERSION$a, resource }).observable.pipe(
     switchMap((client) => from(client.agent.action.prompt(options)))
   );
 }
 function agentPatch(instance, options, resource) {
-  return getClientState(instance, { apiVersion: API_VERSION$7, resource }).observable.pipe(
+  return getClientState(instance, { apiVersion: API_VERSION$a, resource }).observable.pipe(
     switchMap((client) => from(client.agent.action.patch(options)))
   );
 }
+function buildQuery(params) {
+  return Object.fromEntries(
+    Object.entries(params).filter(([, value]) => value !== void 0).map(([key, value]) => [key, Array.isArray(value) ? value : String(value)])
+  );
+}
+const API_VERSION$9 = "vX";
+function serializeInclude$1(include) {
+  return include?.length ? [...include].sort().join(",") : void 0;
+}
+const applications = defineFetcher({
+  name: "applications",
+  getKey: (_instance, options) => [
+    options.organizationId,
+    options.type ?? "",
+    serializeInclude$1(options.include) ?? "",
+    options.limit ?? "",
+    options.cursor ?? ""
+  ].join(":"),
+  fetch: (instance) => (options) => getClientState(instance, { apiVersion: API_VERSION$9, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: "/applications",
+        query: buildQuery({
+          organizationId: options.organizationId,
+          type: options.type,
+          include: serializeInclude$1(options.include),
+          limit: options.limit,
+          cursor: options.cursor
+        }),
+        tag: "applications.list"
+      })
+    )
+  ),
+  tags: (data) => [
+    { type: "application", id: "LIST" },
+    ...data.data.map((app) => ({ type: "application", id: app.id }))
+  ]
+}), application = defineFetcher({
+  name: "application",
+  getKey: (_instance, applicationId, options) => `${applicationId}:${serializeInclude$1(options?.include) ?? ""}`,
+  fetch: (instance) => (applicationId, options) => getClientState(instance, { apiVersion: API_VERSION$9, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: `/applications/${applicationId}`,
+        query: buildQuery({ include: serializeInclude$1(options?.include) }),
+        tag: "applications.get"
+      })
+    )
+  ),
+  tags: (data) => [{ type: "application", id: data.id }]
+}), updateApplication = defineMutation({
+  name: "updateApplication",
+  mutationFn: (instance) => ({ applicationId, ...body }) => getClientState(instance, { apiVersion: API_VERSION$9, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: `/applications/${applicationId}`,
+        method: "PATCH",
+        body,
+        tag: "applications.update"
+      })
+    )
+  ),
+  invalidates: (_result, { applicationId }) => [
+    { type: "application", id: "LIST" },
+    { type: "application", id: applicationId }
+  ]
+}), deleteApplication = defineMutation({
+  name: "deleteApplication",
+  mutationFn: (instance) => ({ applicationId }) => getClientState(instance, { apiVersion: API_VERSION$9, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: `/applications/${applicationId}`,
+        method: "DELETE",
+        tag: "applications.delete"
+      })
+    )
+  ),
+  invalidates: (_result, { applicationId }) => [
+    { type: "application", id: "LIST" },
+    { type: "application", id: applicationId }
+  ]
+}), API_VERSION$8 = "v2024-08-01", userApplications = defineFetcher({
+  name: "userApplications",
+  getKey: (_instance, options) => options.organizationId,
+  fetch: (instance) => (options) => getClientState(instance, { apiVersion: API_VERSION$8, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: "/user-applications",
+        query: buildQuery({ organizationId: options.organizationId }),
+        tag: "user-applications.list"
+      })
+    )
+  ),
+  tags: (data) => [
+    { type: "user-application", id: "LIST" },
+    ...data.map((app) => ({ type: "user-application", id: app.id }))
+  ]
+}), userApplication = defineFetcher({
+  name: "userApplication",
+  getKey: (_instance, userApplicationId) => userApplicationId,
+  fetch: (instance) => (userApplicationId) => getClientState(instance, { apiVersion: API_VERSION$8, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: `/user-applications/${userApplicationId}`,
+        tag: "user-applications.get"
+      })
+    )
+  ),
+  tags: (data) => [{ type: "user-application", id: data.id }]
+}), createUserApplication = defineMutation({
+  name: "createUserApplication",
+  mutationFn: (instance) => ({ organizationId, appType, ...body }) => getClientState(instance, { apiVersion: API_VERSION$8, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: "/user-applications",
+        method: "POST",
+        query: buildQuery({ organizationId, appType }),
+        body,
+        tag: "user-applications.create"
+      })
+    )
+  ),
+  invalidates: [{ type: "user-application", id: "LIST" }]
+}), updateUserApplication = defineMutation({
+  name: "updateUserApplication",
+  mutationFn: (instance) => ({ userApplicationId, ...body }) => getClientState(instance, { apiVersion: API_VERSION$8, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: `/user-applications/${userApplicationId}`,
+        method: "PATCH",
+        body,
+        tag: "user-applications.update"
+      })
+    )
+  ),
+  invalidates: (_result, { userApplicationId }) => [
+    { type: "user-application", id: "LIST" },
+    { type: "user-application", id: userApplicationId }
+  ]
+}), deleteUserApplication = defineMutation({
+  name: "deleteUserApplication",
+  mutationFn: (instance) => ({ userApplicationId }) => getClientState(instance, { apiVersion: API_VERSION$8, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: `/user-applications/${userApplicationId}`,
+        method: "DELETE",
+        tag: "user-applications.delete"
+      })
+    )
+  ),
+  invalidates: (_result, { userApplicationId }) => [
+    { type: "user-application", id: "LIST" },
+    { type: "user-application", id: userApplicationId }
+  ]
+});
 function compareProjectOrganization(projectId, projectOrganizationId, currentDashboardOrgId) {
   return projectOrganizationId !== currentDashboardOrgId ? {
     error: `Project ${projectId} belongs to Organization ${projectOrganizationId ?? "unknown"}, but the Dashboard has Organization ${currentDashboardOrgId} selected`
   } : { error: null };
 }
-function createFetcherStore({
-  name,
-  fetcher: getObservable,
-  getKey,
-  fetchThrottleInternal = 1e3,
-  stateExpirationDelay = 5e3
-}) {
-  const store = defineStore({
-    name,
-    getInitialState: () => ({
-      stateByParams: {}
-    }),
-    initialize: (context) => {
-      const subscription = subscribeToSubscriptionsAndFetch(context);
-      return () => subscription.unsubscribe();
-    }
-  }), subscribeToSubscriptionsAndFetch = ({
-    state
-  }) => state.observable.pipe(
-    // Map the state to an array of [serialized, entry] pairs.
-    switchMap$1((s) => {
-      const entries = Object.entries(s.stateByParams);
-      return entries.length > 0 ? from(entries) : EMPTY;
-    }),
-    // Group by the serialized key.
-    groupBy(([key]) => key),
-    mergeMap(
-      (group$) => group$.pipe(
-        // Emit an initial value for pairwise comparisons.
-        startWith([group$.key, void 0]),
-        pairwise(),
-        // Trigger only when the subscriptions array grows.
-        filter(([[, prevEntry], [, currEntry]]) => {
-          const prevSubs = prevEntry?.subscriptions ?? [];
-          return (currEntry?.subscriptions ?? []).length > prevSubs.length;
-        }),
-        map(([, [, currEntry]]) => currEntry),
-        // Only trigger if we haven't fetched recently.
-        filter((entry) => {
-          const lastFetch = entry?.lastFetchInitiatedAt;
-          return lastFetch ? Date.now() - new Date(lastFetch).getTime() >= fetchThrottleInternal : !0;
-        }),
-        switchMap$1((entry) => entry ? (state.set("setLastFetchInitiatedAt", (prev) => ({
-          stateByParams: {
-            ...prev.stateByParams,
-            [entry.key]: {
-              ...entry,
-              ...prev.stateByParams[entry.key],
-              lastFetchInitiatedAt: (/* @__PURE__ */ new Date()).toISOString()
-            }
-          }
-        })), getObservable(entry.instance)(...entry.params).pipe(
-          // the `createStateSourceAction` util requires the update
-          // to
-          delay(0, asapScheduler),
-          tap(
-            (data) => state.set("setData", (prev) => ({
-              stateByParams: {
-                ...prev.stateByParams,
-                [entry.key]: {
-                  ...omitProperty(entry, "error"),
-                  ...prev.stateByParams[entry.key] ? omitProperty(prev.stateByParams[entry.key], "error") : {},
-                  data
-                }
-              }
-            }))
-          ),
-          catchError((error) => (state.set("setError", (prev) => ({
-            stateByParams: {
-              ...prev.stateByParams,
-              [entry.key]: {
-                ...entry,
-                ...prev.stateByParams[entry.key],
-                error
-              }
-            }
-          })), EMPTY))
-        )) : EMPTY)
-      )
-    )
-  ).subscribe({
-    error: (error) => state.set("setError", { error })
-  }), getState = bindActionGlobally(
-    store,
-    createStateSourceAction({
-      selector: ({
-        instance,
-        state: { stateByParams, error }
-      }, ...params) => {
-        if (error) throw error;
-        const key = getKey(instance, ...params), entry = stateByParams[key];
-        if (entry?.error) throw entry.error;
-        return entry?.data;
-      },
-      onSubscribe: ({ instance, state }, ...params) => {
-        const subscriptionId = insecureRandomId(), key = getKey(instance, ...params);
-        return state.set("addSubscription", (prev) => ({
-          stateByParams: {
-            ...prev.stateByParams,
-            [key]: {
-              ...prev.stateByParams[key],
-              instance,
-              key,
-              params: prev.stateByParams[key]?.params || params,
-              subscriptions: [...prev.stateByParams[key]?.subscriptions || [], subscriptionId]
-            }
-          }
-        })), () => {
-          setCleanupTimeout(() => {
-            state.set("removeSubscription", (prev) => {
-              const entry = prev.stateByParams[key];
-              if (!entry) return prev;
-              const newSubs = (entry.subscriptions || []).filter((id) => id !== subscriptionId);
-              return newSubs.length === 0 ? { stateByParams: omitProperty(prev.stateByParams, key) } : {
-                stateByParams: {
-                  ...prev.stateByParams,
-                  [key]: {
-                    ...entry,
-                    subscriptions: newSubs
-                  }
-                }
-              };
-            });
-          }, stateExpirationDelay);
-        };
-      }
-    })
-  ), resolveState = bindActionGlobally(
-    store,
-    ({ instance }, ...params) => firstValueFrom(getState(instance, ...params).observable.pipe(first((i) => i !== void 0)))
-  );
-  return { getState, resolveState };
+const API_VERSION$7 = "v2025-02-19";
+function normalizeProjectsOptions(options) {
+  return {
+    organizationId: options?.organizationId,
+    includeMembers: options?.includeMembers ?? !1,
+    includeFeatures: options?.includeFeatures ?? !0,
+    onlyExplicitMembership: options?.onlyExplicitMembership ?? !1
+  };
 }
-const API_VERSION$6 = "v2025-02-19";
+function getProjectsCacheKey(_instance, options) {
+  const { organizationId, includeMembers, includeFeatures, onlyExplicitMembership } = normalizeProjectsOptions(options);
+  return `projects${organizationId ? `:org:${organizationId}` : ""}${includeMembers ? ":members" : ""}${includeFeatures ? ":features" : ""}${onlyExplicitMembership ? ":explicit" : ""}`;
+}
+const projects = defineFetcher({
+  name: "projects",
+  getKey: getProjectsCacheKey,
+  fetch: (instance) => (options) => getClientState(instance, { apiVersion: API_VERSION$7, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: "/projects",
+        query: buildQuery(normalizeProjectsOptions(options)),
+        tag: "projects.list"
+      })
+    )
+  ),
+  tags: (data) => [
+    { type: "project", id: "LIST" },
+    ...data.map((project2) => ({ type: "project", id: project2.id }))
+  ]
+}), API_VERSION$6 = "v2025-02-19";
 function normalizeProjectOptions(options) {
   return {
     includeMembers: options?.includeMembers ?? !0,
@@ -272,35 +340,34 @@ function getProjectCacheKey(instance, options) {
   const projectId = resolveProjectId(instance, options), { includeMembers, includeFeatures } = normalizeProjectOptions(options);
   return `project:${projectId}${includeMembers ? ":members" : ""}${includeFeatures ? ":features" : ""}`;
 }
-const project = createFetcherStore({
-  name: "Project",
+const project = defineFetcher({
+  name: "project",
   getKey: getProjectCacheKey,
-  fetcher: (instance) => (options) => {
-    const projectId = resolveProjectId(instance, options);
-    return getClientState(instance, {
-      apiVersion: API_VERSION$6,
-      scope: "global"
-    }).observable.pipe(
-      switchMap((client) => {
-        const normalized = normalizeProjectOptions(options), query = Object.fromEntries(
-          Object.entries(normalized).filter(([, value]) => value !== void 0).map(([key, value]) => [key, String(value)])
-        );
-        return client.observable.request({
-          uri: `/projects/${projectId}`,
-          query,
-          tag: "project.get"
-        });
+  fetch: (instance) => (options) => getClientState(instance, { apiVersion: API_VERSION$6, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: `/projects/${resolveProjectId(instance, options)}`,
+        query: buildQuery(normalizeProjectOptions(options)),
+        tag: "projects.get"
       })
-    );
+    )
+  ),
+  tags: (data) => [{ type: "project", id: data.id }],
+  initialData: (instance, options) => {
+    if (normalizeProjectOptions(options).includeMembers) return;
+    const snapshot = projects.getState(instance).getCurrent();
+    if (snapshot.status !== "success") return;
+    const projectId = resolveProjectId(instance, options), match = snapshot.data.find((item) => item.id === projectId);
+    return match && { data: match, dataUpdatedAt: snapshot.dataUpdatedAt };
   }
-}), getProjectState = project.getState, resolveProject = project.resolveState, getDashboardOrganizationId = bindActionGlobally(
+}), getDashboardOrganizationId = bindActionGlobally(
   authStore,
   createStateSourceAction(({ state: { dashboardContext } }) => dashboardContext?.orgId)
 );
 function observeOrganizationVerificationState(instance, projectIds) {
   const dashboardOrgId$ = getDashboardOrganizationId(instance).observable.pipe(distinctUntilChanged()), projectOrgIdObservables = projectIds.map(
-    (id) => getProjectState(instance, { projectId: id }).observable.pipe(
-      map$1((project2) => ({ projectId: id, orgId: project2?.organizationId ?? null })),
+    (id) => project.getState(instance, { projectId: id }).observable.pipe(
+      map((snapshot) => ({ projectId: id, orgId: snapshot.data?.organizationId ?? null })),
       // Ensure we only proceed if the orgId is loaded, distinct prevents unnecessary checks
       distinctUntilChanged((prev, curr) => prev.orgId === curr.orgId)
     )
@@ -578,6 +645,139 @@ function configureLogging(config) {
     source: "programmatic"
   });
 }
+function createFetcherStore({
+  name,
+  fetcher: getObservable,
+  getKey,
+  fetchThrottleInternal = 1e3,
+  stateExpirationDelay = 5e3
+}) {
+  const store = defineStore({
+    name,
+    getInitialState: () => ({
+      stateByParams: {}
+    }),
+    initialize: (context) => {
+      const subscription = subscribeToSubscriptionsAndFetch(context);
+      return () => subscription.unsubscribe();
+    }
+  }), subscribeToSubscriptionsAndFetch = ({
+    state
+  }) => state.observable.pipe(
+    // Map the state to an array of [serialized, entry] pairs.
+    switchMap$1((s) => {
+      const entries = Object.entries(s.stateByParams);
+      return entries.length > 0 ? from(entries) : EMPTY;
+    }),
+    // Group by the serialized key.
+    groupBy(([key]) => key),
+    mergeMap(
+      (group$) => group$.pipe(
+        // Emit an initial value for pairwise comparisons.
+        startWith([group$.key, void 0]),
+        pairwise(),
+        // Trigger only when the subscriptions array grows.
+        filter(([[, prevEntry], [, currEntry]]) => {
+          const prevSubs = prevEntry?.subscriptions ?? [];
+          return (currEntry?.subscriptions ?? []).length > prevSubs.length;
+        }),
+        map$1(([, [, currEntry]]) => currEntry),
+        // Only trigger if we haven't fetched recently.
+        filter((entry) => {
+          const lastFetch = entry?.lastFetchInitiatedAt;
+          return lastFetch ? Date.now() - new Date(lastFetch).getTime() >= fetchThrottleInternal : !0;
+        }),
+        switchMap$1((entry) => entry ? (state.set("setLastFetchInitiatedAt", (prev) => ({
+          stateByParams: {
+            ...prev.stateByParams,
+            [entry.key]: {
+              ...entry,
+              ...prev.stateByParams[entry.key],
+              lastFetchInitiatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          }
+        })), getObservable(entry.instance)(...entry.params).pipe(
+          // the `createStateSourceAction` util requires the update
+          // to
+          delay(0, asapScheduler),
+          tap(
+            (data) => state.set("setData", (prev) => ({
+              stateByParams: {
+                ...prev.stateByParams,
+                [entry.key]: {
+                  ...omitProperty(entry, "error"),
+                  ...prev.stateByParams[entry.key] ? omitProperty(prev.stateByParams[entry.key], "error") : {},
+                  data
+                }
+              }
+            }))
+          ),
+          catchError((error) => (state.set("setError", (prev) => ({
+            stateByParams: {
+              ...prev.stateByParams,
+              [entry.key]: {
+                ...entry,
+                ...prev.stateByParams[entry.key],
+                error
+              }
+            }
+          })), EMPTY))
+        )) : EMPTY)
+      )
+    )
+  ).subscribe({
+    error: (error) => state.set("setError", { error })
+  }), getState = bindActionGlobally(
+    store,
+    createStateSourceAction({
+      selector: ({
+        instance,
+        state: { stateByParams, error }
+      }, ...params) => {
+        if (error) throw error;
+        const key = getKey(instance, ...params), entry = stateByParams[key];
+        if (entry?.error) throw entry.error;
+        return entry?.data;
+      },
+      onSubscribe: ({ instance, state }, ...params) => {
+        const subscriptionId = insecureRandomId(), key = getKey(instance, ...params);
+        return state.set("addSubscription", (prev) => ({
+          stateByParams: {
+            ...prev.stateByParams,
+            [key]: {
+              ...prev.stateByParams[key],
+              instance,
+              key,
+              params: prev.stateByParams[key]?.params || params,
+              subscriptions: [...prev.stateByParams[key]?.subscriptions || [], subscriptionId]
+            }
+          }
+        })), () => {
+          setCleanupTimeout(() => {
+            state.set("removeSubscription", (prev) => {
+              const entry = prev.stateByParams[key];
+              if (!entry) return prev;
+              const newSubs = (entry.subscriptions || []).filter((id) => id !== subscriptionId);
+              return newSubs.length === 0 ? { stateByParams: omitProperty(prev.stateByParams, key) } : {
+                stateByParams: {
+                  ...prev.stateByParams,
+                  [key]: {
+                    ...entry,
+                    subscriptions: newSubs
+                  }
+                }
+              };
+            });
+          }, stateExpirationDelay);
+        };
+      }
+    })
+  ), resolveState = bindActionGlobally(
+    store,
+    ({ instance }, ...params) => firstValueFrom(getState(instance, ...params).observable.pipe(first((i) => i !== void 0)))
+  );
+  return { getState, resolveState };
+}
 const API_VERSION$5 = "v2025-02-19", datasets = createFetcherStore({
   name: "Datasets",
   getKey: (instance, options) => {
@@ -1146,17 +1346,17 @@ const listen = ({ state }, documentId) => {
   const { sharedListener, fetchDocument } = state.get();
   return sharedListener.events.pipe(
     concatMap((e) => e.type === "welcome" || e.type === "reset" ? fetchDocument(documentId).pipe(
-      map$1((document) => ({ type: "sync", document }))
+      map((document) => ({ type: "sync", document }))
     ) : e.type === "mutation" && e.documentId === documentId ? of(e) : EMPTY),
     sortListenerEvents(),
     withLatestFrom(
       state.observable.pipe(
-        map$1((s) => s.documentStates[documentId]),
+        map((s) => s.documentStates[documentId]),
         filter$1(Boolean),
         distinctUntilChanged()
       )
     ),
-    map$1(([next, documentState]) => {
+    map(([next, documentState]) => {
       if (next.type === "sync")
         return {
           type: "sync",
@@ -2578,7 +2778,7 @@ function createFetchDocument(instance, resource) {
       resource
     }).observable.pipe(
       switchMap((client) => createDocumentLoaderFromClient(client)(documentId)),
-      map$1((result) => {
+      map((result) => {
         if (!result.accessible) {
           if (result.reason === "existence") return null;
           throw new Error(`Document with ID \`${documentId}\` is inaccessible due to permissions.`);
@@ -2697,7 +2897,7 @@ const _resolveDocument = bindActionByResource(
 }) => {
   const { events } = state.get();
   return state.observable.pipe(
-    map$1(applyFirstQueuedTransaction),
+    map(applyFirstQueuedTransaction),
     distinctUntilChanged(),
     tap$1((next) => state.set("applyFirstQueuedTransaction", next)),
     catchError$1((error, caught) => {
@@ -2733,10 +2933,10 @@ const _resolveDocument = bindActionByResource(
       ),
       { leading: !1, trailing: !0 }
     ),
-    map$1(transitionAppliedTransactionsToOutgoing),
+    map(transitionAppliedTransactionsToOutgoing),
     distinctUntilChanged((a, b) => a.outgoing?.transactionId === b.outgoing?.transactionId),
     tap$1((next) => state.set("transitionAppliedTransactionsToOutgoing", next)),
-    map$1((s) => s.outgoing),
+    map((s) => s.outgoing),
     distinctUntilChanged(),
     withLatestFrom(
       getClientState(instance, {
@@ -2750,7 +2950,7 @@ const _resolveDocument = bindActionByResource(
         state.set("revertOutgoingTransaction", revertOutgoingTransaction);
         const message = error instanceof Error ? error.message : "Request failed";
         return events.next({ type: "reverted", message, outgoing, error }), EMPTY;
-      }), toResult = map$1((result) => ({
+      }), toResult = map((result) => ({
         result,
         outgoing
       }));
@@ -2777,7 +2977,7 @@ const _resolveDocument = bindActionByResource(
   const { state } = context, { events } = state.get();
   return state.observable.pipe(
     filter$1((s) => !!s.grants),
-    map$1((s) => Object.keys(s.documentStates)),
+    map((s) => Object.keys(s.documentStates)),
     distinctUntilChanged((curr, next) => {
       if (curr.length !== next.length) return !1;
       const currSet = new Set(curr);
@@ -2899,16 +3099,16 @@ async function _applyDocumentActions({ state }, {
     actions: normalizedActions,
     ...disableBatching && { disableBatching }
   }, fatalError$ = state.observable.pipe(
-    map$1((s) => s.error),
+    map((s) => s.error),
     first$1(Boolean),
-    map$1((error) => ({ type: "error", error }))
+    map((error) => ({ type: "error", error }))
   ), transactionError$ = events.pipe(
     filter$1((e) => e.type === "error"),
     first$1((e) => e.transactionId === transactionId)
   ), appliedTransaction$ = state.observable.pipe(
-    map$1((s) => s.applied),
+    map((s) => s.applied),
     distinctUntilChanged(),
-    map$1((applied) => applied.find((t) => t.transactionId === transactionId)),
+    map((applied) => applied.find((t) => t.transactionId === transactionId)),
     first$1(Boolean)
   ), successfulTransaction$ = events.pipe(
     filter$1((e) => e.type === "accepted"),
@@ -2981,52 +3181,87 @@ const favorites = createFetcherStore({
             payload
           )
         ).pipe(
-          map$1((response) => ({ isFavorited: response.isFavorited })),
+          map((response) => ({ isFavorited: response.isFavorited })),
           catchError$1((err) => (console.error("Favorites service connection error", err), of({ isFavorited: !1 })))
         );
       })
     );
   }
-}), getFavoritesState = favorites.getState, resolveFavoritesState = favorites.resolveState, API_VERSION$2 = "v2025-02-19";
+}), getFavoritesState = favorites.getState, resolveFavoritesState = favorites.resolveState, API_VERSION$2 = "vX";
+function serializeInclude(include) {
+  return include?.length ? [...include].sort().join(",") : void 0;
+}
+const installations = defineFetcher({
+  name: "installations",
+  getKey: (_instance, options) => [
+    options.organizationId,
+    serializeInclude(options.include) ?? "",
+    options.limit ?? "",
+    options.cursor ?? ""
+  ].join(":"),
+  fetch: (instance) => (options) => getClientState(instance, { apiVersion: API_VERSION$2, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: "/installations",
+        query: buildQuery({
+          organizationId: options.organizationId,
+          include: serializeInclude(options.include),
+          limit: options.limit,
+          cursor: options.cursor
+        }),
+        tag: "installations.list"
+      })
+    )
+  ),
+  tags: (data) => [
+    { type: "installation", id: "LIST" },
+    ...data.data.map((installation2) => ({ type: "installation", id: installation2.id }))
+  ]
+}), installation = defineFetcher({
+  name: "installation",
+  getKey: (_instance, installationId, options) => `${installationId}:${serializeInclude(options?.include) ?? ""}`,
+  fetch: (instance) => (installationId, options) => getClientState(instance, { apiVersion: API_VERSION$2, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: `/installations/${installationId}`,
+        query: buildQuery({ include: serializeInclude(options?.include) }),
+        tag: "installations.get"
+      })
+    )
+  ),
+  tags: (data) => [{ type: "installation", id: data.id }]
+}), API_VERSION$1 = "v2025-02-19";
 function resolveOrganizationId(options) {
   const organizationId = options?.organizationId;
   if (!organizationId)
     throw new Error("An organizationId is required to use the organization API.");
   return organizationId;
 }
-function normalizeOrganizationOptions$1(options) {
+function normalizeOrganizationOptions(options) {
   return {
     includeMembers: options?.includeMembers ?? !1,
     includeFeatures: options?.includeFeatures ?? !1
   };
 }
 function getOrganizationCacheKey(_instance, options) {
-  const organizationId = resolveOrganizationId(options), { includeMembers, includeFeatures } = normalizeOrganizationOptions$1(options);
+  const organizationId = resolveOrganizationId(options), { includeMembers, includeFeatures } = normalizeOrganizationOptions(options);
   return `organization:${organizationId}${includeMembers ? ":members" : ""}${includeFeatures ? ":features" : ""}`;
 }
-const organization = createFetcherStore({
-  name: "Organization",
+const organization = defineFetcher({
+  name: "organization",
   getKey: getOrganizationCacheKey,
-  fetcher: (instance) => (options) => {
-    const organizationId = resolveOrganizationId(options);
-    return getClientState(instance, {
-      apiVersion: API_VERSION$2,
-      scope: "global"
-    }).observable.pipe(
-      switchMap((client) => {
-        const normalized = normalizeOrganizationOptions$1(options), query = Object.fromEntries(
-          Object.entries(normalized).filter(([, value]) => value !== void 0).map(([key, value]) => [key, String(value)])
-        );
-        return client.observable.request({
-          uri: `/organizations/${organizationId}`,
-          query,
-          tag: "organization.get"
-        });
+  fetch: (instance) => (options) => getClientState(instance, { apiVersion: API_VERSION$1, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
+        uri: `/organizations/${resolveOrganizationId(options)}`,
+        query: buildQuery(normalizeOrganizationOptions(options)),
+        tag: "organizations.get"
       })
-    );
-  }
-}), getOrganizationState = organization.getState, resolveOrganization = organization.resolveState, API_VERSION$1 = "v2025-02-19";
-function normalizeOrganizationOptions(options) {
+    )
+  ),
+  tags: (data) => [{ type: "organization", id: data.id }]
+}), API_VERSION = "v2025-02-19";
+function normalizeOrganizationsOptions(options) {
   return {
     includeImplicitMemberships: options?.includeImplicitMemberships ?? !1,
     includeMembers: options?.includeMembers ?? !1,
@@ -3034,28 +3269,26 @@ function normalizeOrganizationOptions(options) {
   };
 }
 function getOrganizationsCacheKey(_instance, options) {
-  const { includeMembers, includeFeatures, includeImplicitMemberships } = normalizeOrganizationOptions(options);
+  const { includeMembers, includeFeatures, includeImplicitMemberships } = normalizeOrganizationsOptions(options);
   return `organizations${includeMembers ? ":members" : ""}${includeFeatures ? ":features" : ""}${includeImplicitMemberships ? ":implicit" : ""}`;
 }
-const organizations = createFetcherStore({
-  name: "Organizations",
+const organizations = defineFetcher({
+  name: "organizations",
   getKey: getOrganizationsCacheKey,
-  fetcher: (instance) => (options) => getClientState(instance, {
-    apiVersion: API_VERSION$1,
-    scope: "global"
-  }).observable.pipe(
-    switchMap((client) => {
-      const normalized = normalizeOrganizationOptions(options), query = Object.fromEntries(
-        Object.entries(normalized).filter(([, value]) => value !== void 0).map(([key, value]) => [key, String(value)])
-      );
-      return client.observable.request({
+  fetch: (instance) => (options) => getClientState(instance, { apiVersion: API_VERSION, scope: "global" }).observable.pipe(
+    switchMap(
+      (client) => client.observable.request({
         uri: "/organizations",
-        query,
-        tag: "organizations.get"
-      });
-    })
-  )
-}), getOrganizationsState = organizations.getState, resolveOrganizations = organizations.resolveState, usersStore = defineStore({
+        query: buildQuery(normalizeOrganizationsOptions(options)),
+        tag: "organizations.list"
+      })
+    )
+  ),
+  tags: (data) => [
+    { type: "organization", id: "LIST" },
+    ...data.map((org) => ({ type: "organization", id: org.id }))
+  ]
+}), usersStore = defineStore({
   name: "UsersStore",
   getInitialState: () => ({ users: {} }),
   initialize: (context) => {
@@ -3063,7 +3296,7 @@ const organizations = createFetcherStore({
     return () => subscription.unsubscribe();
   }
 }), errorHandler = (state) => (error) => state.set("setError", { error }), listenForLoadMoreAndFetch = ({ state, instance }) => state.observable.pipe(
-  map$1((s) => new Set(Object.keys(s.users))),
+  map((s) => new Set(Object.keys(s.users))),
   distinctUntilChanged((curr, next) => curr.size !== next.size ? !1 : Array.from(next).every((i) => curr.has(i))),
   startWith$1(/* @__PURE__ */ new Set()),
   pairwise$1(),
@@ -3093,7 +3326,7 @@ const organizations = createFetcherStore({
               uri: `/users/${userId}`,
               tag: "users.get"
             }).pipe(
-              map$1((user) => ({
+              map((user) => ({
                 data: [{
                   sanityUserId: user.sanityUserId,
                   profile: {
@@ -3121,14 +3354,14 @@ const organizations = createFetcherStore({
             );
           const scope = userId.startsWith("g") ? "global" : void 0, client = getClient(instance, {
             scope,
-            apiVersion: API_VERSION$8
+            apiVersion: API_VERSION$c
           }), resourceType2 = options.resourceType || "project", resourceId = resourceType2 === "organization" ? options.organizationId : options.projectId;
           return resourceId ? client.observable.request({
             method: "GET",
             uri: `access/${resourceType2}/${resourceId}/users/${userId}`,
             tag: "users.get"
           }).pipe(
-            map$1((response) => "sanityUserId" in response ? {
+            map((response) => "sanityUserId" in response ? {
               data: [response],
               totalCount: 1,
               nextCursor: null
@@ -3139,14 +3372,14 @@ const organizations = createFetcherStore({
         }
         const projectId = options.projectId, resourceType = options.resourceType ?? (options.organizationId ? "organization" : projectId ? "project" : "organization"), organizationId$ = options.organizationId ? of(options.organizationId) : getDashboardOrganizationId$1(instance).observable.pipe(
           filter$1((i) => typeof i == "string")
-        ), resource$ = resourceType === "project" ? projectId ? of({ type: "project", id: projectId }) : throwError(() => new Error("Project ID required for this API.")) : organizationId$.pipe(map$1((id) => ({ type: "organization", id }))), client$ = getClientState(instance, {
+        ), resource$ = resourceType === "project" ? projectId ? of({ type: "project", id: projectId }) : throwError(() => new Error("Project ID required for this API.")) : organizationId$.pipe(map((id) => ({ type: "organization", id }))), client$ = getClientState(instance, {
           scope: "global",
-          apiVersion: API_VERSION$8
+          apiVersion: API_VERSION$c
         }).observable, loadMore$ = state.observable.pipe(
-          map$1((s) => s.users[group$.key]?.lastLoadMoreRequest),
+          map((s) => s.users[group$.key]?.lastLoadMoreRequest),
           distinctUntilChanged()
         ), cursor$ = state.observable.pipe(
-          map$1((s) => s.users[group$.key]?.nextCursor),
+          map((s) => s.users[group$.key]?.nextCursor),
           distinctUntilChanged(),
           filter$1((cursor) => cursor !== null)
         );
@@ -3209,7 +3442,7 @@ const organizations = createFetcherStore({
     ) : NEVER;
     state.set("initializeRequest", initializeRequest(key));
     const resolved$ = state.observable.pipe(
-      map$1(getCurrent),
+      map(getCurrent),
       first$1((i) => i !== void 0)
     );
     return firstValueFrom(race([resolved$, aborted$]));
@@ -3233,7 +3466,7 @@ const organizations = createFetcherStore({
 ), getUserState = bindActionGlobally(
   usersStore,
   ({ instance }, { userId, ...options }) => getUsersState(instance, { userId, ...options }).observable.pipe(
-    map$1((res) => res?.data[0]),
+    map((res) => res?.data[0]),
     distinctUntilChanged((a, b) => a?.profile.updatedAt === b?.profile.updatedAt)
   )
 ), resolveUser = bindActionGlobally(
@@ -3289,7 +3522,7 @@ const handleIncomingMessage = (event) => {
       throw new Error(`Got unknown presence event: ${JSON.stringify(event)}`);
   }
 }, createBifurTransport = (options) => {
-  const { client, token$, sessionId } = options, bifur = getBifurClient(client, token$), incomingEvents$ = bifur.listen("presence").pipe(map(handleIncomingMessage)), dispatchMessage = (message) => {
+  const { client, token$, sessionId } = options, bifur = getBifurClient(client, token$), incomingEvents$ = bifur.listen("presence").pipe(map$1(handleIncomingMessage)), dispatchMessage = (message) => {
     switch (message.type) {
       case "rollCall":
         return bifur.request("presence_rollcall", { session: sessionId });
@@ -3381,12 +3614,12 @@ const handleIncomingMessage = (event) => {
     selector: (context) => selectPresence(context.state),
     onSubscribe: (context) => {
       const resource = context.key.resource, userIds$ = context.state.observable.pipe(
-        map$1(
+        map(
           (state) => Array.from(state.locations.values()).map((l) => l.userId).filter((id) => !!id)
         ),
         distinctUntilChanged((a, b) => a.length === b.length && a.every((v, i) => v === b[i]))
       ), organizationId$ = isCanvasResource(resource) ? context.state.observable.pipe(
-        map$1((s) => s.organizationId),
+        map((s) => s.organizationId),
         filter$1((id) => id !== void 0),
         first$1()
       ) : of(void 0), subscription = combineLatest([userIds$, organizationId$]).pipe(
@@ -3505,10 +3738,10 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
   key: { resource, perspective }
 }) => {
   const documentProjections$ = state.observable.pipe(
-    map$1((s) => s.documentProjections),
+    map((s) => s.documentProjections),
     distinctUntilChanged(isDeepEqual)
   ), activeDocumentIds$ = state.observable.pipe(
-    map$1(({ subscriptions }) => new Set(Object.keys(subscriptions).map((id) => DocumentId(id)))),
+    map(({ subscriptions }) => new Set(Object.keys(subscriptions).map((id) => DocumentId(id)))),
     distinctUntilChanged(isSetEqual)
   ), pendingUpdateSubscription = activeDocumentIds$.pipe(
     debounceTime(BATCH_DEBOUNCE_TIME),
@@ -3585,14 +3818,14 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a, b) => a.size === b.size && Arra
         filter$1(
           (pair) => pair[0] !== void 0 && pair[1] !== void 0
         ),
-        map$1(([projection, status]) => ({
+        map(([projection, status]) => ({
           data: projection,
           ids,
           statusResults: status
         }))
       );
     }),
-    map$1(({ ids, data, statusResults }) => {
+    map(({ ids, data, statusResults }) => {
       const documentStatuses = processStatusQueryResults(statusResults);
       state.set("updateStatuses", (prev) => ({
         documentStatuses: {
@@ -3712,7 +3945,7 @@ function getPreviewState(instance, options) {
   return {
     getCurrent: () => transformResult(projectionState.getCurrent()),
     subscribe: (callback) => projectionState.subscribe(callback),
-    observable: projectionState.observable.pipe(map$1(transformResult))
+    observable: projectionState.observable.pipe(map(transformResult))
   };
 }
 function resolveProjection(...args) {
@@ -3740,91 +3973,6 @@ async function resolvePreview(instance, options) {
     isPending: projectionResult.isPending
   } : { data: null, isPending: projectionResult.isPending };
 }
-const API_VERSION = "v2025-02-19";
-function normalizeProjectsOptions(options) {
-  return {
-    organizationId: options?.organizationId,
-    includeMembers: options?.includeMembers ?? !1,
-    includeFeatures: options?.includeFeatures ?? !0,
-    onlyExplicitMembership: options?.onlyExplicitMembership ?? !1
-  };
-}
-function getProjectsCacheKey(_instance, options) {
-  const { organizationId, includeMembers, includeFeatures, onlyExplicitMembership } = normalizeProjectsOptions(options);
-  return `projects${organizationId ? `:org:${organizationId}` : ""}${includeMembers ? ":members" : ""}${includeFeatures ? ":features" : ""}${onlyExplicitMembership ? ":explicit" : ""}`;
-}
-const projects = createFetcherStore({
-  name: "Projects",
-  getKey: getProjectsCacheKey,
-  fetcher: (instance) => (options) => getClientState(instance, {
-    apiVersion: API_VERSION,
-    scope: "global"
-  }).observable.pipe(
-    switchMap((client) => {
-      const normalized = normalizeProjectsOptions(options), query = Object.fromEntries(
-        Object.entries(normalized).filter(([, value]) => value !== void 0).map(([key, value]) => [key, String(value)])
-      );
-      return client.observable.request({
-        uri: "/projects",
-        query,
-        tag: "projects.get"
-      });
-    })
-  )
-}), getProjectsState = projects.getState, resolveProjects = projects.resolveState;
-function defineIntent(intent) {
-  if (!intent.id)
-    throw new Error("Intent must have an id");
-  if (!intent.action)
-    throw new Error("Intent must have an action");
-  if (!intent.title)
-    throw new Error("Intent must have a title");
-  if (!Array.isArray(intent.filters))
-    throw new Error("Intent must have a filters array");
-  if (intent.filters.length === 0)
-    throw new Error(
-      "Intent must have at least one filter. If you want to match everything, use {types: ['*']}"
-    );
-  return intent.filters.forEach((filter2, index) => {
-    validateFilter(filter2, index);
-  }), intent;
-}
-function validateFilter(filter2, index) {
-  const filterContext = `Filter at index ${index}`;
-  if (!filter2 || typeof filter2 != "object")
-    throw new Error(`${filterContext} must be an object`);
-  if (filter2.types === void 0)
-    throw new Error(
-      `${filterContext} must have a types property. Use ['*'] to match all document types.`
-    );
-  if (filter2.projectId !== void 0) {
-    if (typeof filter2.projectId != "string")
-      throw new Error(`${filterContext}: projectId must be a string`);
-    if (filter2.projectId.trim() === "")
-      throw new Error(`${filterContext}: projectId cannot be empty`);
-  }
-  if (filter2.dataset !== void 0) {
-    if (typeof filter2.dataset != "string")
-      throw new Error(`${filterContext}: dataset must be a string`);
-    if (filter2.dataset.trim() === "")
-      throw new Error(`${filterContext}: dataset cannot be empty`);
-    if (filter2.projectId === void 0)
-      throw new Error(`${filterContext}: dataset cannot be specified without projectId`);
-  }
-  if (!Array.isArray(filter2.types))
-    throw new Error(`${filterContext}: types must be an array`);
-  if (filter2.types.length === 0)
-    throw new Error(`${filterContext}: types array cannot be empty`);
-  if (filter2.types.forEach((type, typeIndex) => {
-    if (typeof type != "string")
-      throw new Error(`${filterContext}: types[${typeIndex}] must be a string`);
-    if (type.trim() === "")
-      throw new Error(`${filterContext}: types[${typeIndex}] cannot be empty`);
-  }), filter2.types.includes("*") && filter2.types.length > 1)
-    throw new Error(
-      `${filterContext}: when using wildcard '*', it must be the only type in the array`
-    );
-}
 function getCorsErrorProjectId(error) {
   if (!(error instanceof CorsOriginError)) return null;
   const projMatch = (error.message || "").match(/manage\/project\/([^/?#]+)/);
@@ -3845,8 +3993,11 @@ export {
   agentPrompt,
   agentTransform,
   agentTranslate,
+  application,
+  applications,
   applyDocumentActions,
   archiveRelease,
+  checkPermissions,
   configureLogging,
   createDatasetHandle,
   createDocument,
@@ -3856,9 +4007,11 @@ export {
   createProjectHandle,
   createRelease,
   createSanityInstance,
-  defineIntent,
+  createUserApplication,
+  deleteApplication,
   deleteDocument,
   deleteRelease,
+  deleteUserApplication,
   destroyController,
   discardDocument,
   editDocument,
@@ -3885,16 +4038,12 @@ export {
   getOrCreateChannel,
   getOrCreateController,
   getOrCreateNode,
-  getOrganizationState,
-  getOrganizationsState,
   getPathDepth,
   getPermissionsState,
   getPerspectiveState,
   getPresence,
   getPreviewState,
-  getProjectState,
   getProjectionState,
-  getProjectsState,
   getQueryKey,
   getQueryState,
   getReleaseDocumentId,
@@ -3903,6 +4052,8 @@ export {
   getUsersKey,
   getUsersState,
   handleAuthCallback,
+  installation,
+  installations,
   isCanvasResource,
   isCanvasSource,
   isDatasetResource,
@@ -3917,8 +4068,12 @@ export {
   loadMoreUsers,
   logout,
   observeOrganizationVerificationState,
+  organization,
+  organizations,
   parseQueryKey,
   parseUsersKey,
+  project,
+  projects,
   publishDocument,
   publishRelease,
   releaseChannel,
@@ -3926,13 +4081,9 @@ export {
   resolveDatasets,
   resolveDocument,
   resolveFavoritesState,
-  resolveOrganization,
-  resolveOrganizations,
   resolvePermissions,
   resolvePreview,
-  resolveProject,
   resolveProjection,
-  resolveProjects,
   resolveQuery,
   resolveUser,
   resolveUsers,
@@ -3944,6 +4095,10 @@ export {
   transformProjectionToPreview,
   unarchiveRelease,
   unpublishDocument,
-  unscheduleRelease
+  unscheduleRelease,
+  updateApplication,
+  updateUserApplication,
+  userApplication,
+  userApplications
 };
 //# sourceMappingURL=index.js.map