@sanity/client 7.1.0 → 7.2.0

package/dist/stega.browser.d.ts

@@ -13,6 +13,8 @@ export declare type Action =
   | DiscardAction
   | PublishAction
   | UnpublishAction
+  | VersionAction
+  | ReleaseAction
 
 /** @internal */
 export declare interface ActionError {
@@ -314,6 +316,16 @@ export declare interface ApiError {
   statusCode: number
 }
 
+/**
+ * Archives an `active` release, and deletes all the release documents.
+ *
+ * @public
+ */
+export declare interface ArchiveReleaseAction {
+  actionType: 'sanity.action.release.archive'
+  releaseId: string
+}
+
 /** @public */
 export declare type AssetMetadataType =
   | 'location'
@@ -986,6 +998,29 @@ export declare type CreateAction = {
  */
 export declare const createClient: (config: ClientConfig_2) => SanityClient
 
+/**
+ * Creates a new release under the given id, with metadata.
+ *
+ * @public
+ */
+export declare interface CreateReleaseAction {
+  actionType: 'sanity.action.release.create'
+  releaseId: string
+  metadata?: Partial<ReleaseDocument['metadata']>
+}
+
+/**
+ * Creates a new version of an existing document, attached to the release as given
+ * by `document._id`
+ *
+ * @public
+ */
+export declare interface CreateVersionAction {
+  actionType: 'sanity.action.document.version.create'
+  publishedId: string
+  document: IdentifiedSanityDocumentStub
+}
+
 /** @public */
 export declare interface CurrentSanityUser {
   id: string
@@ -1081,6 +1116,16 @@ export declare type DeleteAction = {
   purge?: boolean
 }
 
+/**
+ * Deletes a `archived` or `published` release, and all the release documents versions.
+ *
+ * @public
+ */
+export declare interface DeleteReleaseAction {
+  actionType: 'sanity.action.release.delete'
+  releaseId: string
+}
+
 /**
  * @deprecated use 'drafts' instead
  */
@@ -1091,6 +1136,7 @@ declare type DeprecatedPreviewDrafts = 'previewDrafts'
  * It is an error if it does not exist. If the purge flag is set, the document history is also deleted.
  *
  * @public
+ * @deprecated Use {@link DiscardVersionAction} instead
  */
 export declare type DiscardAction = {
   actionType: 'sanity.action.document.discard'
@@ -1104,6 +1150,17 @@ export declare type DiscardAction = {
   purge?: boolean
 }
 
+/**
+ * Delete a version of a document.
+ *
+ * @public
+ */
+export declare interface DiscardVersionAction {
+  actionType: 'sanity.action.document.version.discard'
+  versionId: string
+  purge?: boolean
+}
+
 /**
  * The listener has been told to explicitly disconnect.
  *  This is a rare situation, but may occur if the API knows reconnect attempts will fail,
@@ -1158,6 +1215,15 @@ export declare interface DocumentAgentActionParam {
   documentId?: string
 }
 
+/** @internal */
+export declare type EditableReleaseDocument = Omit<
+  PartialExcept<ReleaseDocument, '_id'>,
+  'metadata' | '_type'
+> & {
+  _id: string
+  metadata: Partial<ReleaseDocument['metadata']>
+}
+
 /**
  * Modifies an existing draft document.
  * It applies the given patch to the document referenced by draftId.
@@ -1181,6 +1247,17 @@ export declare type EditAction = {
   patch: PatchOperations
 }
 
+/**
+ * Edits an existing release, updating the metadata.
+ *
+ * @public
+ */
+export declare interface EditReleaseAction {
+  actionType: 'sanity.action.release.edit'
+  releaseId: string
+  patch: PatchOperations
+}
+
 /**
  * @internal
  */
@@ -2291,6 +2368,306 @@ export declare class ObservableProjectsClient {
   getById(projectId: string): Observable<SanityProject>
 }
 
+/** @public */
+declare class ObservableReleasesClient {
+  #private
+  constructor(client: ObservableSanityClient, 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,
+    }: {
+      releaseId: string
+    },
+    options?: {
+      signal?: AbortSignal
+      tag?: string
+    },
+  ): Observable<ReleaseDocument | undefined>
+  /**
+   * @public
+   *
+   * Creates a new release under the given id, with metadata.
+   *
+   * @remarks
+   * * If no releaseId is provided, a release id will be generated.
+   * * If no metadata is provided, then an `undecided` releaseType will be used.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to create.
+   *   - `metadata` - The metadata to associate with the release {@link ReleaseDocument}.
+   * @param options - Additional action options.
+   * @returns An observable that resolves to the `transactionId` and the release id and metadata.
+   *
+   * @example Creating a release with a custom id and metadata
+   * ```ts
+   * const releaseId = 'my-release'
+   * const metadata: ReleaseDocument['metadata'] = {
+   *   releaseType: 'asap',
+   * }
+   *
+   * client.observable.releases.create({releaseId, metadata}).pipe(
+   *   tap(({transactionId, releaseId, metadata}) => console.log(transactionId, releaseId, metadata)),
+   *   // {
+   *   //   transactionId: 'transaction-id',
+   *   //   releaseId: 'my-release',
+   *   //   metadata: {releaseType: 'asap'},
+   *   // }
+   * ).subscribe()
+   * ```
+   *
+   * @example Creating a release with generated id and metadata
+   * ```ts
+   * client.observable.releases.create().pipe(
+   *   tap(({metadata}) => console.log(metadata)),
+   *   // {
+   *   //   metadata: {releaseType: 'undecided'},
+   *   // }
+   * ).subscribe()
+   * ```
+   *
+   * @example Creating a release using a custom transaction id
+   * ```ts
+   * client.observable.releases.create({transactionId: 'my-transaction-id'}).pipe(
+   *   tap(({transactionId, metadata}) => console.log(transactionId, metadata)),
+   *   // {
+   *   //   transactionId: 'my-transaction-id',
+   *   //   metadata: {releaseType: 'undecided'},
+   *   // }
+   * ).subscribe()
+   * ```
+   */
+  create(options: BaseActionOptions): Observable<
+    SingleActionResult & {
+      releaseId: string
+      metadata: ReleaseDocument['metadata']
+    }
+  >
+  create(
+    release: {
+      releaseId?: string
+      metadata?: Partial<ReleaseDocument['metadata']>
+    },
+    options?: BaseActionOptions,
+  ): Observable<
+    SingleActionResult & {
+      releaseId: string
+      metadata: ReleaseDocument['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,
+    }: {
+      releaseId: string
+      patch: PatchOperations
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+      publishAt: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+    },
+    options?: BaseMutationOptions,
+  ): Observable<RawQueryResponse<SanityDocument[]>>
+}
+
 /** @public */
 export declare class ObservableSanityClient {
   #private
@@ -2302,6 +2679,7 @@ export declare class ObservableSanityClient {
   agent: {
     action: ObservableAgentsActionClient
   }
+  releases: ObservableReleasesClient
   /**
    * Instance properties
    */
@@ -2392,7 +2770,9 @@ export declare class ObservableSanityClient {
   getDocument<R extends Record<string, Any> = Record<string, Any>>(
     id: string,
     options?: {
+      signal?: AbortSignal
       tag?: string
+      releaseId?: string
     },
   ): Observable<SanityDocument<R> | undefined>
   /**
@@ -2575,6 +2955,90 @@ export declare class ObservableSanityClient {
     document: IdentifiedSanityDocumentStub<R>,
     options?: BaseMutationOptions,
   ): Observable<SanityDocument<R>>
+  /**
+   * @public
+   *
+   * Creates a new version of a published document.
+   *
+   * @remarks
+   * * Requires a document with a `_type` property.
+   * * Creating a version with no `releaseId` will create a new draft version of the published document.
+   * * If the `document._id` is defined, it should be a draft or release version ID that matches the version ID generated from `publishedId` and `releaseId`.
+   * * If the `document._id` is not defined, it will be generated from `publishedId` and `releaseId`.
+   * * To create a version of an unpublished document, use the `client.create` method.
+   *
+   * @category Versions
+   *
+   * @param params - Version action parameters:
+   *   - `document` - The document to create as a new version (must include `_type`).
+   *   - `publishedId` - The ID of the published document being versioned.
+   *   - `releaseId` - The ID of the release to create the version for.
+   * @param options - Additional action options.
+   * @returns an observable that resolves to the `transactionId`.
+   *
+   * @example Creating a new version of a published document with a generated version ID
+   * ```ts
+   * client.observable.createVersion({
+   *   // The document does not need to include an `_id` property since it will be generated from `publishedId` and `releaseId`
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   *   releaseId: 'myRelease',
+   * })
+   *
+   * // The following document will be created:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Creating a new version of a published document with a specified version ID
+   * ```ts
+   * client.observable.createVersion({
+   *   document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
+   *   // `publishedId` and `releaseId` are not required since `document._id` has been specified
+   * })
+   *
+   * // The following document will be created:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Creating a new draft version of a published document
+   * ```ts
+   * client.observable.createVersion({
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   * })
+   *
+   * // The following document will be created:
+   * // {
+   * //   _id: 'drafts.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   */
+  createVersion<R extends Record<string, Any>>(
+    args: {
+      document: SanityDocumentStub<R>
+      publishedId: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
+  createVersion<R extends Record<string, Any>>(
+    args: {
+      document: IdentifiedSanityDocumentStub<R>
+      publishedId?: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
   /**
    * Deletes a document with the given document ID.
    * Returns an observable that resolves to the deleted document.
@@ -2679,6 +3143,157 @@ export declare class ObservableSanityClient {
     selection: MutationSelection,
     options?: BaseMutationOptions,
   ): Observable<SanityDocument<R>>
+  /**
+   * @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,
+    }: {
+      releaseId?: string
+      publishedId: string
+    },
+    purge?: boolean,
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
+  /**
+   * @public
+   *
+   * Replaces an existing version document.
+   *
+   * @remarks
+   * * Requires a document with a `_type` property.
+   * * If the `document._id` is defined, it should be a draft or release version ID that matches the version ID generated from `publishedId` and `releaseId`.
+   * * If the `document._id` is not defined, it will be generated from `publishedId` and `releaseId`.
+   * * Replacing a version with no `releaseId` will replace the draft version of the published document.
+   * * At least one of the **version** or **published** documents must exist.
+   *
+   * @param params - Version action parameters:
+   *   - `document` - The new document to replace the version with.
+   *   - `releaseId` - The ID of the release where the document version is replaced.
+   *   - `publishedId` - The ID of the published document to replace.
+   * @param options - Additional action options.
+   * @returns an observable that resolves to the `transactionId`.
+   *
+   * @example Replacing a release version of a published document with a generated version ID
+   * ```ts
+   * client.observable.replaceVersion({
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   *   releaseId: 'myRelease',
+   * })
+   *
+   * // The following document will be patched:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Replacing a release version of a published document with a specified version ID
+   * ```ts
+   * client.observable.replaceVersion({
+   *   document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
+   *   // `publishedId` and `releaseId` are not required since `document._id` has been specified
+   * })
+   *
+   * // The following document will be patched:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Replacing a draft version of a published document
+   * ```ts
+   * client.observable.replaceVersion({
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   * })
+   *
+   * // The following document will be patched:
+   * // {
+   * //   _id: 'drafts.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   */
+  replaceVersion<R extends Record<string, Any>>(
+    args: {
+      document: SanityDocumentStub<R>
+      publishedId: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
+  replaceVersion<R extends Record<string, Any>>(
+    args: {
+      document: IdentifiedSanityDocumentStub<R>
+      publishedId?: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+      publishedId: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
   /**
    * Perform mutation operations against the configured dataset
    * Returns an observable that resolves to the first mutated document.
@@ -2886,6 +3501,9 @@ export declare type OpenEvent = {
   type: 'open'
 }
 
+/** @internal */
+export declare type PartialExcept<T, K extends keyof T> = Pick<T, K> & Partial<Omit<T, K>>
+
 /** @public */
 export declare class Patch extends BasePatch {
   #private
@@ -3023,6 +3641,16 @@ export declare type PublishAction = {
   ifPublishedRevisionId?: string
 }
 
+/**
+ * Publishes all documents in a release at once.
+ *
+ * @public
+ */
+export declare interface PublishReleaseAction {
+  actionType: 'sanity.action.release.publish'
+  releaseId: string
+}
+
 /** @public */
 export declare type QueryOptions =
   | FilteredResponseQueryOptions
@@ -3121,17 +3749,373 @@ export declare type ReconnectEvent = {
   type: 'reconnect'
 }
 
+/** @public */
+export declare type ReleaseAction =
+  | CreateReleaseAction
+  | EditReleaseAction
+  | PublishReleaseAction
+  | ArchiveReleaseAction
+  | UnarchiveReleaseAction
+  | ScheduleReleaseAction
+  | UnscheduleReleaseAction
+  | DeleteReleaseAction
+
+/** @internal */
+export declare interface ReleaseDocument extends SanityDocument {
+  /**
+   * typically
+   * `_.releases.<name>`
+   */
+  _id: string
+  /**
+   * where a release has _id `_.releases.foo`, the name is `foo`
+   */
+  name: string
+  _type: 'system.release'
+  _createdAt: string
+  _updatedAt: string
+  _rev: string
+  state: ReleaseState
+  error?: {
+    message: string
+  }
+  finalDocumentStates?: {
+    /** Document ID */
+    id: string
+  }[]
+  /**
+   * If defined, it takes precedence over the intendedPublishAt, the state should be 'scheduled'
+   */
+  publishAt?: string
+  /**
+   * If defined, it provides the time the release was actually published
+   */
+  publishedAt?: string
+  metadata: {
+    title?: string
+    description?: string
+    intendedPublishAt?: string
+    releaseType: ReleaseType
+  }
+}
+
 /**
  * @public
  * @deprecated – The `r`-prefix is not required, use `string` instead
  */
 export declare type ReleaseId = `r${string}`
 
+/** @public */
+declare class ReleasesClient {
+  #private
+  constructor(client: SanityClient, 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,
+    }: {
+      releaseId: string
+    },
+    options?: {
+      signal?: AbortSignal
+      tag?: string
+    },
+  ): Promise<ReleaseDocument | undefined>
+  /**
+   * @public
+   *
+   * Creates a new release under the given id, with metadata.
+   *
+   * @remarks
+   * * If no releaseId is provided, a release id will be generated.
+   * * If no metadata is provided, then an `undecided` releaseType will be used.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to create.
+   *   - `metadata` - The metadata to associate with the release {@link ReleaseDocument}.
+   * @param options - Additional action options.
+   * @returns A promise that resolves to the `transactionId` and the release id and metadata.
+   *
+   * @example Creating a release with a custom id and metadata
+   * ```ts
+   * const releaseId = 'my-release'
+   * const releaseMetadata: ReleaseDocument['metadata'] = {
+   *   releaseType: 'asap',
+   * }
+   *
+   * const result =
+   *   await client.releases.create({releaseId, metadata: releaseMetadata})
+   * console.log(result)
+   * // {
+   * //   transactionId: 'transaction-id',
+   * //   releaseId: 'my-release',
+   * //   metadata: {releaseType: 'asap'},
+   * // }
+   * ```
+   *
+   * @example Creating a release with generated id and metadata
+   * ```ts
+   * const {metadata} = await client.releases.create()
+   * console.log(metadata.releaseType) // 'undecided'
+   * ```
+   *
+   * @example Creating a release with a custom transaction id
+   * ```ts
+   * const {transactionId, metadata} = await client.releases.create({transactionId: 'my-transaction-id'})
+   * console.log(metadata.releaseType) // 'undecided'
+   * console.log(transactionId) // 'my-transaction-id'
+   * ```
+   */
+  create(options: BaseActionOptions): Promise<
+    SingleActionResult & {
+      releaseId: string
+      metadata: ReleaseDocument['metadata']
+    }
+  >
+  create(
+    release: {
+      releaseId?: string
+      metadata?: Partial<ReleaseDocument['metadata']>
+    },
+    options?: BaseActionOptions,
+  ): Promise<
+    SingleActionResult & {
+      releaseId: string
+      metadata: ReleaseDocument['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,
+    }: {
+      releaseId: string
+      patch: PatchOperations
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+      publishAt: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+    },
+    options?: BaseMutationOptions,
+  ): Promise<RawQueryResponse<SanityDocument[]>>
+}
+
+/** @beta */
+export declare type ReleaseState =
+  | 'active'
+  | 'archiving'
+  | 'unarchiving'
+  | 'archived'
+  | 'published'
+  | 'publishing'
+  | 'scheduled'
+  | 'scheduling'
+
+/** @internal */
+export declare type ReleaseType = 'asap' | 'scheduled' | 'undecided'
+
 /**
  * Replaces an existing draft document.
  * At least one of the draft or published versions of the document must exist.
  *
  * @public
+ * @deprecated Use {@link ReplaceVersionAction} instead
  */
 export declare type ReplaceDraftAction = {
   actionType: 'sanity.action.document.replaceDraft'
@@ -3145,6 +4129,16 @@ export declare type ReplaceDraftAction = {
   attributes: IdentifiedSanityDocumentStub
 }
 
+/**
+ * Replace an existing version of a document.
+ *
+ * @public
+ */
+export declare interface ReplaceVersionAction {
+  actionType: 'sanity.action.document.version.replace'
+  document: IdentifiedSanityDocumentStub
+}
+
 /**
  * @deprecated -- Use `import {requester} from '@sanity/client'` instead
  * @public
@@ -3236,6 +4230,7 @@ export declare class SanityClient {
   agent: {
     action: AgentActionsClient
   }
+  releases: ReleasesClient
   /**
    * Observable version of the Sanity client, with the same configuration as the promise-based one
    */
@@ -3332,6 +4327,7 @@ export declare class SanityClient {
     options?: {
       signal?: AbortSignal
       tag?: string
+      releaseId?: string
     },
   ): Promise<SanityDocument<R> | undefined>
   /**
@@ -3515,6 +4511,90 @@ export declare class SanityClient {
     document: IdentifiedSanityDocumentStub<R>,
     options?: BaseMutationOptions,
   ): Promise<SanityDocument<R>>
+  /**
+   * @public
+   *
+   * Creates a new version of a published document.
+   *
+   * @remarks
+   * * Requires a document with a `_type` property.
+   * * Creating a version with no `releaseId` will create a new draft version of the published document.
+   * * If the `document._id` is defined, it should be a draft or release version ID that matches the version ID generated from `publishedId` and `releaseId`.
+   * * If the `document._id` is not defined, it will be generated from `publishedId` and `releaseId`.
+   * * To create a version of an unpublished document, use the `client.create` method.
+   *
+   * @category Versions
+   *
+   * @param params - Version action parameters:
+   *   - `document` - The document to create as a new version (must include `_type`).
+   *   - `publishedId` - The ID of the published document being versioned.
+   *   - `releaseId` - The ID of the release to create the version for.
+   * @param options - Additional action options.
+   * @returns A promise that resolves to the `transactionId`.
+   *
+   * @example Creating a new version of a published document with a generated version ID
+   * ```ts
+   * const transactionId = await client.createVersion({
+   *   // The document does not need to include an `_id` property since it will be generated from `publishedId` and `releaseId`
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   *   releaseId: 'myRelease',
+   * })
+   *
+   * // The following document will be created:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Creating a new version of a published document with a specified version ID
+   * ```ts
+   * const transactionId = await client.createVersion({
+   *   document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
+   *   // `publishedId` and `releaseId` are not required since `document._id` has been specified
+   * })
+   *
+   * // The following document will be created:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Creating a new draft version of a published document
+   * ```ts
+   * const transactionId = await client.createVersion({
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   * })
+   *
+   * // The following document will be created:
+   * // {
+   * //   _id: 'drafts.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   */
+  createVersion<R extends Record<string, Any>>(
+    args: {
+      document: SanityDocumentStub<R>
+      publishedId: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
+  createVersion<R extends Record<string, Any>>(
+    args: {
+      document: IdentifiedSanityDocumentStub<R>
+      publishedId?: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
   /**
    * Deletes a document with the given document ID.
    * Returns a promise that resolves to the deleted document.
@@ -3619,6 +4699,157 @@ export declare class SanityClient {
     selection: MutationSelection,
     options?: BaseMutationOptions,
   ): Promise<SanityDocument<R>>
+  /**
+   * @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,
+    }: {
+      releaseId?: string
+      publishedId: string
+    },
+    purge?: boolean,
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
+  /**
+   * @public
+   *
+   * Replaces an existing version document.
+   *
+   * @remarks
+   * * Requires a document with a `_type` property.
+   * * If the `document._id` is defined, it should be a draft or release version ID that matches the version ID generated from `publishedId` and `releaseId`.
+   * * If the `document._id` is not defined, it will be generated from `publishedId` and `releaseId`.
+   * * Replacing a version with no `releaseId` will replace the draft version of the published document.
+   * * At least one of the **version** or **published** documents must exist.
+   *
+   * @param params - Version action parameters:
+   *   - `document` - The new document to replace the version with.
+   *   - `releaseId` - The ID of the release where the document version is replaced.
+   *   - `publishedId` - The ID of the published document to replace.
+   * @param options - Additional action options.
+   * @returns a promise that resolves to the `transactionId`.
+   *
+   * @example Replacing a release version of a published document with a generated version ID
+   * ```ts
+   * await client.replaceVersion({
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   *   releaseId: 'myRelease',
+   * })
+   *
+   * // The following document will be patched:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Replacing a release version of a published document with a specified version ID
+   * ```ts
+   * await client.replaceVersion({
+   *   document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
+   *   // `publishedId` and `releaseId` are not required since `document._id` has been specified
+   * })
+   *
+   * // The following document will be patched:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Replacing a draft version of a published document
+   * ```ts
+   * await client.replaceVersion({
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   * })
+   *
+   * // The following document will be patched:
+   * // {
+   * //   _id: 'drafts.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   */
+  replaceVersion<R extends Record<string, Any>>(
+    args: {
+      document: SanityDocumentStub<R>
+      publishedId: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
+  replaceVersion<R extends Record<string, Any>>(
+    args: {
+      document: IdentifiedSanityDocumentStub<R>
+      publishedId?: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
+  /**
+   * @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,
+    }: {
+      releaseId: string
+      publishedId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
   /**
    * Perform mutation operations against the configured dataset
    * Returns a promise that resolves to the first mutated document.
@@ -3659,7 +4890,7 @@ export declare class SanityClient {
    * @param operations - Mutation operations to execute
    * @param options - Mutation options
    */
-  mutate<R extends Record<string, Any>>(
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
     operations: Mutation<R>[] | Patch | Transaction,
     options: AllDocumentIdsMutationOptions,
   ): Promise<MultipleMutationResult>
@@ -3881,6 +5112,17 @@ export declare interface SanityUser {
   isCurrentUser: boolean
 }
 
+/**
+ * Queues release for publishing at the given future time.
+ *
+ * @public
+ */
+export declare interface ScheduleReleaseAction {
+  actionType: 'sanity.action.release.schedule'
+  releaseId: string
+  publishAt: string
+}
+
 /** @public */
 export declare class ServerError extends Error {
   response: ErrorProps['response']
@@ -4422,6 +5664,16 @@ export declare interface TranslateTargetInclude extends AgentActionTargetInclude
   include?: (AgentActionPathSegment | TranslateTargetInclude)[]
 }
 
+/**
+ * Unarchived an `archived` release, and restores all the release documents.
+ *
+ * @public
+ */
+export declare interface UnarchiveReleaseAction {
+  actionType: 'sanity.action.release.unarchive'
+  releaseId: string
+}
+
 /** @public */
 export declare interface UnfilteredResponseQueryOptions extends ResponseQueryOptions {
   filterResponse: false
@@ -4463,6 +5715,28 @@ export declare type UnpublishAction = {
   publishedId: string
 }
 
+/**
+ * Identify that a version of a document should be unpublished when
+ * the release that version is contained within is published.
+ *
+ * @public
+ */
+export declare interface UnpublishVersionAction {
+  actionType: 'sanity.action.document.version.unpublish'
+  versionId: string
+  publishedId: string
+}
+
+/**
+ * Unschedules a `scheduled` release, stopping it from being published.
+ *
+ * @public
+ */
+export declare interface UnscheduleReleaseAction {
+  actionType: 'sanity.action.release.unschedule'
+  releaseId: string
+}
+
 export {unstable__adapter}
 
 export {unstable__environment}
@@ -4558,6 +5832,13 @@ export declare function validateApiPerspective(
  */
 export declare const vercelStegaCleanAll: typeof stegaClean
 
+/** @public */
+export declare type VersionAction =
+  | CreateVersionAction
+  | DiscardVersionAction
+  | ReplaceVersionAction
+  | UnpublishVersionAction
+
 /**
  * The listener has been established, and will start receiving events.
  * Note that this is also emitted upon _reconnection_.