@sanity/client 7.1.0 → 7.2.1-agent-actions.0

package/dist/index.d.ts

@@ -19,6 +19,8 @@ export declare type Action =
   | DiscardAction
   | PublishAction
   | UnpublishAction
+  | VersionAction
+  | ReleaseAction
 
 /** @internal */
 export declare interface ActionError {
@@ -53,15 +55,27 @@ declare interface AgentActionAsync {
 }
 
 /** @beta */
-export declare type AgentActionParam =
+export declare type AgentActionParam<
+  TParamConfig extends {
+    docIdRequired: boolean
+  } = {
+    docIdRequired: false
+  },
+> =
   | string
   | ConstantAgentActionParam
-  | FieldAgentActionParam
-  | DocumentAgentActionParam
+  | FieldAgentActionParam<TParamConfig>
+  | DocumentAgentActionParam<TParamConfig>
   | GroqAgentActionParam
 
 /** @beta */
-export declare type AgentActionParams = Record<string, AgentActionParam>
+export declare type AgentActionParams<
+  TParamConfig extends {
+    docIdRequired: boolean
+  } = {
+    docIdRequired: false
+  },
+> = Record<string, AgentActionParam<TParamConfig>>
 
 /**  @beta */
 export declare type AgentActionPath = AgentActionPathSegment[]
@@ -190,6 +204,13 @@ declare class AgentActionsClient {
         }
       : IdentifiedSanityDocumentStub & DocumentShape
   >
+  /**
+   * Run a raw instruction and return the result either as text or json
+   * @param request - prompt request
+   */
+  prompt<DocumentShape extends Record<string, Any>>(
+    request: PromptRequest<DocumentShape>,
+  ): Promise<(typeof request)['json'] extends true ? DocumentShape : string>
 }
 
 /** @beta */
@@ -320,6 +341,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'
@@ -891,6 +922,29 @@ export declare type CreateAction = {
  */
 export declare const createClient: (config: ClientConfig) => 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
@@ -986,6 +1040,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
+}
+
 /**
  * @public
  * @deprecated Use the named export `createClient` instead of the `default` export
@@ -1003,6 +1067,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'
@@ -1016,6 +1081,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,
@@ -1042,6 +1118,23 @@ export declare type DisconnectEvent = {
   reason: string
 }
 
+declare type DocIdParam<
+  TParamConfig extends {
+    docIdRequired: boolean
+  } = {
+    docIdRequired: false
+  },
+> = TParamConfig['docIdRequired'] extends true
+  ? {
+      documentId: string
+    }
+  : {
+      /**
+       * If omitted, implicitly uses the documentId of the instruction target
+       */
+      documentId?: string
+    }
+
 /**
  *
  * Includes a LLM-friendly version of the document in the instruction
@@ -1062,12 +1155,23 @@ export declare type DisconnectEvent = {
  *
  * @beta
  * */
-export declare interface DocumentAgentActionParam {
+export declare type DocumentAgentActionParam<
+  TParamConfig extends {
+    docIdRequired: boolean
+  } = {
+    docIdRequired: false
+  },
+> = {
   type: 'document'
-  /**
-   * If omitted, implicitly uses the documentId of the instruction target
-   */
-  documentId?: string
+} & DocIdParam<TParamConfig>
+
+/** @internal */
+export declare type EditableReleaseDocument = Omit<
+  PartialExcept<ReleaseDocument, '_id'>,
+  'metadata' | '_type'
+> & {
+  _id: string
+  metadata: Partial<ReleaseDocument['metadata']>
 }
 
 /**
@@ -1093,6 +1197,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
+}
+
 /** @public */
 export declare interface ErrorProps {
   message: string
@@ -1135,17 +1250,19 @@ export declare type EventSourceInstance = InstanceType<typeof globalThis.EventSo
  *
  * @beta
  * */
-export declare interface FieldAgentActionParam {
+export declare type FieldAgentActionParam<
+  TParamConfig extends {
+    docIdRequired: boolean
+  } = {
+    docIdRequired: false
+  },
+> = {
   type: 'field'
   /**
    * Examples: 'title', ['array', \{_key: 'arrayItemKey'\}, 'field']
    */
   path: AgentActionPathSegment | AgentActionPath
-  /**
-   * If omitted, implicitly uses the documentId of the instruction target
-   */
-  documentId?: string
-}
+} & DocIdParam<TParamConfig>
 
 /** @public */
 export declare type FilterDefault = (props: {
@@ -2118,6 +2235,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
@@ -2129,6 +2546,7 @@ export declare class ObservableSanityClient {
   agent: {
     action: ObservableAgentsActionClient
   }
+  releases: ObservableReleasesClient
   /**
    * Instance properties
    */
@@ -2219,7 +2637,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>
   /**
@@ -2402,6 +2822,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.
@@ -2506,6 +3010,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.
@@ -2707,6 +3362,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
@@ -2816,26 +3474,156 @@ export declare class ProjectsClient {
 }
 
 /**
- * Publishes a draft document.
- * If a published version of the document already exists this is replaced by the current draft document.
- * In either case the draft document is deleted.
- * The optional revision id parameters can be used for optimistic locking to ensure
- * that the draft and/or published versions of the document have not been changed by another client.
- *
- * @public
+ * @beta
  */
-export declare type PublishAction = {
-  actionType: 'sanity.action.document.publish'
-  /**
-   * Draft document ID to publish
-   */
-  draftId: string
+declare interface PromptJsonResponse<T extends Record<string, Any> = Record<string, Any>> {
   /**
-   * Draft revision ID to match
+   *
+   * When true, the response body will be json according to the instruction.
+   * When false, the response is the raw text response to the instruction.
+   *
+   * Note: In addition to setting this to true,  `instruction` MUST include the word 'JSON', or 'json' for this to work.
    */
-  ifDraftRevisionId?: string
+  json: true
+}
+
+/** @beta */
+export declare type PromptRequest<T extends Record<string, Any> = Record<string, Any>> = (
+  | PromptTextResponse
+  | PromptJsonResponse<T>
+) &
+  PromptRequestBase
+
+/**  @beta */
+declare interface PromptRequestBase {
   /**
-   * Published document ID to replace
+   * Instruct the LLM how it should generate content. Be as specific and detailed as needed.
+   *
+   * The LLM only has access to information in the instruction, plus the target schema.
+   *
+   * string template using $variable
+   * */
+  instruction: string
+  /**
+   * param values for the string template, keys are the variable name, ie if the template has "$variable", one key must be "variable"
+   *
+   * ### Examples
+   *
+   * #### Constant
+   *
+   * ##### Shorthand
+   * ```ts
+   * client.agent.action.generate({
+   *   schemaId,
+   *   documentId,
+   *   instruction: 'Give the following topic:\n $topic \n ---\nReturns some facts about it',
+   *   instructionParams: {
+   *     topic: 'Grapefruit'
+   *   },
+   * })
+   * ```
+   * ##### Object-form
+   *
+   * ```ts
+   * client.agent.action.prompt({
+   *   instruction: 'Give the following topic:\n $topic \n ---\nReturns some facts about it.',
+   *   instructionParams: {
+   *     topic: {
+   *       type: 'constant',
+   *       value: 'Grapefruit'
+   *     },
+   *   },
+   * })
+   * ```
+   * #### Field
+   * ```ts
+   * client.agent.action.prompt({
+   *   instruction: 'Give the following field value:\n $pte \n ---\nGenerate keywords.',
+   *   instructionParams: {
+   *     pte: {
+   *       type: 'field',
+   *       path: ['pteField'],
+   *       documentId: 'someSanityDocId'
+   *     },
+   *   },
+   * })
+   * ```
+   * #### Document
+   * ```ts
+   * client.agent.action.prompt({
+   *   json: true,
+   *   instruction: 'Given the following document:$document\nCreate a JSON string[] array with keywords describing it.',
+   *   instructionParams: {
+   *     document: {
+   *       type: 'document',
+   *       documentId: 'someSanityDocId'
+   *     },
+   *   },
+   * })
+   * ```
+   *
+   * #### GROQ
+   * ```ts
+   * client.agent.action.prompt({
+   *   instruction: 'Return the best title amongst these: $titles.',
+   *   instructionParams: {
+   *     titles: {
+   *       type: 'groq',
+   *       query: '* [_type==$type].title',
+   *       params: {type: 'article'}
+   *     },
+   *   },
+   * })
+   * ```
+   * */
+  instructionParams?: AgentActionParams<{
+    docIdRequired: true
+  }>
+  /**
+   * Controls how much variance the instructions will run with.
+   *
+   * Value must be in the range [0, 1] (inclusive).
+   *
+   * Defaults:
+   * - generate: 0.3
+   * - translate: 0
+   * - transform: 0
+   */
+  temperature?: number
+}
+
+declare interface PromptTextResponse {
+  /**
+   *
+   * When true, the response body will be json according to the instruction.
+   * When false, the response is the raw text response to the instruction.
+   *
+   * Note: In addition to setting this to true,  `instruction` MUST include the word 'JSON', or 'json' for this to work.
+   */
+  json?: false
+}
+
+/**
+ * Publishes a draft document.
+ * If a published version of the document already exists this is replaced by the current draft document.
+ * In either case the draft document is deleted.
+ * The optional revision id parameters can be used for optimistic locking to ensure
+ * that the draft and/or published versions of the document have not been changed by another client.
+ *
+ * @public
+ */
+export declare type PublishAction = {
+  actionType: 'sanity.action.document.publish'
+  /**
+   * Draft document ID to publish
+   */
+  draftId: string
+  /**
+   * Draft revision ID to match
+   */
+  ifDraftRevisionId?: string
+  /**
+   * Published document ID to replace
    */
   publishedId: string
   /**
@@ -2844,6 +3632,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
@@ -2942,17 +3740,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'
@@ -2966,6 +4120,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
+}
+
 /** @public */
 export declare const requester: Requester
 
@@ -3051,6 +4215,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
    */
@@ -3147,6 +4312,7 @@ export declare class SanityClient {
     options?: {
       signal?: AbortSignal
       tag?: string
+      releaseId?: string
     },
   ): Promise<SanityDocument<R> | undefined>
   /**
@@ -3330,6 +4496,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.
@@ -3434,6 +4684,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.
@@ -3474,7 +4875,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>
@@ -3690,6 +5091,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']
@@ -4168,6 +5580,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
@@ -4209,6 +5631,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}
@@ -4296,6 +5740,13 @@ export declare function validateApiPerspective(
   perspective: unknown,
 ): asserts perspective is ClientPerspective
 
+/** @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_.