@sanity/client 7.1.0-views.0 → 7.1.0-views.2

package/umd/sanityClient.js

@@ -1495,6 +1495,24 @@
       });
   }
 
+  function firstValueFrom(source, config) {
+      return new Promise(function (resolve, reject) {
+          var subscriber = new SafeSubscriber({
+              next: function (value) {
+                  resolve(value);
+                  subscriber.unsubscribe();
+              },
+              error: reject,
+              complete: function () {
+                  {
+                      reject(new EmptyError());
+                  }
+              },
+          });
+          source.subscribe(subscriber);
+      });
+  }
+
   function isValidDate$1(value) {
       return value instanceof Date && !isNaN(value);
   }
@@ -1875,6 +1893,9 @@
               identity;
   }
 
+  function isRecord(value) {
+    return typeof value == "object" && value !== null && !Array.isArray(value);
+  }
   var s = { 0: 8203, 1: 8204, 2: 8205, 3: 8290, 4: 8291, 5: 8288, 6: 65279, 7: 8289, 8: 119155, 9: 119156, a: 119157, b: 119158, c: 119159, d: 119160, e: 119161, f: 119162 }, c = { 0: 8203, 1: 8204, 2: 8205, 3: 65279 }, u = new Array(4).fill(String.fromCodePoint(c[0])).join("");
   function E(t) {
     let e = JSON.stringify(t);
@@ -1912,13 +1933,110 @@
     return O(result);
   }
 
+  const DRAFTS_FOLDER$1 = "drafts", VERSION_FOLDER$1 = "versions", PATH_SEPARATOR$1 = ".", DRAFTS_PREFIX$1 = `${DRAFTS_FOLDER$1}${PATH_SEPARATOR$1}`, VERSION_PREFIX$1 = `${VERSION_FOLDER$1}${PATH_SEPARATOR$1}`;
+  function isDraftId$1(id) {
+    return id.startsWith(DRAFTS_PREFIX$1);
+  }
+  function isVersionId$1(id) {
+    return id.startsWith(VERSION_PREFIX$1);
+  }
+  function getDraftId(id) {
+    if (isVersionId$1(id)) {
+      const publishedId = getPublishedId$1(id);
+      return DRAFTS_PREFIX$1 + publishedId;
+    }
+    return isDraftId$1(id) ? id : DRAFTS_PREFIX$1 + id;
+  }
+  function getVersionId(id, version) {
+    if (version === "drafts" || version === "published")
+      throw new Error('Version can not be "published" or "drafts"');
+    return `${VERSION_PREFIX$1}${version}${PATH_SEPARATOR$1}${getPublishedId$1(id)}`;
+  }
+  function getVersionFromId$1(id) {
+    if (!isVersionId$1(id)) return;
+    const [_versionPrefix, versionId, ..._publishedId] = id.split(PATH_SEPARATOR$1);
+    return versionId;
+  }
+  function getPublishedId$1(id) {
+    return isVersionId$1(id) ? id.split(PATH_SEPARATOR$1).slice(2).join(PATH_SEPARATOR$1) : isDraftId$1(id) ? id.slice(DRAFTS_PREFIX$1.length) : id;
+  }
+
+  const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+  function codeFrame(query, location2, message) {
+    const lines = query.split(NEWLINE), loc = {
+      start: columnToLine(location2.start, lines),
+      end: location2.end ? columnToLine(location2.end, lines) : void 0
+    }, { start, end, markerLines } = getMarkerLines(loc, lines), numberMaxWidth = `${end}`.length;
+    return query.split(NEWLINE, end).slice(start, end).map((line, index) => {
+      const number = start + 1 + index, gutter = ` ${` ${number}`.slice(-numberMaxWidth)} |`, hasMarker = markerLines[number], lastMarkerLine = !markerLines[number + 1];
+      if (!hasMarker)
+        return ` ${gutter}${line.length > 0 ? ` ${line}` : ""}`;
+      let markerLine = "";
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " "), numberOfMarkers = hasMarker[1] || 1;
+        markerLine = [
+          `
+ `,
+          gutter.replace(/\d/g, " "),
+          " ",
+          markerSpacing,
+          "^".repeat(numberOfMarkers)
+        ].join(""), lastMarkerLine && message && (markerLine += " " + message);
+      }
+      return [">", gutter, line.length > 0 ? ` ${line}` : "", markerLine].join("");
+    }).join(`
+`);
+  }
+  function getMarkerLines(loc, source) {
+    const startLoc = { ...loc.start }, endLoc = { ...startLoc, ...loc.end }, linesAbove = 2, linesBelow = 3, startLine = startLoc.line ?? -1, startColumn = startLoc.column ?? 0, endLine = endLoc.line, endColumn = endLoc.column;
+    let start = Math.max(startLine - (linesAbove + 1), 0), end = Math.min(source.length, endLine + linesBelow);
+    startLine === -1 && (start = 0), endLine === -1 && (end = source.length);
+    const lineDiff = endLine - startLine, markerLines = {};
+    if (lineDiff)
+      for (let i = 0; i <= lineDiff; i++) {
+        const lineNumber = i + startLine;
+        if (!startColumn)
+          markerLines[lineNumber] = true;
+        else if (i === 0) {
+          const sourceLength = source[lineNumber - 1].length;
+          markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+        } else if (i === lineDiff)
+          markerLines[lineNumber] = [0, endColumn];
+        else {
+          const sourceLength = source[lineNumber - i].length;
+          markerLines[lineNumber] = [0, sourceLength];
+        }
+      }
+    else
+      startColumn === endColumn ? startColumn ? markerLines[startLine] = [startColumn, 0] : markerLines[startLine] = true : markerLines[startLine] = [startColumn, endColumn - startColumn];
+    return { start, end, markerLines };
+  }
+  function columnToLine(column, lines) {
+    let offset = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const lineLength = lines[i].length + 1;
+      if (offset + lineLength > column)
+        return {
+          line: i + 1,
+          // 1-based line
+          column: column - offset
+          // 0-based column
+        };
+      offset += lineLength;
+    }
+    return {
+      line: lines.length,
+      column: lines[lines.length - 1]?.length ?? 0
+    };
+  }
+  const MAX_ITEMS_IN_ERROR_MESSAGE = 5;
   class ClientError extends Error {
     response;
     statusCode = 400;
     responseBody;
     details;
-    constructor(res) {
-      const props = extractErrorProps(res);
+    constructor(res, context) {
+      const props = extractErrorProps(res, context);
       super(props.message), Object.assign(this, props);
     }
   }
@@ -1932,7 +2050,7 @@
       super(props.message), Object.assign(this, props);
     }
   }
-  function extractErrorProps(res) {
+  function extractErrorProps(res, context) {
     const body = res.body, props = {
       response: res,
       statusCode: res.statusCode,
@@ -1940,34 +2058,56 @@
       message: "",
       details: void 0
     };
-    if (body.error && body.message)
-      return props.message = `${body.error} - ${body.message}`, props;
-    if (isMutationError(body) || isActionError(body)) {
-      const allItems = body.error.items || [], items = allItems.slice(0, 5).map((item) => item.error?.description).filter(Boolean);
+    if (!isRecord(body))
+      return props.message = httpErrorMessage(res, body), props;
+    const error = body.error;
+    if (typeof error == "string" && typeof body.message == "string")
+      return props.message = `${error} - ${body.message}`, props;
+    if (typeof error != "object" || error === null)
+      return typeof error == "string" ? props.message = error : typeof body.message == "string" ? props.message = body.message : props.message = httpErrorMessage(res, body), props;
+    if (isMutationError(error) || isActionError(error)) {
+      const allItems = error.items || [], items = allItems.slice(0, MAX_ITEMS_IN_ERROR_MESSAGE).map((item) => item.error?.description).filter(Boolean);
       let itemsStr = items.length ? `:
 - ${items.join(`
 - `)}` : "";
-      return allItems.length > 5 && (itemsStr += `
-...and ${allItems.length - 5} more`), props.message = `${body.error.description}${itemsStr}`, props.details = body.error, props;
+      return allItems.length > MAX_ITEMS_IN_ERROR_MESSAGE && (itemsStr += `
+...and ${allItems.length - MAX_ITEMS_IN_ERROR_MESSAGE} more`), props.message = `${error.description}${itemsStr}`, props.details = body.error, props;
+    }
+    if (isQueryParseError(error)) {
+      const tag = context?.options?.query?.tag;
+      return props.message = formatQueryParseError(error, tag), props.details = body.error, props;
     }
-    return body.error && body.error.description ? (props.message = body.error.description, props.details = body.error, props) : (props.message = body.error || body.message || httpErrorMessage(res), props);
+    return "description" in error && typeof error.description == "string" ? (props.message = error.description, props.details = error, props) : (props.message = httpErrorMessage(res, body), props);
   }
-  function isMutationError(body) {
-    return isPlainObject(body) && isPlainObject(body.error) && body.error.type === "mutationError" && typeof body.error.description == "string";
+  function isMutationError(error) {
+    return "type" in error && error.type === "mutationError" && "description" in error && typeof error.description == "string";
   }
-  function isActionError(body) {
-    return isPlainObject(body) && isPlainObject(body.error) && body.error.type === "actionError" && typeof body.error.description == "string";
+  function isActionError(error) {
+    return "type" in error && error.type === "actionError" && "description" in error && typeof error.description == "string";
   }
-  function isPlainObject(obj) {
-    return typeof obj == "object" && obj !== null && !Array.isArray(obj);
+  function isQueryParseError(error) {
+    return isRecord(error) && error.type === "queryParseError" && typeof error.query == "string" && typeof error.start == "number" && typeof error.end == "number";
   }
-  function httpErrorMessage(res) {
-    const statusMessage = res.statusMessage ? ` ${res.statusMessage}` : "";
-    return `${res.method}-request to ${res.url} resulted in HTTP ${res.statusCode}${statusMessage}`;
+  function formatQueryParseError(error, tag) {
+    const { query, start, end, description } = error;
+    if (!query || typeof start > "u")
+      return `GROQ query parse error: ${description}`;
+    const withTag = tag ? `
+
+Tag: ${tag}` : "";
+    return `GROQ query parse error:
+${codeFrame(query, { start, end }, description)}${withTag}`;
+  }
+  function httpErrorMessage(res, body) {
+    const details = typeof body == "string" ? ` (${sliceWithEllipsis(body, 100)})` : "", statusMessage = res.statusMessage ? ` ${res.statusMessage}` : "";
+    return `${res.method}-request to ${res.url} resulted in HTTP ${res.statusCode}${statusMessage}${details}`;
   }
   function stringifyBody(body, res) {
     return (res.headers["content-type"] || "").toLowerCase().indexOf("application/json") !== -1 ? JSON.stringify(body, null, 2) : body;
   }
+  function sliceWithEllipsis(str, max) {
+    return str.length > max ? `${str.slice(0, max)}\u2026` : str;
+  }
   class CorsOriginError extends Error {
     projectId;
     addOriginUrl;
@@ -1982,11 +2122,11 @@
     }
   }
   const httpError = {
-    onResponse: (res) => {
+    onResponse: (res, context) => {
       if (res.statusCode >= 500)
         throw new ServerError(res);
       if (res.statusCode >= 400)
-        throw new ClientError(res);
+        throw new ClientError(res, context);
       return res;
     }
   };
@@ -2043,6 +2183,18 @@
     if (!doc._id)
       throw new Error(`${op}() requires that the document contains an ID ("_id" property)`);
     validateDocumentId(op, doc._id);
+  }, validateDocumentType = (op, type) => {
+    if (typeof type != "string")
+      throw new Error(`\`${op}()\`: \`${type}\` is not a valid document type`);
+  }, requireDocumentType = (op, doc) => {
+    if (!doc._type)
+      throw new Error(`\`${op}()\` requires that the document contains a type (\`_type\` property)`);
+    validateDocumentType(op, doc._type);
+  }, validateVersionIdMatch = (builtVersionId, document) => {
+    if (document._id && document._id !== builtVersionId)
+      throw new Error(
+        `The provided document ID (\`${document._id}\`) does not match the generated version ID (\`${builtVersionId}\`)`
+      );
   }, validateInsert = (at, selector, items) => {
     const signature = "insert(at, selector, items)";
     if (VALID_INSERT_LOCATIONS.indexOf(at) === -1) {
@@ -2085,6 +2237,7 @@
     if (config["~experimental_resource"])
       throw new Error(`\`${service}\` does not support resource-based operations`);
   };
+  var ViewResourceType = /* @__PURE__ */ ((ViewResourceType2) => (ViewResourceType2.Dataset = "dataset", ViewResourceType2.View = "view", ViewResourceType2))(ViewResourceType || {});
   function once(fn) {
     let didCall = false, returnValue;
     return (...args) => (didCall || (returnValue = fn(...args), didCall = true), returnValue);
@@ -2236,7 +2389,8 @@
           return;
         }
         if (message.type === "channelError") {
-          observer.error(new ChannelError(extractErrorMessage(event?.data), event.data));
+          const tag = new URL(es.url).searchParams.get("tag");
+          observer.error(new ChannelError(extractErrorMessage(event?.data, tag), event.data));
           return;
         }
         if (message.type === "disconnect") {
@@ -2275,8 +2429,9 @@
       return [err, null];
     }
   }
-  function extractErrorMessage(err) {
-    return err.error ? err.error.description ? err.error.description : typeof err.error == "string" ? err.error : JSON.stringify(err.error, null, 2) : err.message || "Unknown listener error";
+  function extractErrorMessage(err, tag) {
+    const error = err.error;
+    return error ? isQueryParseError(error) ? formatQueryParseError(error, tag) : error.description ? error.description : typeof error == "string" ? error : JSON.stringify(error, null, 2) : err.message || "Unknown listener error";
   }
   function isEmptyObject(data) {
     for (const _ in data)
@@ -2619,7 +2774,9 @@ ${selectionOpts}`);
   }
   const projectHeader = "X-Sanity-Project-ID";
   function requestOptions(config, overrides = {}) {
-    const headers = {}, token = overrides.token || config.token;
+    const headers = {};
+    config.headers && Object.assign(headers, config.headers);
+    const token = overrides.token || config.token;
     token && (headers.Authorization = `Bearer ${token}`), !overrides.useGlobalApi && !config.useProjectHostname && config.projectId && (headers[projectHeader] = config.projectId);
     const withCredentials = !!(typeof overrides.withCredentials > "u" ? config.withCredentials : overrides.withCredentials), timeout = typeof overrides.timeout > "u" ? config.timeout : overrides.timeout;
     return Object.assign({}, overrides, {
@@ -2639,7 +2796,7 @@ ${selectionOpts}`);
     const searchParams = new URLSearchParams(), { tag, includeMutations, returnQuery, ...opts } = options;
     tag && searchParams.append("tag", tag), searchParams.append("query", query);
     for (const [key, value] of Object.entries(params))
-      searchParams.append(`$${key}`, JSON.stringify(value));
+      value !== void 0 && searchParams.append(`$${key}`, JSON.stringify(value));
     for (const [key, value] of Object.entries(opts))
       value && searchParams.append(key, `${value}`);
     return returnQuery === false && searchParams.append("returnQuery", "false"), includeMutations === false && searchParams.append("includeMutations", "false"), `?${searchParams}`;
@@ -2655,17 +2812,25 @@ ${selectionOpts}`);
     const stega = "stega" in options ? {
       ..._stega || {},
       ...typeof options.stega == "boolean" ? { enabled: options.stega } : options.stega || {}
-    } : _stega, params = stega.enabled ? stegaClean(_params) : _params, mapResponse = options.filterResponse === false ? (res) => res : (res) => res.result, { cache, next, ...opts } = {
+    } : _stega, params = stega.enabled ? stegaClean(_params) : _params, mapResponse = options.filterResponse === false ? (res) => res : (res) => res.result, { cache, next, useEmulate, connections, ...opts } = {
       // Opt out of setting a `signal` on an internal `fetch` if one isn't provided.
       // This is necessary in React Server Components to avoid opting out of Request Memoization.
       useAbortSignal: typeof options.signal < "u",
       // Set `resultSourceMap' when stega is enabled, as it's required for encoding.
       resultSourceMap: stega.enabled ? "withKeyArraySelector" : options.resultSourceMap,
+      // Only use emulate if explicitly asked for
+      useEmulate: false,
+      // Having connections is a special case for views
+      connections: void 0,
       ...options,
       // Default to not returning the query, unless `filterResponse` is `false`,
       // or `returnQuery` is explicitly set. `true` is the default in Content Lake, so skip if truthy
       returnQuery: options.filterResponse === false && options.returnQuery !== false
-    }, reqOpts = typeof cache < "u" || typeof next < "u" ? { ...opts, fetch: { cache, next } } : opts, $request = _dataRequest(config, httpRequest, "query", { query, params }, reqOpts);
+    }, reqOpts = typeof cache < "u" || typeof next < "u" ? { ...opts, fetch: { cache, next } } : opts, $request = _dataRequest(config, httpRequest, useEmulate ? "emulate" : "query", useEmulate ? {
+      query,
+      params,
+      connections
+    } : { query, params }, reqOpts);
     return stega.enabled ? $request.pipe(
       combineLatestWith(
         from(
@@ -2685,8 +2850,24 @@ ${selectionOpts}`);
     ) : $request.pipe(map(mapResponse));
   }
   function _getDocument(config, httpRequest, id, opts = {}) {
-    const options = {
-      uri: _getDataUrl(config, "doc", id),
+    const docId = (() => {
+      if (!opts.releaseId)
+        return id;
+      const versionId = getVersionFromId$1(id);
+      if (!versionId) {
+        if (isDraftId$1(id))
+          throw new Error(
+            `The document ID (\`${id}\`) is a draft, but \`options.releaseId\` is set as \`${opts.releaseId}\``
+          );
+        return getVersionId(id, opts.releaseId);
+      }
+      if (versionId !== opts.releaseId)
+        throw new Error(
+          `The document ID (\`${id}\`) is already a version of \`${versionId}\` release, but this does not match the provided \`options.releaseId\` (\`${opts.releaseId}\`)`
+        );
+      return id;
+    })(), options = {
+      uri: _getDataUrl(config, "doc", docId),
       json: true,
       tag: opts.tag,
       signal: opts.signal
@@ -2711,12 +2892,33 @@ ${selectionOpts}`);
       })
     );
   }
+  function _getReleaseDocuments(config, httpRequest, releaseId, opts = {}) {
+    return _dataRequest(
+      config,
+      httpRequest,
+      "query",
+      {
+        query: "*[sanity::partOfRelease($releaseId)]",
+        params: {
+          releaseId
+        }
+      },
+      opts
+    );
+  }
   function _createIfNotExists(config, httpRequest, doc, options) {
     return requireDocumentId("createIfNotExists", doc), _create(config, httpRequest, doc, "createIfNotExists", options);
   }
   function _createOrReplace(config, httpRequest, doc, options) {
     return requireDocumentId("createOrReplace", doc), _create(config, httpRequest, doc, "createOrReplace", options);
   }
+  function _createVersion(config, httpRequest, doc, publishedId, options) {
+    return requireDocumentId("createVersion", doc), requireDocumentType("createVersion", doc), _action(config, httpRequest, {
+      actionType: "sanity.action.document.version.create",
+      publishedId,
+      document: doc
+    }, options);
+  }
   function _delete(config, httpRequest, selection, options) {
     return _dataRequest(
       config,
@@ -2726,6 +2928,26 @@ ${selectionOpts}`);
       options
     );
   }
+  function _discardVersion(config, httpRequest, versionId, purge = false, options) {
+    return _action(config, httpRequest, {
+      actionType: "sanity.action.document.version.discard",
+      versionId,
+      purge
+    }, options);
+  }
+  function _replaceVersion(config, httpRequest, doc, options) {
+    return requireDocumentId("replaceVersion", doc), requireDocumentType("replaceVersion", doc), _action(config, httpRequest, {
+      actionType: "sanity.action.document.version.replace",
+      document: doc
+    }, options);
+  }
+  function _unpublishVersion(config, httpRequest, versionId, publishedId, options) {
+    return _action(config, httpRequest, {
+      actionType: "sanity.action.document.version.unpublish",
+      versionId,
+      publishedId
+    }, options);
+  }
   function _mutate(config, httpRequest, mutations, options) {
     let mut;
     mutations instanceof Patch || mutations instanceof ObservablePatch ? mut = { patch: mutations.serialize() } : mutations instanceof Transaction || mutations instanceof ObservableTransaction ? mut = mutations.serialize() : mut = mutations;
@@ -2743,7 +2965,7 @@ ${selectionOpts}`);
     );
   }
   function _dataRequest(config, httpRequest, endpoint, body, options = {}) {
-    const isMutation = endpoint === "mutate", isAction = endpoint === "actions", isQuery2 = endpoint === "query", strQuery = isMutation || isAction ? "" : encodeQueryString(body), useGet = !isMutation && !isAction && strQuery.length < getQuerySizeLimit, stringQuery = useGet ? strQuery : "", returnFirst = options.returnFirst, { timeout, token, tag, headers, returnQuery, lastLiveEventId, cacheMode } = options, uri = _getDataUrl(config, endpoint, stringQuery), reqOptions = {
+    const isMutation = endpoint === "mutate", isAction = endpoint === "actions", isQuery2 = endpoint === "query", isEmulate2 = endpoint === "emulate", strQuery = isMutation || isAction || isEmulate2 ? "" : encodeQueryString(body), useGet = !isMutation && !isAction && !isEmulate2 && strQuery.length < getQuerySizeLimit, stringQuery = useGet ? strQuery : "", returnFirst = options.returnFirst, { timeout, token, tag, headers, returnQuery, lastLiveEventId, cacheMode } = options, uri = _getDataUrl(config, endpoint, stringQuery), reqOptions = {
       method: useGet ? "GET" : "POST",
       uri,
       json: true,
@@ -2786,12 +3008,12 @@ ${selectionOpts}`);
     const mutation = { [op]: doc }, opts = Object.assign({ returnFirst: true, returnDocuments: true }, options);
     return _dataRequest(config, httpRequest, "mutate", { mutations: [mutation] }, opts);
   }
-  const hasDataConfig = (config) => config.dataset !== void 0 && config.projectId !== void 0 || config["~experimental_resource"] !== void 0, isQuery = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "query")), isViewQuery = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "views")), isMutate = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "mutate")), isDoc = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "doc", "")), isListener = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "listen")), isHistory = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "history", "")), isData = (config, uri) => uri.startsWith("/data/") || isQuery(config, uri) || isMutate(config, uri) || isDoc(config, uri) || isListener(config, uri) || isHistory(config, uri) || isViewQuery(config, uri);
+  const hasDataConfig = (config) => config.dataset !== void 0 && config.projectId !== void 0 || config["~experimental_resource"] !== void 0, isQuery = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "query")), isViewQuery = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "views")), isEmulate = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "emulate")), isMutate = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "mutate")), isDoc = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "doc", "")), isListener = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "listen")), isHistory = (config, uri) => hasDataConfig(config) && uri.startsWith(_getDataUrl(config, "history", "")), isData = (config, uri) => uri.startsWith("/data/") || isQuery(config, uri) || isMutate(config, uri) || isDoc(config, uri) || isListener(config, uri) || isHistory(config, uri) || isViewQuery(config, uri) || isEmulate(config, uri);
   function _requestObservable(config, httpRequest, options) {
     const uri = options.url || options.uri, canUseCdn = typeof options.canUseCdn > "u" ? ["GET", "HEAD"].indexOf(options.method || "GET") >= 0 && isData(config, uri) : options.canUseCdn;
     let useCdn = (options.useCdn ?? config.useCdn) && canUseCdn;
     const tag = options.tag && config.requestTagPrefix ? [config.requestTagPrefix, options.tag].join(".") : options.tag || config.requestTagPrefix;
-    if (tag && options.tag !== null && (options.query = { tag: requestTag(tag), ...options.query }), ["GET", "HEAD", "POST"].indexOf(options.method || "GET") >= 0 && isQuery(config, uri)) {
+    if (tag && options.tag !== null && (options.query = { tag: requestTag(tag), ...options.query }), ["GET", "HEAD", "POST"].indexOf(options.method || "GET") >= 0 && (isQuery(config, uri) || isEmulate(config, uri))) {
       const resultSourceMap = options.resultSourceMap ?? config.resultSourceMap;
       resultSourceMap !== void 0 && resultSourceMap !== false && (options.query = { resultSourceMap, ...options.query });
       const perspectiveOption = options.perspective || config.perspective;
@@ -2826,7 +3048,7 @@ ${selectionOpts}`);
     const catalog = hasDataset(config), baseUri = `/${operation}/${catalog}`;
     return `/data${path !== void 0 ? `${baseUri}/${path}` : baseUri}`.replace(/\/($|\?)/, "$1");
   }
-  function _getUrl(config, uri, canUseCdn = false, options = {}) {
+  function _getUrl(config, uri, canUseCdn = false) {
     const { url, cdnUrl } = config;
     return `${canUseCdn ? cdnUrl : url}/${uri.replace(/^\//, "")}`;
   }
@@ -2881,6 +3103,22 @@ ${selectionOpts}`);
       body: request
     });
   }
+  function _patch(client, httpRequest, request) {
+    const dataset2 = hasDataset(client.config());
+    return _request(client.config(), httpRequest, {
+      method: "POST",
+      uri: `/agent/action/patch/${dataset2}`,
+      body: request
+    });
+  }
+  function _prompt(client, httpRequest, request) {
+    const dataset2 = hasDataset(client.config());
+    return _request(client.config(), httpRequest, {
+      method: "POST",
+      uri: `/agent/action/prompt/${dataset2}`,
+      body: request
+    });
+  }
   function _transform(client, httpRequest, request) {
     const dataset2 = hasDataset(client.config());
     return _request(client.config(), httpRequest, {
@@ -2952,6 +3190,21 @@ ${selectionOpts}`);
     translate(request) {
       return lastValueFrom(_translate(this.#client, this.#httpRequest, request));
     }
+    /**
+     * Run a raw instruction and return the result either as text or json
+     * @param request - prompt request
+     */
+    prompt(request) {
+      return lastValueFrom(_prompt(this.#client, this.#httpRequest, request));
+    }
+    /**
+     * Patch a document using a schema aware API.
+     * Does not use an LLM, but uses the schema to ensure paths and values matches the schema.
+     * @param request - instruction request
+     */
+    patch(request) {
+      return lastValueFrom(_patch(this.#client, this.#httpRequest, request));
+    }
   }
   class ObservableAssetsClient {
     #client;
@@ -3060,13 +3313,11 @@ ${selectionOpts}`);
     includeResult: true
   };
   function _listen(query, params, opts = {}) {
-    const { url, token, withCredentials, requestTagPrefix } = this.config(), tag = opts.tag && requestTagPrefix ? [requestTagPrefix, opts.tag].join(".") : opts.tag, options = { ...defaults(opts, defaultOptions), tag }, listenOpts = pick(options, possibleOptions), qs = encodeQueryString({ query, params, options: { tag, ...listenOpts } }), uri = `${url}${_getDataUrl(this.config(), "listen", qs)}`;
+    const { url, token, withCredentials, requestTagPrefix, headers: configHeaders } = this.config(), tag = opts.tag && requestTagPrefix ? [requestTagPrefix, opts.tag].join(".") : opts.tag, options = { ...defaults(opts, defaultOptions), tag }, listenOpts = pick(options, possibleOptions), qs = encodeQueryString({ query, params, options: { tag, ...listenOpts } }), uri = `${url}${_getDataUrl(this.config(), "listen", qs)}`;
     if (uri.length > MAX_URL_LENGTH)
       return throwError(() => new Error("Query too large for listener"));
     const listenFor = options.events ? options.events : ["mutation"], esOptions = {};
-    return withCredentials && (esOptions.withCredentials = true), token && (esOptions.headers = {
-      Authorization: `Bearer ${token}`
-    }), connectEventSource(() => (
+    return withCredentials && (esOptions.withCredentials = true), (token || configHeaders) && (esOptions.headers = {}, token && (esOptions.headers.Authorization = `Bearer ${token}`), configHeaders && Object.assign(esOptions.headers, configHeaders)), connectEventSource(() => (
       // use polyfill if there is no global EventSource or if we need to set headers
       (typeof EventSource > "u" || esOptions.headers ? eventSourcePolyfill : of(EventSource)).pipe(map((EventSource2) => new EventSource2(uri, esOptions)))
     ), listenFor).pipe(
@@ -3124,7 +3375,8 @@ ${selectionOpts}`);
         apiVersion: _apiVersion,
         token,
         withCredentials,
-        requestTagPrefix
+        requestTagPrefix,
+        headers: configHeaders
       } = this.#client.config(), apiVersion = _apiVersion.replace(/^v/, "");
       if (apiVersion !== "X" && apiVersion < requiredApiVersion)
         throw new Error(
@@ -3137,9 +3389,7 @@ ${selectionOpts}`);
       const path = _getDataUrl(this.#client.config(), "live/events"), url = new URL(this.#client.getUrl(path, false)), tag = _tag && requestTagPrefix ? [requestTagPrefix, _tag].join(".") : _tag;
       tag && url.searchParams.set("tag", tag), includeDrafts && url.searchParams.set("includeDrafts", "true");
       const esOptions = {};
-      includeDrafts && token && (esOptions.headers = {
-        Authorization: `Bearer ${token}`
-      }), includeDrafts && withCredentials && (esOptions.withCredentials = true);
+      includeDrafts && withCredentials && (esOptions.withCredentials = true), (includeDrafts && token || configHeaders) && (esOptions.headers = {}, includeDrafts && token && (esOptions.headers.Authorization = `Bearer ${token}`), configHeaders && Object.assign(esOptions.headers, configHeaders));
       const key = `${url.href}::${JSON.stringify(esOptions)}`, existing = eventsCache.get(key);
       if (existing)
         return existing;
@@ -3277,7 +3527,10 @@ ${selectionOpts}`);
      */
     list() {
       return resourceGuard("dataset", this.#client.config()), lastValueFrom(
-        _request(this.#client.config(), this.#httpRequest, { uri: "/datasets", tag: null })
+        _request(this.#client.config(), this.#httpRequest, {
+          uri: "/datasets",
+          tag: null
+        })
       );
     }
   }
@@ -3306,7 +3559,9 @@ ${selectionOpts}`);
      * @param projectId - ID of the project to fetch
      */
     getById(projectId2) {
-      return resourceGuard("projects", this.#client.config()), _request(this.#client.config(), this.#httpRequest, { uri: `/projects/${projectId2}` });
+      return resourceGuard("projects", this.#client.config()), _request(this.#client.config(), this.#httpRequest, {
+        uri: `/projects/${projectId2}`
+      });
     }
   }
   class ProjectsClient {
@@ -3327,7 +3582,518 @@ ${selectionOpts}`);
      */
     getById(projectId2) {
       return resourceGuard("projects", this.#client.config()), lastValueFrom(
-        _request(this.#client.config(), this.#httpRequest, { uri: `/projects/${projectId2}` })
+        _request(this.#client.config(), this.#httpRequest, {
+          uri: `/projects/${projectId2}`
+        })
+      );
+    }
+  }
+  let random = (bytes) => crypto.getRandomValues(new Uint8Array(bytes)), customRandom = (alphabet, defaultSize, getRandom) => {
+    let mask = (2 << Math.log(alphabet.length - 1) / Math.LN2) - 1, step = -~(1.6 * mask * defaultSize / alphabet.length);
+    return (size = defaultSize) => {
+      let id = "";
+      for (; ; ) {
+        let bytes = getRandom(step), j = step | 0;
+        for (; j--; )
+          if (id += alphabet[bytes[j] & mask] || "", id.length === size) return id;
+      }
+    };
+  }, customAlphabet = (alphabet, size = 21) => customRandom(alphabet, size, random);
+  const generateReleaseId = customAlphabet(
+    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
+    8
+  ), getDocumentVersionId = (publishedId, releaseId) => releaseId ? getVersionId(publishedId, releaseId) : getDraftId(publishedId);
+  function deriveDocumentVersionId(op, {
+    releaseId,
+    publishedId,
+    document
+  }) {
+    if (publishedId && document._id) {
+      const versionId = getDocumentVersionId(publishedId, releaseId);
+      return validateVersionIdMatch(versionId, document), versionId;
+    }
+    if (document._id) {
+      const isDraft = isDraftId$1(document._id), isVersion = isVersionId$1(document._id);
+      if (!isDraft && !isVersion)
+        throw new Error(
+          `\`${op}()\` requires a document with an \`_id\` that is a version or draft ID`
+        );
+      if (releaseId) {
+        if (isDraft)
+          throw new Error(
+            `\`${op}()\` was called with a document ID (\`${document._id}\`) that is a draft ID, but a release ID (\`${releaseId}\`) was also provided.`
+          );
+        const builtVersionId = getVersionFromId$1(document._id);
+        if (builtVersionId !== releaseId)
+          throw new Error(
+            `\`${op}()\` was called with a document ID (\`${document._id}\`) that is a version ID, but the release ID (\`${releaseId}\`) does not match the document's version ID (\`${builtVersionId}\`).`
+          );
+      }
+      return document._id;
+    }
+    if (publishedId)
+      return getDocumentVersionId(publishedId, releaseId);
+    throw new Error(`\`${op}()\` requires either a publishedId or a document with an \`_id\``);
+  }
+  const getArgs = (releaseOrOptions, maybeOptions) => {
+    if (typeof releaseOrOptions == "object" && releaseOrOptions !== null && ("releaseId" in releaseOrOptions || "metadata" in releaseOrOptions)) {
+      const { releaseId = generateReleaseId(), metadata = {} } = releaseOrOptions;
+      return [releaseId, metadata, maybeOptions];
+    }
+    return [generateReleaseId(), {}, releaseOrOptions];
+  }, createRelease = (releaseOrOptions, maybeOptions) => {
+    const [releaseId, metadata, options] = getArgs(releaseOrOptions, maybeOptions), finalMetadata = {
+      ...metadata,
+      releaseType: metadata.releaseType || "undecided"
+    };
+    return { action: {
+      actionType: "sanity.action.release.create",
+      releaseId,
+      metadata: finalMetadata
+    }, options };
+  };
+  class ObservableReleasesClient {
+    #client;
+    #httpRequest;
+    constructor(client, httpRequest) {
+      this.#client = client, this.#httpRequest = httpRequest;
+    }
+    /**
+     * @public
+     *
+     * Retrieve a release by id.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to retrieve.
+     * @param options - Additional query options including abort signal and query tag.
+     * @returns An observable that resolves to the release document {@link ReleaseDocument}.
+     *
+     * @example Retrieving a release by id
+     * ```ts
+     * client.observable.releases.get({releaseId: 'my-release'}).pipe(
+     *   tap((release) => console.log(release)),
+     *   // {
+     *   //   _id: '_.releases.my-release',
+     *   //   name: 'my-release'
+     *   //   _type: 'system.release',
+     *   //   metadata: {releaseType: 'asap'},
+     *   //   _createdAt: '2021-01-01T00:00:00.000Z',
+     *   //   ...
+     *   // }
+     * ).subscribe()
+     * ```
+     */
+    get({ releaseId }, options) {
+      return _getDocument(
+        this.#client.config(),
+        this.#httpRequest,
+        `_.releases.${releaseId}`,
+        options
+      );
+    }
+    create(releaseOrOptions, maybeOptions) {
+      const { action, options } = createRelease(releaseOrOptions, maybeOptions), { releaseId, metadata } = action;
+      return _action(this.#client.config(), this.#httpRequest, action, options).pipe(
+        map((actionResult) => ({
+          ...actionResult,
+          releaseId,
+          metadata
+        }))
+      );
+    }
+    /**
+     * @public
+     *
+     * Edits an existing release, updating the metadata.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to edit.
+     *   - `patch` - The patch operation to apply on the release metadata {@link PatchMutationOperation}.
+     * @param options - Additional action options.
+     * @returns An observable that resolves to the `transactionId`.
+     */
+    edit({ releaseId, patch }, options) {
+      const editAction = {
+        actionType: "sanity.action.release.edit",
+        releaseId,
+        patch
+      };
+      return _action(this.#client.config(), this.#httpRequest, editAction, options);
+    }
+    /**
+     * @public
+     *
+     * Publishes all documents in a release at once. For larger releases the effect of the publish
+     * will be visible immediately when querying but the removal of the `versions.<releasesId>.*`
+     * documents and creation of the corresponding published documents with the new content may
+     * take some time.
+     *
+     * During this period both the source and target documents are locked and cannot be
+     * modified through any other means.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to publish.
+     * @param options - Additional action options.
+     * @returns An observable that resolves to the `transactionId`.
+     */
+    publish({ releaseId }, options) {
+      const publishAction = {
+        actionType: "sanity.action.release.publish",
+        releaseId
+      };
+      return _action(this.#client.config(), this.#httpRequest, publishAction, options);
+    }
+    /**
+     * @public
+     *
+     * An archive action removes an active release. The documents that comprise the release
+     * are deleted and therefore no longer queryable.
+     *
+     * While the documents remain in retention the last version can still be accessed using document history endpoint.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to archive.
+     * @param options - Additional action options.
+     * @returns An observable that resolves to the `transactionId`.
+     */
+    archive({ releaseId }, options) {
+      const archiveAction = {
+        actionType: "sanity.action.release.archive",
+        releaseId
+      };
+      return _action(this.#client.config(), this.#httpRequest, archiveAction, options);
+    }
+    /**
+     * @public
+     *
+     * An unarchive action restores an archived release and all documents
+     * with the content they had just prior to archiving.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to unarchive.
+     * @param options - Additional action options.
+     * @returns An observable that resolves to the `transactionId`.
+     */
+    unarchive({ releaseId }, options) {
+      const unarchiveAction = {
+        actionType: "sanity.action.release.unarchive",
+        releaseId
+      };
+      return _action(this.#client.config(), this.#httpRequest, unarchiveAction, options);
+    }
+    /**
+     * @public
+     *
+     * A schedule action queues a release for publishing at the given future time.
+     * The release is locked such that no documents in the release can be modified and
+     * no documents that it references can be deleted as this would make the publish fail.
+     * At the given time, the same logic as for the publish action is triggered.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to schedule.
+     *   - `publishAt` - The serialised date and time to publish the release. If the `publishAt` is in the past, the release will be published immediately.
+     * @param options - Additional action options.
+     * @returns An observable that resolves to the `transactionId`.
+     */
+    schedule({ releaseId, publishAt }, options) {
+      const scheduleAction = {
+        actionType: "sanity.action.release.schedule",
+        releaseId,
+        publishAt
+      };
+      return _action(this.#client.config(), this.#httpRequest, scheduleAction, options);
+    }
+    /**
+     * @public
+     *
+     * An unschedule action stops a release from being published.
+     * The documents in the release are considered unlocked and can be edited again.
+     * This may fail if another release is scheduled to be published after this one and
+     * has a reference to a document created by this one.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to unschedule.
+     * @param options - Additional action options.
+     * @returns An observable that resolves to the `transactionId`.
+     */
+    unschedule({ releaseId }, options) {
+      const unscheduleAction = {
+        actionType: "sanity.action.release.unschedule",
+        releaseId
+      };
+      return _action(this.#client.config(), this.#httpRequest, unscheduleAction, options);
+    }
+    /**
+     * @public
+     *
+     * A delete action removes a published or archived release.
+     * The backing system document will be removed from the dataset.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to delete.
+     * @param options - Additional action options.
+     * @returns An observable that resolves to the `transactionId`.
+     */
+    delete({ releaseId }, options) {
+      const deleteAction = {
+        actionType: "sanity.action.release.delete",
+        releaseId
+      };
+      return _action(this.#client.config(), this.#httpRequest, deleteAction, options);
+    }
+    /**
+     * @public
+     *
+     * Fetch the documents in a release by release id.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to fetch documents for.
+     * @param options - Additional mutation options {@link BaseMutationOptions}.
+     * @returns An observable that resolves to the documents in the release.
+     */
+    fetchDocuments({ releaseId }, options) {
+      return _getReleaseDocuments(this.#client.config(), this.#httpRequest, releaseId, options);
+    }
+  }
+  class ReleasesClient {
+    #client;
+    #httpRequest;
+    constructor(client, httpRequest) {
+      this.#client = client, this.#httpRequest = httpRequest;
+    }
+    /**
+     * @public
+     *
+     * Retrieve a release by id.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to retrieve.
+     * @param options - Additional query options including abort signal and query tag.
+     * @returns A promise that resolves to the release document {@link ReleaseDocument}.
+     *
+     * @example Retrieving a release by id
+     * ```ts
+     * const release = await client.releases.get({releaseId: 'my-release'})
+     * console.log(release)
+     * // {
+     * //   _id: '_.releases.my-release',
+     * //   name: 'my-release'
+     * //   _type: 'system.release',
+     * //   metadata: {releaseType: 'asap'},
+     * //   _createdAt: '2021-01-01T00:00:00.000Z',
+     * //   ...
+     * // }
+     * ```
+     */
+    get({ releaseId }, options) {
+      return lastValueFrom(
+        _getDocument(
+          this.#client.config(),
+          this.#httpRequest,
+          `_.releases.${releaseId}`,
+          options
+        )
+      );
+    }
+    async create(releaseOrOptions, maybeOptions) {
+      const { action, options } = createRelease(releaseOrOptions, maybeOptions), { releaseId, metadata } = action;
+      return { ...await lastValueFrom(
+        _action(this.#client.config(), this.#httpRequest, action, options)
+      ), releaseId, metadata };
+    }
+    /**
+     * @public
+     *
+     * Edits an existing release, updating the metadata.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to edit.
+     *   - `patch` - The patch operation to apply on the release metadata {@link PatchMutationOperation}.
+     * @param options - Additional action options.
+     * @returns A promise that resolves to the `transactionId`.
+     */
+    edit({ releaseId, patch }, options) {
+      const editAction = {
+        actionType: "sanity.action.release.edit",
+        releaseId,
+        patch
+      };
+      return lastValueFrom(_action(this.#client.config(), this.#httpRequest, editAction, options));
+    }
+    /**
+     * @public
+     *
+     * Publishes all documents in a release at once. For larger releases the effect of the publish
+     * will be visible immediately when querying but the removal of the `versions.<releasesId>.*`
+     * documents and creation of the corresponding published documents with the new content may
+     * take some time.
+     *
+     * During this period both the source and target documents are locked and cannot be
+     * modified through any other means.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to publish.
+     * @param options - Additional action options.
+     * @returns A promise that resolves to the `transactionId`.
+     */
+    publish({ releaseId }, options) {
+      const publishAction = {
+        actionType: "sanity.action.release.publish",
+        releaseId
+      };
+      return lastValueFrom(_action(this.#client.config(), this.#httpRequest, publishAction, options));
+    }
+    /**
+     * @public
+     *
+     * An archive action removes an active release. The documents that comprise the release
+     * are deleted and therefore no longer queryable.
+     *
+     * While the documents remain in retention the last version can still be accessed using document history endpoint.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to archive.
+     * @param options - Additional action options.
+     * @returns A promise that resolves to the `transactionId`.
+     */
+    archive({ releaseId }, options) {
+      const archiveAction = {
+        actionType: "sanity.action.release.archive",
+        releaseId
+      };
+      return lastValueFrom(_action(this.#client.config(), this.#httpRequest, archiveAction, options));
+    }
+    /**
+     * @public
+     *
+     * An unarchive action restores an archived release and all documents
+     * with the content they had just prior to archiving.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to unarchive.
+     * @param options - Additional action options.
+     * @returns A promise that resolves to the `transactionId`.
+     */
+    unarchive({ releaseId }, options) {
+      const unarchiveAction = {
+        actionType: "sanity.action.release.unarchive",
+        releaseId
+      };
+      return lastValueFrom(
+        _action(this.#client.config(), this.#httpRequest, unarchiveAction, options)
+      );
+    }
+    /**
+     * @public
+     *
+     * A schedule action queues a release for publishing at the given future time.
+     * The release is locked such that no documents in the release can be modified and
+     * no documents that it references can be deleted as this would make the publish fail.
+     * At the given time, the same logic as for the publish action is triggered.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to schedule.
+     *   - `publishAt` - The serialised date and time to publish the release. If the `publishAt` is in the past, the release will be published immediately.
+     * @param options - Additional action options.
+     * @returns A promise that resolves to the `transactionId`.
+     */
+    schedule({ releaseId, publishAt }, options) {
+      const scheduleAction = {
+        actionType: "sanity.action.release.schedule",
+        releaseId,
+        publishAt
+      };
+      return lastValueFrom(_action(this.#client.config(), this.#httpRequest, scheduleAction, options));
+    }
+    /**
+     * @public
+     *
+     * An unschedule action stops a release from being published.
+     * The documents in the release are considered unlocked and can be edited again.
+     * This may fail if another release is scheduled to be published after this one and
+     * has a reference to a document created by this one.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to unschedule.
+     * @param options - Additional action options.
+     * @returns A promise that resolves to the `transactionId`.
+     */
+    unschedule({ releaseId }, options) {
+      const unscheduleAction = {
+        actionType: "sanity.action.release.unschedule",
+        releaseId
+      };
+      return lastValueFrom(
+        _action(this.#client.config(), this.#httpRequest, unscheduleAction, options)
+      );
+    }
+    /**
+     * @public
+     *
+     * A delete action removes a published or archived release.
+     * The backing system document will be removed from the dataset.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to delete.
+     * @param options - Additional action options.
+     * @returns A promise that resolves to the `transactionId`.
+     */
+    delete({ releaseId }, options) {
+      const deleteAction = {
+        actionType: "sanity.action.release.delete",
+        releaseId
+      };
+      return lastValueFrom(_action(this.#client.config(), this.#httpRequest, deleteAction, options));
+    }
+    /**
+     * @public
+     *
+     * Fetch the documents in a release by release id.
+     *
+     * @category Releases
+     *
+     * @param params - Release action parameters:
+     *   - `releaseId` - The id of the release to fetch documents for.
+     * @param options - Additional mutation options {@link BaseMutationOptions}.
+     * @returns A promise that resolves to the documents in the release.
+     */
+    fetchDocuments({ releaseId }, options) {
+      return lastValueFrom(
+        _getReleaseDocuments(this.#client.config(), this.#httpRequest, releaseId, options)
       );
     }
   }
@@ -3363,9 +4129,13 @@ ${selectionOpts}`);
      */
     getById(id) {
       return lastValueFrom(
-        _request(this.#client.config(), this.#httpRequest, {
-          uri: `/users/${id}`
-        })
+        _request(
+          this.#client.config(),
+          this.#httpRequest,
+          {
+            uri: `/users/${id}`
+          }
+        )
       );
     }
   }
@@ -3376,6 +4146,7 @@ ${selectionOpts}`);
     projects;
     users;
     agent;
+    releases;
     /**
      * Private properties
      */
@@ -3388,7 +4159,7 @@ ${selectionOpts}`);
     constructor(httpRequest, config = defaultConfig) {
       this.config(config), this.#httpRequest = httpRequest, this.assets = new ObservableAssetsClient(this, this.#httpRequest), this.datasets = new ObservableDatasetsClient(this, this.#httpRequest), this.live = new LiveClient(this), this.projects = new ObservableProjectsClient(this, this.#httpRequest), this.users = new ObservableUsersClient(this, this.#httpRequest), this.agent = {
         action: new ObservableAgentsActionClient(this, this.#httpRequest)
-      };
+      }, this.releases = new ObservableReleasesClient(this, this.#httpRequest);
     }
     /**
      * Clone the client - returns a new instance
@@ -3453,17 +4224,132 @@ ${selectionOpts}`);
       return _getDocuments(this.#clientConfig, this.#httpRequest, ids, options);
     }
     create(document, options) {
-      return _create(this.#clientConfig, this.#httpRequest, document, "create", options);
+      return _create(
+        this.#clientConfig,
+        this.#httpRequest,
+        document,
+        "create",
+        options
+      );
     }
     createIfNotExists(document, options) {
-      return _createIfNotExists(this.#clientConfig, this.#httpRequest, document, options);
+      return _createIfNotExists(
+        this.#clientConfig,
+        this.#httpRequest,
+        document,
+        options
+      );
     }
     createOrReplace(document, options) {
       return _createOrReplace(this.#clientConfig, this.#httpRequest, document, options);
     }
+    createVersion({
+      document,
+      publishedId,
+      releaseId
+    }, options) {
+      const documentVersionId = deriveDocumentVersionId("createVersion", {
+        document,
+        publishedId,
+        releaseId
+      }), documentVersion = { ...document, _id: documentVersionId }, versionPublishedId = publishedId || getPublishedId$1(document._id);
+      return _createVersion(
+        this.config(),
+        this.#httpRequest,
+        documentVersion,
+        versionPublishedId,
+        options
+      );
+    }
     delete(selection, options) {
       return _delete(this.#clientConfig, this.#httpRequest, selection, options);
     }
+    /**
+     * @public
+     *
+     * Deletes the draft or release version of a document.
+     *
+     * @remarks
+     * * Discarding a version with no `releaseId` will discard the draft version of the published document.
+     * * If the draft or release version does not exist, any error will throw.
+     *
+     * @param params - Version action parameters:
+     *   - `releaseId` - The ID of the release to discard the document from.
+     *   - `publishedId` - The published ID of the document to discard.
+     * @param purge - if `true` the document history is also discarded.
+     * @param options - Additional action options.
+     * @returns an observable that resolves to the `transactionId`.
+     *
+     * @example Discarding a release version of a document
+     * ```ts
+     * client.observable.discardVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
+     * // The document with the ID `versions.myRelease.myDocument` will be discarded.
+     * ```
+     *
+     * @example Discarding a draft version of a document
+     * ```ts
+     * client.observable.discardVersion({publishedId: 'myDocument'})
+     * // The document with the ID `drafts.myDocument` will be discarded.
+     * ```
+     */
+    discardVersion({ releaseId, publishedId }, purge, options) {
+      const documentVersionId = getDocumentVersionId(publishedId, releaseId);
+      return _discardVersion(
+        this.config(),
+        this.#httpRequest,
+        documentVersionId,
+        purge,
+        options
+      );
+    }
+    replaceVersion({
+      document,
+      publishedId,
+      releaseId
+    }, options) {
+      const documentVersionId = deriveDocumentVersionId("replaceVersion", {
+        document,
+        publishedId,
+        releaseId
+      }), documentVersion = { ...document, _id: documentVersionId };
+      return _replaceVersion(
+        this.config(),
+        this.#httpRequest,
+        documentVersion,
+        options
+      );
+    }
+    /**
+     * @public
+     *
+     * Used to indicate when a document within a release should be unpublished when
+     * the release is run.
+     *
+     * @remarks
+     * * If the published document does not exist, an error will be thrown.
+     *
+     * @param params - Version action parameters:
+     *   - `releaseId` - The ID of the release to unpublish the document from.
+     *   - `publishedId` - The published ID of the document to unpublish.
+     * @param options - Additional action options.
+     * @returns an observable that resolves to the `transactionId`.
+     *
+     * @example Unpublishing a release version of a published document
+     * ```ts
+     * client.observable.unpublishVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
+     * // The document with the ID `versions.myRelease.myDocument` will be unpublished. when `myRelease` is run.
+     * ```
+     */
+    unpublishVersion({ releaseId, publishedId }, options) {
+      const versionId = getVersionId(publishedId, releaseId);
+      return _unpublishVersion(
+        this.config(),
+        this.#httpRequest,
+        versionId,
+        publishedId,
+        options
+      );
+    }
     mutate(operations, options) {
       return _mutate(this.#clientConfig, this.#httpRequest, operations, options);
     }
@@ -3528,6 +4414,7 @@ ${selectionOpts}`);
     projects;
     users;
     agent;
+    releases;
     /**
      * Observable version of the Sanity client, with the same configuration as the promise-based one
      */
@@ -3544,7 +4431,7 @@ ${selectionOpts}`);
     constructor(httpRequest, config = defaultConfig) {
       this.config(config), this.#httpRequest = httpRequest, this.assets = new AssetsClient(this, this.#httpRequest), this.datasets = new DatasetsClient(this, this.#httpRequest), this.live = new LiveClient(this), this.projects = new ProjectsClient(this, this.#httpRequest), this.users = new UsersClient(this, this.#httpRequest), this.agent = {
         action: new AgentActionsClient(this, this.#httpRequest)
-      }, this.observable = new ObservableSanityClient(httpRequest, config);
+      }, this.releases = new ReleasesClient(this, this.#httpRequest), this.observable = new ObservableSanityClient(httpRequest, config);
     }
     /**
      * Clone the client - returns a new instance
@@ -3596,7 +4483,9 @@ ${selectionOpts}`);
      * @param options - Request options
      */
     getDocument(id, options) {
-      return lastValueFrom(_getDocument(this.#clientConfig, this.#httpRequest, id, options));
+      return lastValueFrom(
+        _getDocument(this.#clientConfig, this.#httpRequest, id, options)
+      );
     }
     /**
      * Fetch multiple documents in one request.
@@ -3608,7 +4497,9 @@ ${selectionOpts}`);
      * @param options - Request options
      */
     getDocuments(ids, options) {
-      return lastValueFrom(_getDocuments(this.#clientConfig, this.#httpRequest, ids, options));
+      return lastValueFrom(
+        _getDocuments(this.#clientConfig, this.#httpRequest, ids, options)
+      );
     }
     create(document, options) {
       return lastValueFrom(
@@ -3625,11 +4516,122 @@ ${selectionOpts}`);
         _createOrReplace(this.#clientConfig, this.#httpRequest, document, options)
       );
     }
+    createVersion({
+      document,
+      publishedId,
+      releaseId
+    }, options) {
+      const documentVersionId = deriveDocumentVersionId("createVersion", {
+        document,
+        publishedId,
+        releaseId
+      }), documentVersion = { ...document, _id: documentVersionId }, versionPublishedId = publishedId || getPublishedId$1(document._id);
+      return firstValueFrom(
+        _createVersion(
+          this.config(),
+          this.#httpRequest,
+          documentVersion,
+          versionPublishedId,
+          options
+        )
+      );
+    }
     delete(selection, options) {
-      return lastValueFrom(_delete(this.#clientConfig, this.#httpRequest, selection, options));
+      return lastValueFrom(
+        _delete(this.#clientConfig, this.#httpRequest, selection, options)
+      );
+    }
+    /**
+     * @public
+     *
+     * Deletes the draft or release version of a document.
+     *
+     * @remarks
+     * * Discarding a version with no `releaseId` will discard the draft version of the published document.
+     * * If the draft or release version does not exist, any error will throw.
+     *
+     * @param params - Version action parameters:
+     *   - `releaseId` - The ID of the release to discard the document from.
+     *   - `publishedId` - The published ID of the document to discard.
+     * @param purge - if `true` the document history is also discarded.
+     * @param options - Additional action options.
+     * @returns a promise that resolves to the `transactionId`.
+     *
+     * @example Discarding a release version of a document
+     * ```ts
+     * client.discardVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
+     * // The document with the ID `versions.myRelease.myDocument` will be discarded.
+     * ```
+     *
+     * @example Discarding a draft version of a document
+     * ```ts
+     * client.discardVersion({publishedId: 'myDocument'})
+     * // The document with the ID `drafts.myDocument` will be discarded.
+     * ```
+     */
+    discardVersion({ releaseId, publishedId }, purge, options) {
+      const documentVersionId = getDocumentVersionId(publishedId, releaseId);
+      return lastValueFrom(
+        _discardVersion(
+          this.config(),
+          this.#httpRequest,
+          documentVersionId,
+          purge,
+          options
+        )
+      );
+    }
+    replaceVersion({
+      document,
+      publishedId,
+      releaseId
+    }, options) {
+      const documentVersionId = deriveDocumentVersionId("replaceVersion", {
+        document,
+        publishedId,
+        releaseId
+      }), documentVersion = { ...document, _id: documentVersionId };
+      return firstValueFrom(
+        _replaceVersion(this.config(), this.#httpRequest, documentVersion, options)
+      );
+    }
+    /**
+     * @public
+     *
+     * Used to indicate when a document within a release should be unpublished when
+     * the release is run.
+     *
+     * @remarks
+     * * If the published document does not exist, an error will be thrown.
+     *
+     * @param params - Version action parameters:
+     *   - `releaseId` - The ID of the release to unpublish the document from.
+     *   - `publishedId` - The published ID of the document to unpublish.
+     * @param options - Additional action options.
+     * @returns a promise that resolves to the `transactionId`.
+     *
+     * @example Unpublishing a release version of a published document
+     * ```ts
+     * await client.unpublishVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
+     * // The document with the ID `versions.myRelease.myDocument` will be unpublished. when `myRelease` is run.
+     * ```
+     */
+    unpublishVersion({ releaseId, publishedId }, options) {
+      const versionId = getVersionId(publishedId, releaseId);
+      return lastValueFrom(
+        _unpublishVersion(
+          this.config(),
+          this.#httpRequest,
+          versionId,
+          publishedId,
+          options
+        )
+      );
     }
     mutate(operations, options) {
-      return lastValueFrom(_mutate(this.#clientConfig, this.#httpRequest, operations, options));
+      return lastValueFrom(
+        _mutate(this.#clientConfig, this.#httpRequest, operations, options)
+      );
     }
     /**
      * Create a new buildable patch of operations to perform
@@ -3657,7 +4659,9 @@ ${selectionOpts}`);
      * @param options - Action options
      */
     action(operations, options) {
-      return lastValueFrom(_action(this.#clientConfig, this.#httpRequest, operations, options));
+      return lastValueFrom(
+        _action(this.#clientConfig, this.#httpRequest, operations, options)
+      );
     }
     /**
      * Perform a request against the Sanity API
@@ -3680,7 +4684,9 @@ ${selectionOpts}`);
      * @internal
      */
     dataRequest(endpoint, body, options) {
-      return lastValueFrom(_dataRequest(this.#clientConfig, this.#httpRequest, endpoint, body, options));
+      return lastValueFrom(
+        _dataRequest(this.#clientConfig, this.#httpRequest, endpoint, body, options)
+      );
     }
     /**
      * Get a Sanity API URL for the URI provided
@@ -3827,9 +4833,6 @@ ${selectionOpts}`);
   function isArray(value) {
     return value !== null && Array.isArray(value);
   }
-  function isRecord(value) {
-    return typeof value == "object" && value !== null;
-  }
   function walkMap(value, mappingFn, path = []) {
     if (isArray(value))
       return value.map((v, idx) => {
@@ -5175,9 +6178,12 @@ ${selectionOpts}`);
   exports.SanityClient = SanityClient;
   exports.ServerError = ServerError;
   exports.Transaction = Transaction;
+  exports.ViewResourceType = ViewResourceType;
   exports.connectEventSource = connectEventSource;
   exports.createClient = createClient;
   exports.default = deprecatedCreateClient;
+  exports.formatQueryParseError = formatQueryParseError;
+  exports.isQueryParseError = isQueryParseError;
   exports.requester = requester;
   exports.unstable__adapter = c$2;
   exports.unstable__environment = f$1;