@sanity/client 7.1.0 → 7.2.1

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);
   }
@@ -1912,6 +1930,53 @@
     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;
+  }
+
+  let random = bytes => crypto.getRandomValues(new Uint8Array(bytes));
+  let customRandom = (alphabet, defaultSize, getRandom) => {
+    let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1;
+    let step = -~((1.6 * mask * defaultSize) / alphabet.length);
+    return (size = defaultSize) => {
+      let id = '';
+      while (true) {
+        let bytes = getRandom(step);
+        let j = step | 0;
+        while (j--) {
+          id += alphabet[bytes[j] & mask] || '';
+          if (id.length === size) return id
+        }
+      }
+    }
+  };
+  let customAlphabet = (alphabet, size = 21) =>
+    customRandom(alphabet, size, random);
+
   class ClientError extends Error {
     response;
     statusCode = 400;
@@ -2043,6 +2108,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) {
@@ -2684,8 +2761,24 @@ ${selectionOpts}`);
     ) : $request.pipe(map(mapResponse));
   }
   function _getDocument(client, httpRequest, id, opts = {}) {
-    const options = {
-      uri: _getDataUrl(client, "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(client, "doc", docId),
       json: true,
       tag: opts.tag,
       signal: opts.signal
@@ -2710,12 +2803,33 @@ ${selectionOpts}`);
       })
     );
   }
+  function _getReleaseDocuments(client, httpRequest, releaseId, opts = {}) {
+    return _dataRequest(
+      client,
+      httpRequest,
+      "query",
+      {
+        query: "*[sanity::partOfRelease($releaseId)]",
+        params: {
+          releaseId
+        }
+      },
+      opts
+    );
+  }
   function _createIfNotExists(client, httpRequest, doc, options) {
     return requireDocumentId("createIfNotExists", doc), _create(client, httpRequest, doc, "createIfNotExists", options);
   }
   function _createOrReplace(client, httpRequest, doc, options) {
     return requireDocumentId("createOrReplace", doc), _create(client, httpRequest, doc, "createOrReplace", options);
   }
+  function _createVersion(client, httpRequest, doc, publishedId, options) {
+    return requireDocumentId("createVersion", doc), requireDocumentType("createVersion", doc), _action(client, httpRequest, {
+      actionType: "sanity.action.document.version.create",
+      publishedId,
+      document: doc
+    }, options);
+  }
   function _delete(client, httpRequest, selection, options) {
     return _dataRequest(
       client,
@@ -2725,6 +2839,26 @@ ${selectionOpts}`);
       options
     );
   }
+  function _discardVersion(client, httpRequest, versionId, purge = false, options) {
+    return _action(client, httpRequest, {
+      actionType: "sanity.action.document.version.discard",
+      versionId,
+      purge
+    }, options);
+  }
+  function _replaceVersion(client, httpRequest, doc, options) {
+    return requireDocumentId("replaceVersion", doc), requireDocumentType("replaceVersion", doc), _action(client, httpRequest, {
+      actionType: "sanity.action.document.version.replace",
+      document: doc
+    }, options);
+  }
+  function _unpublishVersion(client, httpRequest, versionId, publishedId, options) {
+    return _action(client, httpRequest, {
+      actionType: "sanity.action.document.version.unpublish",
+      versionId,
+      publishedId
+    }, options);
+  }
   function _mutate(client, 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;
@@ -3327,6 +3461,498 @@ ${selectionOpts}`);
       );
     }
   }
+  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,
+        this.#httpRequest,
+        `_.releases.${releaseId}`,
+        options
+      );
+    }
+    create(releaseOrOptions, maybeOptions) {
+      const { action, options } = createRelease(releaseOrOptions, maybeOptions), { releaseId, metadata } = action;
+      return _action(this.#client, 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, 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, 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, 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, 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, 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, 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, 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, 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,
+          this.#httpRequest,
+          `_.releases.${releaseId}`,
+          options
+        )
+      );
+    }
+    async create(releaseOrOptions, maybeOptions) {
+      const { action, options } = createRelease(releaseOrOptions, maybeOptions), { releaseId, metadata } = action;
+      return { ...await lastValueFrom(
+        _action(this.#client, 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, 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, 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, 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, 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, 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, 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, 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, this.#httpRequest, releaseId, options));
+    }
+  }
   class ObservableUsersClient {
     #client;
     #httpRequest;
@@ -3372,6 +3998,7 @@ ${selectionOpts}`);
     projects;
     users;
     agent;
+    releases;
     /**
      * Private properties
      */
@@ -3384,7 +4011,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
@@ -3457,9 +4084,96 @@ ${selectionOpts}`);
     createOrReplace(document, options) {
       return _createOrReplace(this, 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,
+        this.#httpRequest,
+        documentVersion,
+        versionPublishedId,
+        options
+      );
+    }
     delete(selection, options) {
       return _delete(this, 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, this.#httpRequest, documentVersionId, purge, options);
+    }
+    replaceVersion({
+      document,
+      publishedId,
+      releaseId
+    }, options) {
+      const documentVersionId = deriveDocumentVersionId("replaceVersion", {
+        document,
+        publishedId,
+        releaseId
+      }), documentVersion = { ...document, _id: documentVersionId };
+      return _replaceVersion(this, 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, this.#httpRequest, versionId, publishedId, options);
+    }
     mutate(operations, options) {
       return _mutate(this, this.#httpRequest, operations, options);
     }
@@ -3524,6 +4238,7 @@ ${selectionOpts}`);
     projects;
     users;
     agent;
+    releases;
     /**
      * Observable version of the Sanity client, with the same configuration as the promise-based one
      */
@@ -3540,7 +4255,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
@@ -3621,9 +4336,104 @@ ${selectionOpts}`);
         _createOrReplace(this, 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,
+          this.#httpRequest,
+          documentVersion,
+          versionPublishedId,
+          options
+        )
+      );
+    }
     delete(selection, options) {
       return lastValueFrom(_delete(this, 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, 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, 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, this.#httpRequest, versionId, publishedId, options)
+      );
+    }
     mutate(operations, options) {
       return lastValueFrom(_mutate(this, this.#httpRequest, operations, options));
     }