@sanity/sdk 2.11.1 → 2.12.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { switchMap, from, firstValueFrom, EMPTY, asapScheduler, distinctUntilChanged, map as map$1, combineLatest, of, concatMap, withLatestFrom, filter as filter$1, concat, timer, throwError, 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, throttle, race, skip, Observable, NEVER, fromEvent, Subscription, debounceTime, defer } from "rxjs";
 import { createLogger, pickProperties, insecureRandomId, getClientState, bindActionGlobally, createStateSourceAction, setCleanupTimeout, omitProperty, defineStore, authStore, AuthStateType, getCleanedUrl, getTokenFromLocation, createLoggedInAuthState, getAuthCode, REQUEST_TAG_PREFIX, DEFAULT_API_VERSION, getDefaultLocation, isDeepEqual, configureLogging as configureLogging$1, isReleasePerspective, bindActionByResource, isDatasetResource, isMediaLibraryResource, isCanvasResource, getUsersKey, addSubscription, parseUsersKey, getClient, PROJECT_API_VERSION, setUsersError, setUsersData, API_VERSION as API_VERSION$8, getDashboardOrganizationId as getDashboardOrganizationId$1, USERS_STATE_CLEAR_DELAY, removeSubscription, updateLastLoadMoreRequest, cancelRequest, initializeRequest, getTokenState, getQueryState, resolveQuery, bindActionByResourceAndPerspective, PREVIEW_PROJECTION, transformProjectionToPreview } from "./_chunks-es/createGroqSearchFilter.js";
-import { createGroqSearchFilter, getActiveReleasesState, getAuthState, getClientErrorApiBody, getClientErrorApiDescription, getClientErrorApiType, getCurrentUserState, getIsInDashboardState, getLoginUrlState, getPerspectiveState, getQueryKey, isCanvasSource, isDatasetSource, isMediaLibrarySource, isProjectUserNotFoundClientError, isStudioConfig, parseQueryKey, setAuthToken } from "./_chunks-es/createGroqSearchFilter.js";
+import { createGroqSearchFilter, getActiveReleasesState, getAllReleasesState, getAuthState, getClientErrorApiBody, getClientErrorApiDescription, getClientErrorApiType, getCurrentUserState, 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 { createController, createNode } from "@sanity/comlink";
 import { createSelector } from "reselect";
@@ -642,7 +642,47 @@ function discardDocument(doc) {
     documentId: effectiveDocumentId
   };
 }
-const DOCUMENT_STATE_CLEAR_DELAY = 1e3, INITIAL_OUTGOING_THROTTLE_TIME = 1e3, API_VERSION$4 = "v2025-05-06";
+function createRelease(handle, metadata = { releaseType: "undecided" }) {
+  return { type: "release.create", ...handle, metadata };
+}
+function editRelease(handle, patch) {
+  return { type: "release.edit", ...handle, patch };
+}
+function publishRelease(handle) {
+  return { type: "release.publish", ...handle };
+}
+function scheduleRelease(handle, publishAt) {
+  return { type: "release.schedule", ...handle, publishAt };
+}
+function unscheduleRelease(handle) {
+  return { type: "release.unschedule", ...handle };
+}
+function archiveRelease(handle) {
+  return { type: "release.archive", ...handle };
+}
+function unarchiveRelease(handle) {
+  return { type: "release.unarchive", ...handle };
+}
+function deleteRelease(handle) {
+  return { type: "release.delete", ...handle };
+}
+const DOCUMENT_STATE_CLEAR_DELAY = 1e3, INITIAL_OUTGOING_THROTTLE_TIME = 1e3, API_VERSION$4 = "v2025-05-06", RELEASE_DOCUMENTS_PATH = "_.releases";
+function getReleaseDocumentId(releaseId) {
+  return `${RELEASE_DOCUMENTS_PATH}.${releaseId}`;
+}
+const RELEASE_ACTION_TYPES = /* @__PURE__ */ new Set([
+  "release.create",
+  "release.edit",
+  "release.publish",
+  "release.schedule",
+  "release.unschedule",
+  "release.archive",
+  "release.unarchive",
+  "release.delete"
+]);
+function isReleaseAction(action) {
+  return RELEASE_ACTION_TYPES.has(action.type);
+}
 function generateArrayKey(length = 12) {
   const numBytes = Math.ceil(length / 2), bytes = crypto.getRandomValues(new Uint8Array(numBytes));
   return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, length);
@@ -1290,6 +1330,38 @@ class ActionError extends Error {
 }
 class PermissionActionError extends ActionError {
 }
+function applySingleDocPatch({
+  base: initialBase,
+  working: initialWorking,
+  documentId,
+  patches,
+  transactionId,
+  timestamp,
+  grants,
+  notFoundMessage = "Cannot edit document because it does not exist.",
+  permissionMessage = `You do not have permission to edit document "${documentId}".`
+}) {
+  let base = initialBase, working = initialWorking;
+  const userPatches = patches?.map((patch) => ({ patch: { id: documentId, ...patch } }));
+  if (!userPatches?.length)
+    return { base, working, diffedPatches: [], workingMutations: [] };
+  if (!working[documentId] || !base[documentId])
+    throw new ActionError({ documentId, transactionId, message: notFoundMessage });
+  const baseBefore = base[documentId];
+  base = processMutations({ documents: base, transactionId, mutations: userPatches, timestamp });
+  const baseAfter = base[documentId], diffedPatches = diffValue(baseBefore, baseAfter), workingBefore = working[documentId];
+  if (!checkGrant(grants.update, workingBefore))
+    throw new PermissionActionError({ documentId, transactionId, message: permissionMessage });
+  const workingMutations = diffedPatches.map((patch) => ({
+    patch: { id: documentId, ...patch }
+  }));
+  return working = processMutations({
+    documents: working,
+    transactionId,
+    mutations: workingMutations,
+    timestamp
+  }), { base, working, diffedPatches, workingMutations };
+}
 function handleCreate(action, ctx) {
   const { transactionId, timestamp, grants, outgoingActions, outgoingMutations } = ctx;
   let { base, working } = ctx;
@@ -1452,35 +1524,16 @@ function handleEdit(action, ctx) {
   let { base, working } = ctx;
   const documentId = getId(action.documentId);
   if (action.liveEdit) {
-    const userPatches2 = action.patches?.map((patch) => ({ patch: { id: documentId, ...patch } }));
-    if (!userPatches2?.length) return { base, working };
-    if (!working[documentId] || !base[documentId])
-      throw new ActionError({
-        documentId,
-        transactionId,
-        message: "Cannot edit document because it does not exist."
-      });
-    const baseBefore2 = base[documentId];
-    userPatches2 && (base = processMutations({
-      documents: base,
-      transactionId,
-      mutations: userPatches2,
-      timestamp
-    }));
-    const baseAfter2 = base[documentId], patches2 = diffValue(baseBefore2, baseAfter2), workingBefore2 = working[documentId];
-    if (!checkGrant(grants.update, workingBefore2))
-      throw new PermissionActionError({
-        documentId,
-        transactionId,
-        message: `You do not have permission to edit document "${documentId}".`
-      });
-    const workingMutations2 = patches2.map((patch) => ({ patch: { id: documentId, ...patch } }));
-    return working = processMutations({
-      documents: working,
+    const result = applySingleDocPatch({
+      base,
+      working,
+      documentId,
+      patches: action.patches,
       transactionId,
-      mutations: workingMutations2,
-      timestamp
-    }), outgoingMutations.push(...workingMutations2), { base, working };
+      timestamp,
+      grants
+    });
+    return outgoingMutations.push(...result.workingMutations), { base: result.base, working: result.working };
   }
   const versionId = isReleasePerspective(action.perspective) ? getVersionId(DocumentId(documentId), action.perspective.releaseName) : void 0, draftId = getDraftId(DocumentId(documentId)), publishedId = getPublishedId(DocumentId(documentId)), patchDocumentId = isReleasePerspective(action.perspective) ? versionId : draftId, userPatches = action.patches?.map((patch) => ({
     patch: { id: patchDocumentId, ...patch }
@@ -1603,6 +1656,188 @@ function strengthenOnPublish(draft) {
   }
   return strengthen(draft);
 }
+function handleReleaseArchive(action, ctx) {
+  const { base, working, grants, outgoingActions, transactionId } = ctx, releaseDocumentId = getReleaseDocumentId(action.releaseId), existing = working[releaseDocumentId] ?? base[releaseDocumentId];
+  if (!existing)
+    throw new ActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `Cannot archive release "${action.releaseId}" because it does not exist.`
+    });
+  if (!checkGrant(grants.update, existing))
+    throw new PermissionActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `You do not have permission to archive release "${action.releaseId}".`
+    });
+  return outgoingActions.push({
+    actionType: "sanity.action.release.archive",
+    releaseId: action.releaseId
+  }), { base, working };
+}
+function handleReleaseUnarchive(action, ctx) {
+  const { base, working, grants, outgoingActions, transactionId } = ctx, releaseDocumentId = getReleaseDocumentId(action.releaseId), existing = working[releaseDocumentId] ?? base[releaseDocumentId];
+  if (!existing)
+    throw new ActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `Cannot unarchive release "${action.releaseId}" because it does not exist.`
+    });
+  if (!checkGrant(grants.update, existing))
+    throw new PermissionActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `You do not have permission to unarchive release "${action.releaseId}".`
+    });
+  return outgoingActions.push({
+    actionType: "sanity.action.release.unarchive",
+    releaseId: action.releaseId
+  }), { base, working };
+}
+function handleReleaseCreate(action, ctx) {
+  const { transactionId, timestamp, grants, outgoingActions, outgoingMutations } = ctx;
+  let { base, working } = ctx;
+  const releaseDocumentId = getReleaseDocumentId(action.releaseId);
+  if (working[releaseDocumentId] || base[releaseDocumentId])
+    throw new ActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `A release with id "${action.releaseId}" already exists.`
+    });
+  const mutations = [{ create: {
+    _id: releaseDocumentId,
+    _type: "system.release",
+    name: action.releaseId,
+    state: "active",
+    metadata: action.metadata
+  } }];
+  if (base = processMutations({ documents: base, transactionId, mutations, timestamp }), working = processMutations({ documents: working, transactionId, mutations, timestamp }), !checkGrant(grants.create, working[releaseDocumentId]))
+    throw new PermissionActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `You do not have permission to create release "${action.releaseId}".`
+    });
+  return outgoingMutations.push(...mutations), outgoingActions.push({
+    actionType: "sanity.action.release.create",
+    releaseId: action.releaseId,
+    metadata: action.metadata
+  }), { base, working };
+}
+const DELETABLE_STATES = /* @__PURE__ */ new Set(["archived", "published"]);
+function handleReleaseDelete(action, ctx) {
+  const { transactionId, timestamp, grants, outgoingActions, outgoingMutations } = ctx;
+  let { base, working } = ctx;
+  const releaseDocumentId = getReleaseDocumentId(action.releaseId), existing = working[releaseDocumentId] ?? base[releaseDocumentId];
+  if (!existing)
+    throw new ActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `Cannot delete release "${action.releaseId}" because it does not exist.`
+    });
+  const state = existing.state;
+  if (state && typeof state == "string" && !DELETABLE_STATES.has(state))
+    throw new ActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `Cannot delete release "${action.releaseId}" while it is "${state}". Archive it first.`
+    });
+  if (!checkGrant(grants.update, existing))
+    throw new PermissionActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `You do not have permission to delete release "${action.releaseId}".`
+    });
+  const mutations = [{ delete: { id: releaseDocumentId } }];
+  return base = processMutations({ documents: base, transactionId, mutations, timestamp }), working = processMutations({ documents: working, transactionId, mutations, timestamp }), outgoingMutations.push(...mutations), outgoingActions.push({
+    actionType: "sanity.action.release.delete",
+    releaseId: action.releaseId
+  }), { base, working };
+}
+function handleReleaseEdit(action, ctx) {
+  const { transactionId, timestamp, grants, outgoingActions, outgoingMutations } = ctx, { base, working } = ctx, releaseDocumentId = getReleaseDocumentId(action.releaseId), result = applySingleDocPatch({
+    base,
+    working,
+    documentId: releaseDocumentId,
+    patches: [action.patch],
+    transactionId,
+    timestamp,
+    grants,
+    notFoundMessage: `Cannot edit release "${action.releaseId}" because it does not exist.`,
+    permissionMessage: `You do not have permission to edit release "${action.releaseId}".`
+  });
+  return outgoingMutations.push(...result.workingMutations), outgoingActions.push(
+    ...result.diffedPatches.map((patch) => ({
+      actionType: "sanity.action.release.edit",
+      releaseId: action.releaseId,
+      patch
+    }))
+  ), { base: result.base, working: result.working };
+}
+function handleReleasePublish(action, ctx) {
+  const { base, working, grants, outgoingActions, transactionId } = ctx, releaseDocumentId = getReleaseDocumentId(action.releaseId), existing = working[releaseDocumentId] ?? base[releaseDocumentId];
+  if (!existing)
+    throw new ActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `Cannot publish release "${action.releaseId}" because it does not exist.`
+    });
+  if (!checkGrant(grants.update, existing))
+    throw new PermissionActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `You do not have permission to publish release "${action.releaseId}".`
+    });
+  return outgoingActions.push({
+    actionType: "sanity.action.release.publish",
+    releaseId: action.releaseId
+  }), { base, working };
+}
+function handleReleaseSchedule(action, ctx) {
+  const { base, working, grants, outgoingActions, transactionId } = ctx, releaseDocumentId = getReleaseDocumentId(action.releaseId);
+  if (Number.isNaN(Date.parse(action.publishAt)))
+    throw new ActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `Cannot schedule release "${action.releaseId}": "publishAt" must be a valid ISO 8601 timestamp (received "${action.publishAt}").`
+    });
+  const existing = working[releaseDocumentId] ?? base[releaseDocumentId];
+  if (!existing)
+    throw new ActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `Cannot schedule release "${action.releaseId}" because it does not exist.`
+    });
+  if (!checkGrant(grants.update, existing))
+    throw new PermissionActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `You do not have permission to schedule release "${action.releaseId}".`
+    });
+  return outgoingActions.push({
+    actionType: "sanity.action.release.schedule",
+    releaseId: action.releaseId,
+    publishAt: action.publishAt
+  }), { base, working };
+}
+function handleReleaseUnschedule(action, ctx) {
+  const { base, working, grants, outgoingActions, transactionId } = ctx, releaseDocumentId = getReleaseDocumentId(action.releaseId), existing = working[releaseDocumentId] ?? base[releaseDocumentId];
+  if (!existing)
+    throw new ActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `Cannot unschedule release "${action.releaseId}" because it does not exist.`
+    });
+  if (!checkGrant(grants.update, existing))
+    throw new PermissionActionError({
+      documentId: releaseDocumentId,
+      transactionId,
+      message: `You do not have permission to unschedule release "${action.releaseId}".`
+    });
+  return outgoingActions.push({
+    actionType: "sanity.action.release.unschedule",
+    releaseId: action.releaseId
+  }), { base, working };
+}
 function handleUnpublish(action, ctx) {
   const { transactionId, timestamp, grants, outgoingActions, outgoingMutations } = ctx;
   let { base, working } = ctx;
@@ -1659,7 +1894,13 @@ function processActions({
   grants
 }) {
   let base = { ...initialBase }, working = { ...initialWorking };
-  const outgoingActions = [], outgoingMutations = [];
+  const outgoingActions = [], outgoingMutations = [], liveEditAction = actions.find((action) => !isReleaseAction(action) && action.liveEdit), otherAction = actions.find((action) => isReleaseAction(action) || !action.liveEdit);
+  if (liveEditAction && otherAction)
+    throw new ActionError({
+      documentId: liveEditAction.documentId,
+      transactionId,
+      message: "Cannot combine liveEdit document actions with other actions in the same transaction. Submit them as separate transactions."
+    });
   for (const action of actions) {
     const result = dispatch(action, {
       base,
@@ -1697,6 +1938,22 @@ function dispatch(action, ctx) {
       return handlePublish(action, ctx);
     case "document.unpublish":
       return handleUnpublish(action, ctx);
+    case "release.create":
+      return handleReleaseCreate(action, ctx);
+    case "release.edit":
+      return handleReleaseEdit(action, ctx);
+    case "release.publish":
+      return handleReleasePublish(action, ctx);
+    case "release.schedule":
+      return handleReleaseSchedule(action, ctx);
+    case "release.unschedule":
+      return handleReleaseUnschedule(action, ctx);
+    case "release.archive":
+      return handleReleaseArchive(action, ctx);
+    case "release.unarchive":
+      return handleReleaseUnarchive(action, ctx);
+    case "release.delete":
+      return handleReleaseDelete(action, ctx);
     default:
       throw new Error(
         `Unknown action type: "${// @ts-expect-error invalid input
@@ -1779,29 +2036,31 @@ function batchAppliedTransactions([curr, ...rest]) {
   };
   if (!rest.length) return editAction;
   const next = batchAppliedTransactions(rest);
-  if (next)
-    return next.disableBatching || !!action.liveEdit != !!next.actions[0]?.liveEdit ? editAction : {
-      disableBatching: !1,
-      // Use the transactionId from the later (next) transaction.
-      transactionId: next.transactionId,
-      // Accumulate actions: current action first, then later ones.
-      actions: [action, ...next.actions],
-      // Merge outgoingActions in order.
-      outgoingActions: [...curr.outgoingActions, ...next.outgoingActions],
-      // Batched transaction IDs: preserve order by placing curr first.
-      batchedTransactionIds: [curr.transactionId, ...next.batchedTransactionIds],
-      // Merge outgoingMutations in order.
-      outgoingMutations: [...curr.outgoingMutations, ...next.outgoingMutations],
-      // Working state reflects the latest optimistic changes: later transactions override earlier.
-      working: { ...curr.working, ...next.working },
-      // Base state (base, previous, previousRevs) must reflect the original state.
-      // Use curr values (the earliest transaction) to override later ones.
-      previousRevs: { ...next.previousRevs, ...curr.previousRevs },
-      previous: { ...next.previous, ...curr.previous },
-      base: { ...next.base, ...curr.base },
-      // Use the earliest timestamp from curr.
-      timestamp: curr.timestamp ?? next.timestamp
-    };
+  if (!next) return;
+  if (next.disableBatching) return editAction;
+  const nextFirst = next.actions[0], nextLiveEdit = nextFirst && "liveEdit" in nextFirst ? nextFirst.liveEdit : !1;
+  return !!action.liveEdit != !!nextLiveEdit ? editAction : {
+    disableBatching: !1,
+    // Use the transactionId from the later (next) transaction.
+    transactionId: next.transactionId,
+    // Accumulate actions: current action first, then later ones.
+    actions: [action, ...next.actions],
+    // Merge outgoingActions in order.
+    outgoingActions: [...curr.outgoingActions, ...next.outgoingActions],
+    // Batched transaction IDs: preserve order by placing curr first.
+    batchedTransactionIds: [curr.transactionId, ...next.batchedTransactionIds],
+    // Merge outgoingMutations in order.
+    outgoingMutations: [...curr.outgoingMutations, ...next.outgoingMutations],
+    // Working state reflects the latest optimistic changes: later transactions override earlier.
+    working: { ...curr.working, ...next.working },
+    // Base state (base, previous, previousRevs) must reflect the original state.
+    // Use curr values (the earliest transaction) to override later ones.
+    previousRevs: { ...next.previousRevs, ...curr.previousRevs },
+    previous: { ...next.previous, ...curr.previous },
+    base: { ...next.base, ...curr.base },
+    // Use the earliest timestamp from curr.
+    timestamp: curr.timestamp ?? next.timestamp
+  };
 }
 function transitionAppliedTransactionsToOutgoing(prev) {
   if (prev.outgoing) return prev;
@@ -1978,32 +2237,43 @@ function manageSubscriberIds({ state }, handles) {
 }
 function getDocumentIdsFromHandleLikes(handles) {
   return handles.flatMap((handle) => {
+    if ("type" in handle && isReleaseAction(handle))
+      return [getReleaseDocumentId(handle.releaseId)];
     const idsForDocument = [];
     return handle.documentId ? handle.liveEdit ? [handle.documentId] : (isReleasePerspective(handle.perspective) && idsForDocument.push(
       getVersionId(DocumentId(handle.documentId), handle.perspective.releaseName)
     ), idsForDocument.push(getPublishedId(DocumentId(handle.documentId))), idsForDocument.push(getDraftId(DocumentId(handle.documentId))), idsForDocument) : [];
   });
 }
+const actionMap = {
+  "document.create": "created",
+  "document.delete": "deleted",
+  "document.discard": "discarded",
+  "document.edit": "edited",
+  "document.publish": "published",
+  "document.unpublish": "unpublished",
+  "release.create": "created",
+  "release.edit": "edited",
+  "release.delete": "deleted"
+};
 function getDocumentEvents(outgoing) {
-  const documentIdsByAction = Object.entries(
-    outgoing.actions.reduce(
-      (acc, { type, documentId }) => {
-        const ids = acc[type] || /* @__PURE__ */ new Set();
-        return documentId && ids.add(documentId), acc[type] = ids, acc;
-      },
-      {}
-    )
-  ), actionMap = {
-    "document.create": "created",
-    "document.delete": "deleted",
-    "document.discard": "discarded",
-    "document.edit": "edited",
-    "document.publish": "published",
-    "document.unpublish": "unpublished"
-  };
-  return documentIdsByAction.flatMap(
-    ([actionType, documentIds]) => Array.from(documentIds).map(
-      (documentId) => ({ type: actionMap[actionType], documentId, outgoing })
+  const documentIdsByAction = outgoing.actions.reduce(
+    (acc, action) => {
+      if (!(action.type in actionMap)) return acc;
+      const documentId = isReleaseAction(action) ? getReleaseDocumentId(action.releaseId) : action.documentId;
+      if (!documentId) return acc;
+      const type = action.type, ids = acc[type] ?? /* @__PURE__ */ new Set();
+      return ids.add(documentId), acc[type] = ids, acc;
+    },
+    {}
+  );
+  return Object.entries(documentIdsByAction).flatMap(
+    ([actionType, documentIds]) => Array.from(documentIds ?? []).map(
+      (documentId) => ({
+        type: actionMap[actionType],
+        documentId,
+        outgoing
+      })
     )
   );
 }
@@ -2227,7 +2497,7 @@ const _resolveDocument = bindActionByResource(
         result,
         outgoing
       }));
-      return outgoing.actions.some((action) => action.liveEdit) ? client.observable.mutate(outgoing.outgoingMutations, {
+      return outgoing.actions.some((action) => !isReleaseAction(action) && action.liveEdit) ? client.observable.mutate(outgoing.outgoingMutations, {
         transactionId: outgoing.transactionId,
         visibility: "async",
         returnDocuments: !1,
@@ -3270,6 +3540,7 @@ export {
   agentTransform,
   agentTranslate,
   applyDocumentActions,
+  archiveRelease,
   configureLogging,
   createDatasetHandle,
   createDocument,
@@ -3277,13 +3548,17 @@ export {
   createDocumentTypeHandle,
   createGroqSearchFilter,
   createProjectHandle,
+  createRelease,
   createSanityInstance,
   defineIntent,
   deleteDocument,
+  deleteRelease,
   destroyController,
   discardDocument,
   editDocument,
+  editRelease,
   getActiveReleasesState,
+  getAllReleasesState,
   getAuthState,
   getClient,
   getClientErrorApiBody,
@@ -3316,6 +3591,7 @@ export {
   getProjectsState,
   getQueryKey,
   getQueryState,
+  getReleaseDocumentId,
   getTokenState,
   getUserState,
   getUsersKey,
@@ -3338,6 +3614,7 @@ export {
   parseQueryKey,
   parseUsersKey,
   publishDocument,
+  publishRelease,
   releaseChannel,
   releaseNode,
   resolveDatasets,
@@ -3353,11 +3630,14 @@ export {
   resolveQuery,
   resolveUser,
   resolveUsers,
+  scheduleRelease,
   setAuthToken,
   slicePath2 as slicePath,
   stringifyPath2 as stringifyPath,
   subscribeDocumentEvents,
   transformProjectionToPreview,
-  unpublishDocument
+  unarchiveRelease,
+  unpublishDocument,
+  unscheduleRelease
 };
 //# sourceMappingURL=index.js.map