@sanity/client 7.0.1-canary.2 → 7.2.0

package/dist/index.browser.d.ts

@@ -19,6 +19,8 @@ export declare type Action =
   | DiscardAction
   | PublishAction
   | UnpublishAction
+  | VersionAction
+  | ReleaseAction
 
 /** @internal */
 export declare interface ActionError {
@@ -39,6 +41,262 @@ export declare interface ActionErrorItem {
   index: number
 }
 
+/** @beta */
+declare interface AgentActionAsync {
+  /**
+   * When async: true, requests responds with status 201 and \{_id\} as response body as soon as the request is validated.
+   * The instruction operation will carry on in the background.
+   *
+   * When async: false (default), requests respond with status 200 and the document value after instruction has been applied.
+   *
+   * async: true is incompatible with noWrite, as async: true does not return the resulting document
+   */
+  async: true
+}
+
+/** @beta */
+export declare type AgentActionParam =
+  | string
+  | ConstantAgentActionParam
+  | FieldAgentActionParam
+  | DocumentAgentActionParam
+  | GroqAgentActionParam
+
+/** @beta */
+export declare type AgentActionParams = Record<string, AgentActionParam>
+
+/**  @beta */
+export declare type AgentActionPath = AgentActionPathSegment[]
+
+/**  @beta */
+export declare type AgentActionPathSegment =
+  | string
+  | {
+      _key: string
+    }
+
+/** @beta */
+declare interface AgentActionRequestBase {
+  /** schemaId as reported by sanity deploy / sanity schema store */
+  schemaId: string
+  /**
+   * When a type or field in the schema has a function set for `hidden` or `readOnly`, it is conditional.
+   *
+   * By default, Generate will not output to conditional `readOnly` and `hidden` fields,
+   * ie, they are considered to resolve to `readOnly: true` / `hidden: true`.
+   *
+   * `conditionalPaths` param allows setting the default conditional value for
+   * `hidden` and `readOnly` to false,
+   * or individually set `hidden` and `readOnly` state for individual document paths.
+   *
+   * Note: fields and types with explicit readOnly: true or hidden: true in the schema, are not available to Generate,
+   * and cannot be changed via conditionalPaths
+   *
+   * conditionalPaths state only apply to fields and types that have conditional `hidden` or `readOnly` in their schema definition.
+   *
+   * Consider using `hidden: () => true` in schema config, if a field should be writeable only by Generate and never
+   * visible in the studio – then make the field visible to the Generate using `conditionalPaths`.
+   *
+   * @see GenerateRequestBase#target
+   */
+  conditionalPaths?: {
+    defaultReadOnly?: boolean
+    defaultHidden?: boolean
+    paths?: {
+      /** path here is not a relative path: it must be the full document path, regardless of `path` param used in targets */
+      path: AgentActionPath
+      readOnly: boolean
+      hidden: boolean
+    }[]
+  }
+  /**
+   * When localeSettings is provided on the request, instruct can write to date and datetime fields.
+   * Otherwise, such fields will be ignored.
+   */
+  localeSettings?: {
+    /**
+     * A valid Unicode BCP 47 locale identifier used to interpret and format
+     * natural language inputs and date output. Examples include "en-US", "fr-FR", or "ja-JP".
+     *
+     * This affects how phrases like "next Friday" or "in two weeks" are parsed,
+     * and how resulting dates are presented (e.g., 12-hour vs 24-hour format).
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#getcanonicalocales
+     */
+    locale: string
+    /**
+     * A valid IANA time zone identifier used to resolve relative and absolute
+     * date expressions to a specific point in time. Examples include
+     * "America/New_York", "Europe/Paris", or "Asia/Tokyo".
+     *
+     * This ensures phrases like "tomorrow at 9am" are interpreted correctly
+     * based on the user's local time.
+     *
+     * @see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+     */
+    timeZone: string
+  }
+  /**
+   * 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
+}
+
+/** @public */
+declare class AgentActionsClient {
+  #private
+  constructor(client: SanityClient, httpRequest: HttpRequest)
+  /**
+   * Run an instruction to generate content in a target document.
+   * @param request - instruction request
+   */
+  generate<DocumentShape extends Record<string, Any>>(
+    request: GenerateInstruction<DocumentShape>,
+  ): Promise<
+    (typeof request)['async'] extends true
+      ? {
+          _id: string
+        }
+      : IdentifiedSanityDocumentStub & DocumentShape
+  >
+  /**
+   * Transform a target document based on a source.
+   * @param request - translation request
+   */
+  transform<DocumentShape extends Record<string, Any>>(
+    request: TransformDocument<DocumentShape>,
+  ): Promise<
+    (typeof request)['async'] extends true
+      ? {
+          _id: string
+        }
+      : IdentifiedSanityDocumentStub & DocumentShape
+  >
+  /**
+   * Translate a target document based on a source.
+   * @param request - translation request
+   */
+  translate<DocumentShape extends Record<string, Any>>(
+    request: TranslateDocument<DocumentShape>,
+  ): Promise<
+    (typeof request)['async'] extends true
+      ? {
+          _id: string
+        }
+      : IdentifiedSanityDocumentStub & DocumentShape
+  >
+}
+
+/** @beta */
+declare interface AgentActionSync {
+  /**
+   * By default, noWrite: false.
+   * Write enabled operations will mutate the target document, and emit AI presence in the studio.
+   *
+   * When noWrite: true, the api will not mutate any documents nor emit presence.
+   * Ie, when true, no changes will be made to content-lake
+   *
+   * noWrite: true is incompatible with async: true,
+   * as noWrite implies that you will use the return value of the operation
+   */
+  noWrite?: boolean
+  /**
+   * When async: true, requests responds with status 201 and \{_id\} as response body as soon as the request is validated.
+   * The instruction operation will carry on in the background.
+   *
+   * When async: false (default), requests respond with status 200 and the document value after instruction has been applied.
+   *
+   * async: true is incompatible with noWrite: true, as async: true does not return the resulting document
+   */
+  async?: false
+}
+
+/**
+ * @beta
+ */
+export declare interface AgentActionTarget {
+  /**
+   * Root target path.
+   *
+   * Use this to have the instruction only affect a part of the document.
+   *
+   * To further control the behavior of individual paths under the root, use `include`, `exclude`, `types.include`
+   * and `types.exclude`.
+   *
+   * Example:
+   *
+   * `path: ['body', {_key: 'someKey'}, 'nestedObject']`
+   *
+   * Here, the instruction will only write to fields under the nestedObject.
+   *
+   * Default: [] = the document itself
+   *
+   * @see #AgentActionPathSegment
+   * @see #AgentActionPath
+   * */
+  path?: AgentActionPathSegment | AgentActionPath
+  /**
+   * maxPathDepth controls how deep into the schema from the target root the instruction will affect.
+   *
+   * Depth is based on path segments:
+   * - `title` has depth 1
+   * - `array[_key="no"].title` has depth 3
+   *
+   * Be careful not to set this too high in studios with recursive document schemas, as it could have
+   * negative impact on performance; both for runtime and quality of responses.
+   *
+   * Default: 4
+   */
+  maxPathDepth?: number
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   * Fields or array items not on the exclude list, are implicitly included.
+   */
+  exclude?: AgentActionPathSegment[]
+  /**
+   * Types can be used to exclude array item types or all fields directly under the target path of a certain type.
+   * If you do exclude: ['string'] all string fields under the target will be excluded, for instance.
+   *
+   * `types.include` and `types.exclude` are mutually exclusive.
+   */
+  types?: AgentActionTypeConfig
+}
+
+/**  @beta */
+declare interface AgentActionTargetInclude {
+  path: AgentActionPathSegment | AgentActionPath
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   * Fields or array items not on the exclude list, are implicitly included.
+   */
+  exclude?: AgentActionPathSegment[]
+  /**
+   * Types can be used to exclude array item types or all fields directly under the target path of a certain type.
+   * If you do exclude: ['string'] all string fields under the target will be excluded, for instance.
+   *
+   * `types.include` and `types.exclude` are mutually exclusive.
+   */
+  types?: AgentActionTypeConfig
+}
+
+/**  @beta */
+declare type AgentActionTypeConfig =
+  | {
+      include: string[]
+      exclude?: never
+    }
+  | {
+      exclude: string[]
+      include?: never
+    }
+
 /** @internal */
 export declare type AllDocumentIdsMutationOptions = BaseMutationOptions & {
   returnFirst: false
@@ -64,6 +322,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'
@@ -75,7 +343,7 @@ export declare type AssetMetadataType =
   | 'none'
 
 /** @internal */
-export declare class AssetsClient implements AssetsClientType {
+export declare class AssetsClient {
   #private
   constructor(client: SanityClient, httpRequest: HttpRequest)
   /**
@@ -116,46 +384,6 @@ export declare class AssetsClient implements AssetsClientType {
   ): Promise<SanityAssetDocument | SanityImageAssetDocument>
 }
 
-/** @internal */
-declare interface AssetsClientType {
-  /**
-   * Uploads a file asset to the configured dataset
-   *
-   * @param assetType - Asset type (file)
-   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
-   * @param options - Options to use for the upload
-   */
-  upload(
-    assetType: 'file',
-    body: UploadBody,
-    options?: UploadClientConfig,
-  ): Promise<SanityAssetDocument>
-  /**
-   * Uploads an image asset to the configured dataset
-   *
-   * @param assetType - Asset type (image)
-   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
-   * @param options - Options to use for the upload
-   */
-  upload(
-    assetType: 'image',
-    body: UploadBody,
-    options?: UploadClientConfig,
-  ): Promise<SanityImageAssetDocument>
-  /**
-   * Uploads a file or an image asset to the configured dataset
-   *
-   * @param assetType - Asset type (file/image)
-   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
-   * @param options - Options to use for the upload
-   */
-  upload(
-    assetType: 'file' | 'image',
-    body: UploadBody,
-    options?: UploadClientConfig,
-  ): Promise<SanityAssetDocument | SanityImageAssetDocument>
-}
-
 /** @internal */
 export declare type AttributeSet = {
   [key: string]: Any
@@ -515,6 +743,43 @@ export declare class ConnectionFailedError extends Error {
   readonly name = 'ConnectionFailedError'
 }
 
+/**
+ * Include a string in the instruction: do not have to escape $ signs in the string.
+ *
+ * ```ts
+ * client.agent.action.generate({
+ *   schemaId,
+ *   documentId,
+ *   instruction: 'Give the following topic:\n $topic \n ---\nGenerate the full article.',
+ *   instructionParams: {
+ *     topic: {
+ *       type: 'constant',
+ *       value: 'Grapefruit'
+ *     },
+ *   },
+ * })
+ * ```
+ *
+ * `type: 'constant'` can also be provided directly as a string, as a shorthand:
+ *
+ * ```ts
+ * client.agent.action.generate({
+ *   schemaId,
+ *   documentId,
+ *   instruction: 'Give the following topic:\n $topic \n ---\nGenerate the full article.',
+ *   instructionParams: {
+ *     topic: 'Grapefruit'
+ *   },
+ * })
+ * ```
+ *
+ * @beta
+ * */
+export declare interface ConstantAgentActionParam {
+  type: 'constant'
+  value: string
+}
+
 /** @public */
 export declare interface ContentSourceMap {
   mappings: ContentSourceMapMappings
@@ -634,6 +899,29 @@ export declare type CreateAction = {
 /** @public */
 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
@@ -653,7 +941,7 @@ export declare type DatasetResponse = {
 }
 
 /** @internal */
-export declare class DatasetsClient implements DatasetsClientType {
+export declare class DatasetsClient {
   #private
   constructor(client: SanityClient, httpRequest: HttpRequest)
   /**
@@ -694,46 +982,6 @@ export declare class DatasetsClient implements DatasetsClientType {
   list(): Promise<DatasetsResponse>
 }
 
-/** @internal */
-declare interface DatasetsClientType {
-  /**
-   * Create a new dataset with the given name
-   *
-   * @param name - Name of the dataset to create
-   * @param options - Options for the dataset
-   */
-  create(
-    name: string,
-    options?: {
-      aclMode?: DatasetAclMode
-    },
-  ): Promise<DatasetResponse>
-  /**
-   * Edit a dataset with the given name
-   *
-   * @param name - Name of the dataset to edit
-   * @param options - New options for the dataset
-   */
-  edit(
-    name: string,
-    options?: {
-      aclMode?: DatasetAclMode
-    },
-  ): Promise<DatasetResponse>
-  /**
-   * Delete a dataset with the given name
-   *
-   * @param name - Name of the dataset to delete
-   */
-  delete(name: string): Promise<{
-    deleted: true
-  }>
-  /**
-   * Fetch a list of datasets for the configured project
-   */
-  list(): Promise<DatasetsResponse>
-}
-
 /** @public */
 export declare type DatasetsResponse = {
   name: string
@@ -769,6 +1017,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
@@ -786,6 +1044,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'
@@ -799,6 +1058,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,
@@ -825,6 +1095,43 @@ export declare type DisconnectEvent = {
   reason: string
 }
 
+/**
+ *
+ * Includes a LLM-friendly version of the document in the instruction
+ *
+ * ```ts
+ * client.agent.action.generate({
+ *   schemaId,
+ *   documentId,
+ *   instruction: 'Give the following document value:\n $document \n ---\nGenerate keywords.',
+ *   instructionParams: {
+ *     document: {
+ *       type: 'document',
+ *     },
+ *   },
+ *   target: {path: 'keywords' }
+ * })
+ * ```
+ *
+ * @beta
+ * */
+export declare interface DocumentAgentActionParam {
+  type: 'document'
+  /**
+   * If omitted, implicitly uses the documentId of the instruction target
+   */
+  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.
@@ -848,6 +1155,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
@@ -867,6 +1185,41 @@ export declare type EventSourceEvent<Name extends string> = ServerSentEvent<Name
  */
 export declare type EventSourceInstance = InstanceType<typeof globalThis.EventSource>
 
+/**
+ *
+ *
+ * Includes a LLM-friendly version of the field value in the instruction
+ *
+ * ```ts
+ * client.agent.action.generate({
+ *   schemaId,
+ *   documentId,
+ *   instruction: 'Give the following field value:\n $pte \n ---\nGenerate keywords.',
+ *   instructionParams: {
+ *     pte: {
+ *       type: 'field',
+ *       path: ['pteField'],
+ *     },
+ *   },
+ *   target: {path: 'keywords' }
+ * })
+ *
+ * ```
+ *
+ * @beta
+ * */
+export declare interface FieldAgentActionParam {
+  type: 'field'
+  /**
+   * Examples: 'title', ['array', \{_key: 'arrayItemKey'\}, 'field']
+   */
+  path: AgentActionPathSegment | AgentActionPath
+  /**
+   * If omitted, implicitly uses the documentId of the instruction target
+   */
+  documentId?: string
+}
+
 /** @public */
 export declare type FilterDefault = (props: {
   /**
@@ -933,18 +1286,286 @@ export declare type FirstDocumentMutationOptions = BaseMutationOptions & {
   returnDocuments?: true
 }
 
-/** @public */
-export declare type HttpRequest = {
-  (options: RequestOptions, requester: Requester): ReturnType<Requester>
+/** @beta */
+declare type GenerateAsyncInstruction<T extends Record<string, Any> = Record<string, Any>> = (
+  | GenerateExistingDocumentRequest
+  | GenerateTargetDocumentRequest<T>
+) &
+  GenerateRequestBase &
+  AgentActionAsync
+
+/**
+ * Instruction for an existing document.
+ * @beta
+ */
+declare interface GenerateExistingDocumentRequest {
+  documentId: string
+  createDocument?: never
 }
 
-/** @public */
-export declare type HttpRequestEvent<T = unknown> = ResponseEvent<T> | ProgressEvent_2
+/** @beta */
+export declare type GenerateInstruction<T extends Record<string, Any> = Record<string, Any>> =
+  | GenerateSyncInstruction<T>
+  | GenerateAsyncInstruction<T>
+
+/**  @beta */
+export declare type GenerateOperation = 'set' | 'append' | 'mixed'
+
+/**  @beta */
+declare interface GenerateRequestBase extends AgentActionRequestBase {
+  /** schemaId as reported by sanity deploy / sanity schema store */
+  schemaId: string
+  /**
+   * 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 ---\nGenerate the full article.',
+   *   instructionParams: {
+   *     topic: 'Grapefruit'
+   *   },
+   * })
+   * ```
+   * ##### Object-form
+   *
+   * ```ts
+   * client.agent.action.generate({
+   *   schemaId,
+   *   documentId,
+   *   instruction: 'Give the following topic:\n $topic \n ---\nGenerate the full article.',
+   *   instructionParams: {
+   *     topic: {
+   *       type: 'constant',
+   *       value: 'Grapefruit'
+   *     },
+   *   },
+   * })
+   * ```
+   * #### Field
+   * ```ts
+   * client.agent.action.generate({
+   *   schemaId,
+   *   documentId,
+   *   instruction: 'Give the following field value:\n $pte \n ---\nGenerate keywords.',
+   *   instructionParams: {
+   *     pte: {
+   *       type: 'field',
+   *       path: ['pteField'],
+   *     },
+   *   },
+   *   target: {path: 'keywords' }
+   * })
+   * ```
+   * #### Document
+   * ```ts
+   * client.agent.action.generate({
+   *   schemaId,
+   *   documentId,
+   *   instruction: 'Give the following document value:\n $document \n ---\nGenerate keywords.',
+   *   instructionParams: {
+   *     document: {
+   *       type: 'document',
+   *     },
+   *   },
+   *   target: {path: 'keywords' }
+   * })
+   * ```
+   *
+   * #### GROQ
+   * ```ts
+   * client.agent.action.generate({
+   *   schemaId,
+   *   documentId,
+   *   instruction: 'Give the following list of titles:\n $list \n ---\nGenerate a similar title.',
+   *   instructionParams: {
+   *     list: {
+   *       type: 'groq',
+   *       query: '* [_type==$type].title',
+   *       params: {type: 'article'}
+   *     },
+   *   },
+   *   target: {path: 'title' }
+   * })
+   * ```
+   * */
+  instructionParams?: AgentActionParams
+  /**
+   * Target defines which parts of the document will be affected by the instruction.
+   * It can be an array, so multiple parts of the document can be separately configured in detail.
+   *
+   * Omitting target implies that the document itself is the root.
+   *
+   * Notes:
+   * - instruction can only affect fields up to `maxPathDepth`
+   * - when multiple targets are provided, they will be coalesced into a single target sharing a common target root.
+   * It is therefor an error to provide conflicting include/exclude across targets (ie, include title in one, and exclude it in another)
+   *
+   * @see AgentActionRequestBase#conditionalPaths
+   */
+  target?: GenerateTarget | GenerateTarget[]
+}
 
-/** @public */
-export declare type IdentifiedSanityDocumentStub<
-  T extends Record<string, Any> = Record<string, Any>,
-> = {
+/** @beta */
+declare type GenerateSyncInstruction<T extends Record<string, Any> = Record<string, Any>> = (
+  | GenerateExistingDocumentRequest
+  | GenerateTargetDocumentRequest<T>
+) &
+  GenerateRequestBase &
+  AgentActionSync
+
+/**  @beta */
+export declare interface GenerateTarget extends AgentActionTarget {
+  /**
+   * Sets the default operation for all paths in the target.
+   * Generate runs in `'mixed'` operation mode by default:
+   * Changes are set in all non-array fields, and append to all array fields.
+   *
+   * ### Operation types
+   * - `'set'` – an *overwriting* operation, and replaces the full field value.
+   * - `'append'`:
+   *    – array fields: appends new items to the end of the array,
+   *    - string fields: '"existing content" "new content"'
+   *    - text fields: '"existing content"\\n"new content"'
+   *    - number fields: existing + new
+   *    - other field types not mentioned will set instead (dates, url)
+   * - `'mixed'` – (default) sets non-array fields, and appends to array fields
+   *
+   * The default operation can be overridden on a per-path basis using `include`.
+   *
+   * Nested fields inherit the operation specified by their parent and falls back to the
+   * top level target operation if not otherwise specified.
+   *
+   * Use `include` to change the `operation` of individual fields or items.
+   *
+   * #### Appending in the middle of arrays
+   * `target: {path: ['array'], operation: 'append'}` will append the output of the instruction to the end of the array.
+   *
+   * To insert in the middle of the array, use `target: {path: ['array', {_key: 'appendAfterKey'}], operation: 'append'}`.
+   * Here, the output of the instruction will be appended after the array item with key `'appendAfterKey'`.
+   *
+   * @see #AgentActionTargetInclude.operation
+   * @see #include
+   * @see #AgentActionTargetInclude.include
+   */
+  operation?: GenerateOperation
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   *
+   * When `include` is specified, only segments explicitly listed will be included.
+   *
+   * Fields or array items not on the include list, are implicitly excluded.
+   */
+  include?: (AgentActionPathSegment | GenerateTargetInclude)[]
+}
+
+/**  @beta */
+export declare type GenerateTargetDocument<T extends Record<string, Any> = Record<string, Any>> =
+  | {
+      operation: 'edit'
+      _id: string
+    }
+  | {
+      operation: 'create'
+      _id?: string
+      _type: string
+      initialValues?: T
+    }
+  | {
+      operation: 'createIfNotExists'
+      _id: string
+      _type: string
+      initialValues?: T
+    }
+  | {
+      operation: 'createOrReplace'
+      _id: string
+      _type: string
+      initialValues?: T
+    }
+
+/**
+ * Instruction to create a new document
+ * @beta
+ */
+declare interface GenerateTargetDocumentRequest<
+  T extends Record<string, Any> = Record<string, Any>,
+> {
+  targetDocument: GenerateTargetDocument<T>
+  documentId?: never
+}
+
+/**  @beta */
+export declare interface GenerateTargetInclude extends AgentActionTargetInclude {
+  /**
+   * Sets the operation for this path, and all its children.
+   * This overrides any operation set parents or the root target.
+   * @see #GenerateTarget.operation
+   * @see #include
+   */
+  operation?: GenerateOperation
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   *
+   * When `include` is specified, only segments explicitly listed will be included.
+   *
+   * Fields or array items not on the include list, are implicitly excluded.
+   */
+  include?: (AgentActionPathSegment | GenerateTargetInclude)[]
+}
+
+/**
+ * Includes a LLM-friendly version of GROQ query result in the instruction
+ *
+ * ```ts
+ * client.agent.action.generate({
+ *   schemaId,
+ *   documentId,
+ *   instruction: 'Give the following list of titles:\n $list \n ---\nGenerate a similar title.',
+ *   instructionParams: {
+ *     list: {
+ *       type: 'groq',
+ *       query: '* [_type==$type].title',
+ *       params: {type: 'article'}
+ *     },
+ *   },
+ *   target: {path: 'title' }
+ * })
+ * ```
+ * @beta
+ * */
+export declare interface GroqAgentActionParam {
+  type: 'groq'
+  query: string
+  params?: Record<string, string>
+}
+
+/** @public */
+export declare type HttpRequest = {
+  (options: RequestOptions, requester: Requester): ReturnType<Requester>
+}
+
+/** @public */
+export declare type HttpRequestEvent<T = unknown> = ResponseEvent<T> | ProgressEvent_2
+
+/** @public */
+export declare type IdentifiedSanityDocumentStub<
+  T extends Record<string, Any> = Record<string, Any>,
+> = {
   [P in keyof T]: T[P]
 } & {
   _id: string
@@ -1062,15 +1683,6 @@ export declare interface ListenOptions {
    * @defaultValue `false`
    */
   includePreviousRevision?: boolean
-  /**
-   * Whether to include events for drafts and versions. As of API Version >= v2025-02-19, only events
-   * for published documents will be included by default (see {@link https://www.sanity.io/changelog/676aaa9d-2da6-44fb-abe5-580f28047c10|Changelog})
-   * If you need events from drafts and versions, set this to `true`.
-   * Note: Keep in mind that additional document variants may be introduced in the future, so it's
-   * recommended to respond to events in a way that's tolerant of potential future variants, e.g. by
-   * explicitly checking whether the event is for a draft or a version.
-   * @defaultValue `false`
-   */
   includeAllVersions?: boolean
   /**
    * Whether events should be sent as soon as a transaction has been committed (`transaction`, default),
@@ -1365,62 +1977,55 @@ export declare type MutationSelectionQueryParams = {
   [key: string]: Any
 }
 
-/** @internal */
-export declare class ObservableAssetsClient implements ObservableAssetsClientType {
+/** @public */
+declare class ObservableAgentsActionClient {
   #private
   constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
   /**
-   * Uploads a file asset to the configured dataset
-   *
-   * @param assetType - Asset type (file)
-   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
-   * @param options - Options to use for the upload
+   * Run an instruction to generate content in a target document.
+   * @param request - instruction request
    */
-  upload(
-    assetType: 'file',
-    body: UploadBody,
-    options?: UploadClientConfig,
+  generate<DocumentShape extends Record<string, Any>>(
+    request: GenerateInstruction<DocumentShape>,
   ): Observable<
-    HttpRequestEvent<{
-      document: SanityAssetDocument
-    }>
+    (typeof request)['async'] extends true
+      ? {
+          _id: string
+        }
+      : IdentifiedSanityDocumentStub & DocumentShape
   >
   /**
-   * Uploads an image asset to the configured dataset
-   *
-   * @param assetType - Asset type (image)
-   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
-   * @param options - Options to use for the upload
+   * Transform a target document based on a source.
+   * @param request - translation request
    */
-  upload(
-    assetType: 'image',
-    body: UploadBody,
-    options?: UploadClientConfig,
+  transform<DocumentShape extends Record<string, Any>>(
+    request: TransformDocument<DocumentShape>,
   ): Observable<
-    HttpRequestEvent<{
-      document: SanityImageAssetDocument
-    }>
+    (typeof request)['async'] extends true
+      ? {
+          _id: string
+        }
+      : IdentifiedSanityDocumentStub & DocumentShape
   >
   /**
-   * Uploads a file or an image asset to the configured dataset
-   *
-   * @param assetType - Asset type (file/image)
-   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
-   * @param options - Options to use for the upload
+   * Translate a target document based on a source.
+   * @param request - translation request
    */
-  upload(
-    assetType: 'file' | 'image',
-    body: UploadBody,
-    options?: UploadClientConfig,
+  translate<DocumentShape extends Record<string, Any>>(
+    request: TranslateDocument<DocumentShape>,
   ): Observable<
-    HttpRequestEvent<{
-      document: SanityAssetDocument | SanityImageAssetDocument
-    }>
+    (typeof request)['async'] extends true
+      ? {
+          _id: string
+        }
+      : IdentifiedSanityDocumentStub & DocumentShape
   >
 }
 
 /** @internal */
-declare interface ObservableAssetsClientType {
+export declare class ObservableAssetsClient {
+  #private
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
   /**
    * Uploads a file asset to the configured dataset
    *
@@ -1472,7 +2077,7 @@ declare interface ObservableAssetsClientType {
 }
 
 /** @internal */
-export declare class ObservableDatasetsClient implements ObservableDatasetsClientType {
+export declare class ObservableDatasetsClient {
   #private
   constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
   /**
@@ -1513,46 +2118,6 @@ export declare class ObservableDatasetsClient implements ObservableDatasetsClien
   list(): Observable<DatasetsResponse>
 }
 
-/** @internal */
-declare interface ObservableDatasetsClientType {
-  /**
-   * Create a new dataset with the given name
-   *
-   * @param name - Name of the dataset to create
-   * @param options - Options for the dataset
-   */
-  create(
-    name: string,
-    options?: {
-      aclMode?: DatasetAclMode
-    },
-  ): Observable<DatasetResponse>
-  /**
-   * Edit a dataset with the given name
-   *
-   * @param name - Name of the dataset to edit
-   * @param options - New options for the dataset
-   */
-  edit(
-    name: string,
-    options?: {
-      aclMode?: DatasetAclMode
-    },
-  ): Observable<DatasetResponse>
-  /**
-   * Delete a dataset with the given name
-   *
-   * @param name - Name of the dataset to delete
-   */
-  delete(name: string): Observable<{
-    deleted: true
-  }>
-  /**
-   * Fetch a list of datasets for the configured project
-   */
-  list(): Observable<DatasetsResponse>
-}
-
 /** @public */
 export declare class ObservablePatch extends BasePatch {
   #private
@@ -1607,14 +2172,14 @@ export declare class ObservablePatch extends BasePatch {
 export declare type ObservablePatchBuilder = (patch: ObservablePatch) => ObservablePatch
 
 /** @internal */
-export declare class ObservableProjectsClient implements ObservableProjectsClientType {
+export declare class ObservableProjectsClient {
   #private
   constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
   /**
    * Fetch a list of projects the authenticated user has access to.
    *
    * @param options - Options for the list request
-   * @param options.includeMembers - Whether to include members in the response (default: true)
+   *   - `includeMembers` - Whether to include members in the response (default: true)
    */
   list(options?: {includeMembers?: true}): Observable<SanityProject[]>
   list(options?: {includeMembers?: false}): Observable<Omit<SanityProject, 'members'>[]>
@@ -1626,35 +2191,321 @@ export declare class ObservableProjectsClient implements ObservableProjectsClien
   getById(projectId: string): Observable<SanityProject>
 }
 
-/** @internal */
-declare interface ObservableProjectsClientType {
+/** @public */
+declare class ObservableReleasesClient {
+  #private
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
   /**
-   * Fetch a list of projects the authenticated user has access to.
+   * @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
    *
-   * @param options - Options for the list request
-   * @param options.includeMembers - Whether to include members in the response (default: true)
+   * 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`.
    */
-  list(options?: {includeMembers?: true}): Observable<SanityProject[]>
-  list(options?: {includeMembers?: false}): Observable<Omit<SanityProject, 'members'>[]>
-  list(options?: {
-    includeMembers?: boolean
-  }): Observable<SanityProject[] | Omit<SanityProject, 'members'>[]>
+  edit(
+    {
+      releaseId,
+      patch,
+    }: {
+      releaseId: string
+      patch: PatchOperations
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
   /**
-   * Fetch a project by project ID
+   * @public
    *
-   * @param projectId - ID of the project to fetch
+   * 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`.
    */
-  getById(projectId: string): Observable<SanityProject>
+  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 implements ObservableSanityClientType {
+export declare class ObservableSanityClient {
   #private
   assets: ObservableAssetsClient
   datasets: ObservableDatasetsClient
   live: LiveClient
   projects: ObservableProjectsClient
   users: ObservableUsersClient
+  agent: {
+    action: ObservableAgentsActionClient
+  }
+  releases: ObservableReleasesClient
+  /**
+   * Instance properties
+   */
   listen: typeof _listen
   constructor(httpRequest: HttpRequest, config?: ClientConfig)
   /**
@@ -1713,7 +2564,7 @@ export declare class ObservableSanityClient implements ObservableSanityClientTyp
     Q extends QueryWithoutParams | QueryParams = QueryParams,
     const G extends string = string,
   >(
-    query: G,
+    query: string,
     params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
     options: UnfilteredResponseQueryOptions,
   ): Observable<RawQueryResponse<ClientReturn<G, R>>>
@@ -1742,7 +2593,9 @@ export declare class ObservableSanityClient implements ObservableSanityClientTyp
   getDocument<R extends Record<string, Any> = Record<string, Any>>(
     id: string,
     options?: {
+      signal?: AbortSignal
       tag?: string
+      releaseId?: string
     },
   ): Observable<SanityDocument<R> | undefined>
   /**
@@ -1925,6 +2778,90 @@ export declare class ObservableSanityClient implements ObservableSanityClientTyp
     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.
@@ -2029,6 +2966,157 @@ export declare class ObservableSanityClient implements ObservableSanityClientTyp
     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.
@@ -2148,1516 +3236,825 @@ export declare class ObservableSanityClient implements ObservableSanityClientTyp
   getDataUrl(operation: string, path?: string): string
 }
 
-/**
- * The interface implemented by the `ObservableSanityClient` class.
- * When writing code that wants to take an instance of `ObservableSanityClient` as input it's better to use this type,
- * as the `ObservableSanityClient` class has private properties and thus TypeScrict will consider the type incompatible
- * in cases where you might have multiple `@sanity/client` instances in your node_modules.
- * @public
- */
-export declare interface ObservableSanityClientType extends SanityClientBase {
-  assets: ObservableAssetsClientType
-  datasets: ObservableDatasetsClientType
-  projects: ObservableProjectsClientType
-  users: ObservableUsersClientType
+/** @public */
+export declare class ObservableTransaction extends BaseTransaction {
+  #private
+  constructor(operations?: Mutation[], client?: ObservableSanityClient, transactionId?: string)
   /**
-   * Clone the client - returns a new instance
+   * Clones the transaction
    */
-  clone(): ObservableSanityClientType
+  clone(): ObservableTransaction
   /**
-   * Returns the current client configuration
+   * Commit the transaction, returning an observable that produces the first mutated document
+   *
+   * @param options - Options for the mutation operation
    */
-  config(): InitializedClientConfig
+  commit<R extends Record<string, Any>>(
+    options: TransactionFirstDocumentMutationOptions,
+  ): Observable<SanityDocument<R>>
   /**
-   * Reconfigure the client. Note that this _mutates_ the current client.
+   * Commit the transaction, returning an observable that produces an array of the mutated documents
+   *
+   * @param options - Options for the mutation operation
    */
-  config(newConfig?: Partial<ClientConfig>): ObservableSanityClientType
+  commit<R extends Record<string, Any>>(
+    options: TransactionAllDocumentsMutationOptions,
+  ): Observable<SanityDocument<R>[]>
   /**
-   * Clone the client with a new (partial) configuration.
+   * Commit the transaction, returning an observable that produces a mutation result object
    *
-   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
+   * @param options - Options for the mutation operation
    */
-  withConfig(newConfig?: Partial<ClientConfig>): ObservableSanityClientType
+  commit(options: TransactionFirstDocumentIdMutationOptions): Observable<SingleMutationResult>
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Commit the transaction, returning an observable that produces a mutation result object
    *
-   * @param query - GROQ-query to perform
+   * @param options - Options for the mutation operation
    */
-  fetch<
-    R = Any,
-    Q extends QueryWithoutParams = QueryWithoutParams,
-    const G extends string = string,
-  >(
-    query: G,
-    params?: Q | QueryWithoutParams,
-  ): Observable<ClientReturn<G, R>>
+  commit(options: TransactionAllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Commit the transaction, returning an observable that produces a mutation result object
    *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Optional request options
+   * @param options - Options for the mutation operation
    */
-  fetch<
-    R = Any,
-    Q extends QueryWithoutParams | QueryParams = QueryParams,
-    const G extends string = string,
-  >(
-    query: G,
-    params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
-    options?: FilteredResponseQueryOptions,
-  ): Observable<ClientReturn<G, R>>
+  commit(options?: BaseMutationOptions): Observable<MultipleMutationResult>
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Performs a patch on the given document ID. Can either be a builder function or an object of patch operations.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
    *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Request options
+   * @param documentId - Document ID to perform the patch operation on
+   * @param patchOps - Operations to perform, or a builder function
    */
-  fetch<
-    R = Any,
-    Q extends QueryWithoutParams | QueryParams = QueryParams,
-    const G extends string = string,
-  >(
-    query: G,
-    params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
-    options: UnfilteredResponseQueryOptions,
-  ): Observable<RawQueryResponse<ClientReturn<G, R>>>
+  patch(documentId: string, patchOps?: ObservablePatchBuilder | PatchOperations): this
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Adds the given patch instance to the transaction.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
    *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Request options
+   * @param patch - ObservablePatch to execute
    */
-  fetch<
-    R = Any,
-    Q extends QueryWithoutParams | QueryParams = QueryParams,
-    const G extends string = string,
-  >(
-    query: G,
-    params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
-    options: UnfilteredResponseWithoutQuery,
-  ): Observable<RawQuerylessQueryResponse<ClientReturn<G, R>>>
+  patch(patch: ObservablePatch): this
+}
+
+/** @public */
+export declare class ObservableUsersClient {
+  #private
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
   /**
-   * Fetch a single document with the given ID.
+   * Fetch a user by user ID
    *
-   * @param id - Document ID to fetch
-   * @param options - Request options
+   * @param id - User ID of the user to fetch. If `me` is provided, a minimal response including the users role is returned.
    */
-  getDocument<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options?: {
-      tag?: string
-    },
-  ): Observable<SanityDocument<R> | undefined>
+  getById<T extends 'me' | string>(
+    id: T,
+  ): Observable<T extends 'me' ? CurrentSanityUser : SanityUser>
+}
+
+/**
+ * The listener connection has been established
+ * note: it's usually a better option to use the 'welcome' event
+ * @public
+ */
+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
+  constructor(selection: PatchSelection, operations?: PatchOperations, client?: SanityClient)
   /**
-   * Fetch multiple documents in one request.
-   * Should be used sparingly - performing a query is usually a better option.
-   * The order/position of documents is preserved based on the original array of IDs.
-   * If any of the documents are missing, they will be replaced by a `null` entry in the returned array
-   *
-   * @param ids - Document IDs to fetch
-   * @param options - Request options
+   * Clones the patch
    */
-  getDocuments<R extends Record<string, Any> = Record<string, Any>>(
-    ids: string[],
-    options?: {
-      tag?: string
-    },
-  ): Observable<(SanityDocument<R> | null)[]>
+  clone(): Patch
   /**
-   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
-   * Returns an observable that resolves to the created document.
+   * Commit the patch, returning a promise that resolves to the first patched document
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
+  commit<R extends Record<string, Any> = Record<string, Any>>(
     options: FirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
+  ): Promise<SanityDocument<R>>
   /**
-   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
-   * Returns an observable that resolves to an array containing the created document.
+   * Commit the patch, returning a promise that resolves to an array of the mutated documents
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
+  commit<R extends Record<string, Any> = Record<string, Any>>(
     options: AllDocumentsMutationOptions,
-  ): Observable<SanityDocument<R>[]>
+  ): Promise<SanityDocument<R>[]>
   /**
-   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
-   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
+   * Commit the patch, returning a promise that resolves to a mutation result object
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options: FirstDocumentIdMutationOptions,
-  ): Observable<SingleMutationResult>
+  commit(options: FirstDocumentIdMutationOptions): Promise<SingleMutationResult>
   /**
-   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
-   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
+   * Commit the patch, returning a promise that resolves to a mutation result object
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options: AllDocumentIdsMutationOptions,
-  ): Observable<MultipleMutationResult>
+  commit(options: AllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
   /**
-   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
-   * Returns an observable that resolves to the created document.
+   * Commit the patch, returning a promise that resolves to the first patched document
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
+  commit<R extends Record<string, Any> = Record<string, Any>>(
     options?: BaseMutationOptions,
-  ): Observable<SanityDocument<R>>
+  ): Promise<SanityDocument<R>>
+}
+
+/** @public */
+export declare type PatchBuilder = (patch: Patch) => Patch
+
+/** @internal */
+export declare type PatchMutationOperation = PatchOperations & MutationSelection
+
+/** @internal */
+export declare interface PatchOperations {
+  set?: {
+    [key: string]: Any
+  }
+  setIfMissing?: {
+    [key: string]: Any
+  }
+  diffMatchPatch?: {
+    [key: string]: Any
+  }
+  unset?: string[]
+  inc?: {
+    [key: string]: number
+  }
+  dec?: {
+    [key: string]: number
+  }
+  insert?: InsertPatch
+  ifRevisionID?: string
+}
+
+/** @internal */
+export declare type PatchSelection = string | string[] | MutationSelection
+
+/** @public */
+declare interface ProgressEvent_2 {
+  type: 'progress'
+  stage: 'upload' | 'download'
+  percent: number
+  total?: number
+  loaded?: number
+  lengthComputable: boolean
+}
+export {ProgressEvent_2 as ProgressEvent}
+
+/** @internal */
+export declare class ProjectsClient {
+  #private
+  constructor(client: SanityClient, httpRequest: HttpRequest)
   /**
-   * Create a document if no document with the same ID already exists.
-   * Returns an observable that resolves to the created document.
+   * Fetch a list of projects the authenticated user has access to.
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param options - Options for the list request
+   *   - `includeMembers` - Whether to include members in the response (default: true)
    */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
+  list(options?: {includeMembers?: true}): Promise<SanityProject[]>
+  list(options?: {includeMembers?: false}): Promise<Omit<SanityProject, 'members'>[]>
   /**
-   * Create a document if no document with the same ID already exists.
-   * Returns an observable that resolves to an array containing the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentsMutationOptions,
-  ): Observable<SanityDocument<R>[]>
-  /**
-   * Create a document if no document with the same ID already exists.
-   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentIdMutationOptions,
-  ): Observable<SingleMutationResult>
-  /**
-   * Create a document if no document with the same ID already exists.
-   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentIdsMutationOptions,
-  ): Observable<MultipleMutationResult>
-  /**
-   * Create a document if no document with the same ID already exists.
-   * Returns an observable that resolves to the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options?: BaseMutationOptions,
-  ): Observable<SanityDocument<R>>
-  /**
-   * Create a document if it does not exist, or replace a document with the same document ID
-   * Returns an observable that resolves to the created document.
-   *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
-   */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
-  /**
-   * Create a document if it does not exist, or replace a document with the same document ID
-   * Returns an observable that resolves to an array containing the created document.
-   *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
-   */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentsMutationOptions,
-  ): Observable<SanityDocument<R>[]>
-  /**
-   * Create a document if it does not exist, or replace a document with the same document ID
-   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
-   *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
-   */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentIdMutationOptions,
-  ): Observable<SingleMutationResult>
-  /**
-   * Create a document if it does not exist, or replace a document with the same document ID
-   * Returns an observable that resolves to a mutation result object containing the created document ID.
-   *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
-   */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentIdsMutationOptions,
-  ): Observable<MultipleMutationResult>
-  /**
-   * Create a document if it does not exist, or replace a document with the same document ID
-   * Returns an observable that resolves to the created document.
-   *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
-   */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options?: BaseMutationOptions,
-  ): Observable<SanityDocument<R>>
-  /**
-   * Deletes a document with the given document ID.
-   * Returns an observable that resolves to the deleted document.
-   *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
-   */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options: FirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
-  /**
-   * Deletes a document with the given document ID.
-   * Returns an observable that resolves to an array containing the deleted document.
-   *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
-   */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options: AllDocumentsMutationOptions,
-  ): Observable<SanityDocument<R>[]>
-  /**
-   * Deletes a document with the given document ID.
-   * Returns an observable that resolves to a mutation result object containing the deleted document ID.
-   *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
-   */
-  delete(id: string, options: FirstDocumentIdMutationOptions): Observable<SingleMutationResult>
-  /**
-   * Deletes a document with the given document ID.
-   * Returns an observable that resolves to a mutation result object containing the deleted document ID.
-   *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
-   */
-  delete(id: string, options: AllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
-  /**
-   * Deletes a document with the given document ID.
-   * Returns an observable that resolves to the deleted document.
-   *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
-   */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options?: BaseMutationOptions,
-  ): Observable<SanityDocument<R>>
-  /**
-   * Deletes one or more documents matching the given query or document ID.
-   * Returns an observable that resolves to first deleted document.
-   *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
-   */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
-    options: FirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
-  /**
-   * Deletes one or more documents matching the given query or document ID.
-   * Returns an observable that resolves to an array containing the deleted documents.
-   *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
-   */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
-    options: AllDocumentsMutationOptions,
-  ): Observable<SanityDocument<R>[]>
-  /**
-   * Deletes one or more documents matching the given query or document ID.
-   * Returns an observable that resolves to a mutation result object containing the ID of the first deleted document.
-   *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
-   */
-  delete(
-    selection: MutationSelection,
-    options: FirstDocumentIdMutationOptions,
-  ): Observable<SingleMutationResult>
-  /**
-   * Deletes one or more documents matching the given query or document ID.
-   * Returns an observable that resolves to a mutation result object containing the document IDs that were deleted.
-   *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
-   */
-  delete(
-    selection: MutationSelection,
-    options: AllDocumentIdsMutationOptions,
-  ): Observable<MultipleMutationResult>
-  /**
-   * Deletes one or more documents matching the given query or document ID.
-   * Returns an observable that resolves to first deleted document.
-   *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
-   */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
-    options?: BaseMutationOptions,
-  ): Observable<SanityDocument<R>>
-  /**
-   * Perform mutation operations against the configured dataset
-   * Returns an observable that resolves to the first mutated document.
-   *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
-    options: FirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
-  /**
-   * Perform mutation operations against the configured dataset.
-   * Returns an observable that resolves to an array of the mutated documents.
-   *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
-    options: AllDocumentsMutationOptions,
-  ): Observable<SanityDocument<R>[]>
-  /**
-   * Perform mutation operations against the configured dataset
-   * Returns an observable that resolves to a mutation result object containing the document ID of the first mutated document.
-   *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
-    options: FirstDocumentIdMutationOptions,
-  ): Observable<SingleMutationResult>
-  /**
-   * Perform mutation operations against the configured dataset
-   * Returns an observable that resolves to a mutation result object containing the mutated document IDs.
-   *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
-    options: AllDocumentIdsMutationOptions,
-  ): Observable<MultipleMutationResult>
-  /**
-   * Perform mutation operations against the configured dataset
-   * Returns an observable that resolves to the first mutated document.
-   *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
-    options?: BaseMutationOptions,
-  ): Observable<SanityDocument<R>>
-  /**
-   * Create a new buildable patch of operations to perform
-   *
-   * @param documentId - Document ID to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
-   */
-  patch(documentId: string, operations?: PatchOperations): ObservablePatch
-  /**
-   * Create a new buildable patch of operations to perform
-   *
-   * @param documentIds - Array of document IDs to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
-   */
-  patch(documentIds: string[], operations?: PatchOperations): ObservablePatch
-  /**
-   * Create a new buildable patch of operations to perform
-   *
-   * @param selection - An object with `query` and optional `params`, defining which document(s) to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
-   */
-  patch(selection: MutationSelection, operations?: PatchOperations): ObservablePatch
-  /**
-   * Create a new buildable patch of operations to perform
-   *
-   * @param selection - Document ID, an array of document IDs, or an object with `query` and optional `params`, defining which document(s) to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
-   */
-  patch(selection: PatchSelection, operations?: PatchOperations): ObservablePatch
-  /**
-   * Create a new transaction of mutations
-   *
-   * @param operations - Optional array of mutation operations to initialize the transaction instance with
-   */
-  transaction<R extends Record<string, Any> = Record<string, Any>>(
-    operations?: Mutation<R>[],
-  ): ObservableTransaction
-  /**
-   * Perform action operations against the configured dataset
-   *
-   * @param operations - Action operation(s) to execute
-   * @param options - Action options
-   */
-  action(
-    operations: Action | Action[],
-    options?: BaseActionOptions,
-  ): Observable<SingleActionResult | MultipleActionResult>
-  /**
-   * Perform an HTTP request against the Sanity API
-   *
-   * @param options - Request options
-   */
-  request<R = Any>(options: RawRequestOptions): Observable<R>
-}
-
-/** @public */
-export declare class ObservableTransaction extends BaseTransaction {
-  #private
-  constructor(operations?: Mutation[], client?: ObservableSanityClient, transactionId?: string)
-  /**
-   * Clones the transaction
-   */
-  clone(): ObservableTransaction
-  /**
-   * Commit the transaction, returning an observable that produces the first mutated document
-   *
-   * @param options - Options for the mutation operation
-   */
-  commit<R extends Record<string, Any>>(
-    options: TransactionFirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
-  /**
-   * Commit the transaction, returning an observable that produces an array of the mutated documents
-   *
-   * @param options - Options for the mutation operation
-   */
-  commit<R extends Record<string, Any>>(
-    options: TransactionAllDocumentsMutationOptions,
-  ): Observable<SanityDocument<R>[]>
-  /**
-   * Commit the transaction, returning an observable that produces a mutation result object
-   *
-   * @param options - Options for the mutation operation
-   */
-  commit(options: TransactionFirstDocumentIdMutationOptions): Observable<SingleMutationResult>
-  /**
-   * Commit the transaction, returning an observable that produces a mutation result object
-   *
-   * @param options - Options for the mutation operation
-   */
-  commit(options: TransactionAllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
-  /**
-   * Commit the transaction, returning an observable that produces a mutation result object
-   *
-   * @param options - Options for the mutation operation
-   */
-  commit(options?: BaseMutationOptions): Observable<MultipleMutationResult>
-  /**
-   * Performs a patch on the given document ID. Can either be a builder function or an object of patch operations.
-   * The operation is added to the current transaction, ready to be commited by `commit()`
-   *
-   * @param documentId - Document ID to perform the patch operation on
-   * @param patchOps - Operations to perform, or a builder function
-   */
-  patch(documentId: string, patchOps?: ObservablePatchBuilder | PatchOperations): this
-  /**
-   * Adds the given patch instance to the transaction.
-   * The operation is added to the current transaction, ready to be commited by `commit()`
-   *
-   * @param patch - ObservablePatch to execute
-   */
-  patch(patch: ObservablePatch): this
-}
-
-/** @public */
-export declare class ObservableUsersClient implements ObservableUsersClientType {
-  #private
-  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
-  /**
-   * Fetch a user by user ID
-   *
-   * @param id - User ID of the user to fetch. If `me` is provided, a minimal response including the users role is returned.
-   */
-  getById<T extends 'me' | string>(
-    id: T,
-  ): Observable<T extends 'me' ? CurrentSanityUser : SanityUser>
-}
-
-/** @internal */
-declare interface ObservableUsersClientType {
-  /**
-   * Fetch a user by user ID
-   *
-   * @param id - User ID of the user to fetch. If `me` is provided, a minimal response including the users role is returned.
-   */
-  getById<T extends 'me' | string>(
-    id: T,
-  ): Observable<T extends 'me' ? CurrentSanityUser : SanityUser>
-}
-
-/**
- * The listener connection has been established
- * note: it's usually a better option to use the 'welcome' event
- * @public
- */
-export declare type OpenEvent = {
-  type: 'open'
-}
-
-/** @public */
-export declare class Patch extends BasePatch {
-  #private
-  constructor(selection: PatchSelection, operations?: PatchOperations, client?: SanityClient)
-  /**
-   * Clones the patch
-   */
-  clone(): Patch
-  /**
-   * Commit the patch, returning a promise that resolves to the first patched document
-   *
-   * @param options - Options for the mutation operation
-   */
-  commit<R extends Record<string, Any> = Record<string, Any>>(
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * Commit the patch, returning a promise that resolves to an array of the mutated documents
-   *
-   * @param options - Options for the mutation operation
-   */
-  commit<R extends Record<string, Any> = Record<string, Any>>(
-    options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
-  /**
-   * Commit the patch, returning a promise that resolves to a mutation result object
-   *
-   * @param options - Options for the mutation operation
-   */
-  commit(options: FirstDocumentIdMutationOptions): Promise<SingleMutationResult>
-  /**
-   * Commit the patch, returning a promise that resolves to a mutation result object
-   *
-   * @param options - Options for the mutation operation
-   */
-  commit(options: AllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
-  /**
-   * Commit the patch, returning a promise that resolves to the first patched document
-   *
-   * @param options - Options for the mutation operation
-   */
-  commit<R extends Record<string, Any> = Record<string, Any>>(
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
-}
-
-/** @public */
-export declare type PatchBuilder = (patch: Patch) => Patch
-
-/** @internal */
-export declare type PatchMutationOperation = PatchOperations & MutationSelection
-
-/** @internal */
-export declare interface PatchOperations {
-  set?: {
-    [key: string]: Any
-  }
-  setIfMissing?: {
-    [key: string]: Any
-  }
-  diffMatchPatch?: {
-    [key: string]: Any
-  }
-  unset?: string[]
-  inc?: {
-    [key: string]: number
-  }
-  dec?: {
-    [key: string]: number
-  }
-  insert?: InsertPatch
-  ifRevisionID?: string
-}
-
-/** @internal */
-export declare type PatchSelection = string | string[] | MutationSelection
-
-/** @public */
-declare interface ProgressEvent_2 {
-  type: 'progress'
-  stage: 'upload' | 'download'
-  percent: number
-  total?: number
-  loaded?: number
-  lengthComputable: boolean
-}
-export {ProgressEvent_2 as ProgressEvent}
-
-/** @internal */
-export declare class ProjectsClient implements ProjectsClientType {
-  #private
-  constructor(client: SanityClient, httpRequest: HttpRequest)
-  /**
-   * Fetch a list of projects the authenticated user has access to.
-   *
-   * @param options - Options for the list request
-   * @param options.includeMembers - Whether to include members in the response (default: true)
-   */
-  list(options?: {includeMembers?: true}): Promise<SanityProject[]>
-  list(options?: {includeMembers?: false}): Promise<Omit<SanityProject, 'members'>[]>
-  /**
-   * Fetch a project by project ID
-   *
-   * @param projectId - ID of the project to fetch
-   */
-  getById(projectId: string): Promise<SanityProject>
-}
-
-/** @internal */
-declare interface ProjectsClientType {
-  /**
-   * Fetch a list of projects the authenticated user has access to.
-   *
-   * @param options - Options for the list request
-   * @param options.includeMembers - Whether to include members in the response (default: true)
-   */
-  list(options?: {includeMembers?: true}): Promise<SanityProject[]>
-  list(options?: {includeMembers?: false}): Promise<Omit<SanityProject, 'members'>[]>
-  list(options?: {includeMembers?: boolean}): Promise<SanityProject[]>
-  /**
-   * Fetch a project by project ID
-   *
-   * @param projectId - ID of the project to fetch
-   */
-  getById(projectId: string): Promise<SanityProject>
-}
-
-/**
- * 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
-  /**
-   * Published revision ID to match
-   */
-  ifPublishedRevisionId?: string
-}
-
-/** @public */
-export declare type QueryOptions =
-  | FilteredResponseQueryOptions
-  | UnfilteredResponseQueryOptions
-  | UnfilteredResponseWithoutQuery
-
-/** @public */
-export declare interface QueryParams {
-  [key: string]: any
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  body?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  cache?: 'next' extends keyof RequestInit ? never : any
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  filterResponse?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  headers?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  method?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  next?: 'next' extends keyof RequestInit ? never : any
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  perspective?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  query?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  resultSourceMap?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  returnQuery?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  signal?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  stega?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  tag?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  timeout?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  token?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  useCdn?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  lastLiveEventId?: never
-  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
-  cacheMode?: never
-}
-
-/**
- * This type can be used with `client.fetch` to indicate that the query has no GROQ parameters.
- * @public
- */
-export declare type QueryWithoutParams = Record<string, never> | undefined
-
-/** @public */
-export declare type RawQuerylessQueryResponse<R> = Omit<RawQueryResponse<R>, 'query'>
-
-/** @public */
-export declare interface RawQueryResponse<R> {
-  query: string
-  ms: number
-  result: R
-  resultSourceMap?: ContentSourceMap
-  /** Requires `apiVersion` to be `2021-03-25` or later. */
-  syncTags?: SyncTag[]
-}
-
-/** @internal */
-export declare interface RawRequestOptions {
-  url?: string
-  uri?: string
-  method?: string
-  token?: string
-  json?: boolean
-  tag?: string
-  useGlobalApi?: boolean
-  withCredentials?: boolean
-  query?: {
-    [key: string]: string | string[]
-  }
-  headers?: {
-    [key: string]: string
-  }
-  timeout?: number
-  proxy?: string
-  body?: Any
-  maxRedirects?: number
-  signal?: AbortSignal
-}
-
-/**
- * The listener has been disconnected, and a reconnect attempt is scheduled.
- *
- * @public
- */
-export declare type ReconnectEvent = {
-  type: 'reconnect'
-}
-
-/**
- * @public
- * @deprecated – The `r`-prefix is not required, use `string` instead
- */
-export declare type ReleaseId = `r${string}`
-
-/**
- * Replaces an existing draft document.
- * At least one of the draft or published versions of the document must exist.
- *
- * @public
- */
-export declare type ReplaceDraftAction = {
-  actionType: 'sanity.action.document.replaceDraft'
-  /**
-   * Published document ID to create draft from, if draft does not exist
-   */
-  publishedId: string
-  /**
-   * Document to create if it does not already exist. Requires `_id` and `_type` properties.
-   */
-  attributes: IdentifiedSanityDocumentStub
-}
-
-/** @public */
-export declare const requester: Requester
-
-/** @internal */
-export declare interface RequestObservableOptions extends Omit<RequestOptions, 'url'> {
-  url?: string
-  uri?: string
-  canUseCdn?: boolean
-  useCdn?: boolean
-  tag?: string
-  returnQuery?: boolean
-  resultSourceMap?: boolean | 'withKeyArraySelector'
-  perspective?: ClientPerspective
-  lastLiveEventId?: string
-  cacheMode?: 'noStale'
-}
-
-/** @public */
-export declare interface RequestOptions {
-  timeout?: number
-  token?: string
-  tag?: string
-  headers?: Record<string, string>
-  method?: string
-  query?: Any
-  body?: Any
-  signal?: AbortSignal
-}
-
-export {ResolveStudioUrl}
-
-/** @public */
-export declare interface ResponseEvent<T = unknown> {
-  type: 'response'
-  body: T
-  url: string
-  method: string
-  statusCode: number
-  statusMessage?: string
-  headers: Record<string, string>
-}
-
-/** @public */
-export declare interface ResponseQueryOptions extends RequestOptions {
-  perspective?: ClientPerspective
-  resultSourceMap?: boolean | 'withKeyArraySelector'
-  returnQuery?: boolean
-  useCdn?: boolean
-  stega?: boolean | StegaConfig
-  cache?: 'next' extends keyof RequestInit ? RequestInit['cache'] : never
-  next?: ('next' extends keyof RequestInit ? RequestInit : never)['next']
-  lastLiveEventId?: string | string[] | null
-  /**
-   * When set to `noStale`, APICDN will not return a cached response if the content is stale.
-   * Tradeoff between latency and freshness of content.
-   *
-   * Only to be used with live content queries and when useCdn is true.
-   */
-  cacheMode?: 'noStale'
-}
-
-/** @internal */
-export declare interface SanityAssetDocument extends SanityDocument {
-  url: string
-  path: string
-  size: number
-  assetId: string
-  mimeType: string
-  sha1hash: string
-  extension: string
-  uploadId?: string
-  originalFilename?: string
-}
-
-/** @public */
-export declare class SanityClient implements SanityClientType {
-  #private
-  assets: AssetsClient
-  datasets: DatasetsClient
-  live: LiveClient
-  projects: ProjectsClient
-  users: UsersClient
-  /**
-   * Observable version of the Sanity client, with the same configuration as the promise-based one
-   */
-  observable: ObservableSanityClient
-  listen: typeof _listen
-  constructor(httpRequest: HttpRequest, config?: ClientConfig)
-  /**
-   * Clone the client - returns a new instance
-   */
-  clone(): SanityClient
-  /**
-   * Returns the current client configuration
-   */
-  config(): InitializedClientConfig
-  /**
-   * Reconfigure the client. Note that this _mutates_ the current client.
-   */
-  config(newConfig?: Partial<ClientConfig>): this
-  /**
-   * Clone the client with a new (partial) configuration.
-   *
-   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
-   */
-  withConfig(newConfig?: Partial<ClientConfig>): SanityClient
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   */
-  fetch<
-    R = Any,
-    Q extends QueryWithoutParams = QueryWithoutParams,
-    const G extends string = string,
-  >(query: G, params?: Q | QueryWithoutParams): Promise<ClientReturn<G, R>>
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Optional request options
-   */
-  fetch<
-    R = Any,
-    Q extends QueryWithoutParams | QueryParams = QueryParams,
-    const G extends string = string,
-  >(
-    query: G,
-    params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
-    options?: FilteredResponseQueryOptions,
-  ): Promise<ClientReturn<G, R>>
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Request options
-   */
-  fetch<
-    R = Any,
-    Q extends QueryWithoutParams | QueryParams = QueryParams,
-    const G extends string = string,
-  >(
-    query: G,
-    params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
-    options: UnfilteredResponseQueryOptions,
-  ): Promise<RawQueryResponse<ClientReturn<G, R>>>
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Request options
-   */
-  fetch<
-    R = Any,
-    Q extends QueryWithoutParams | QueryParams = QueryParams,
-    const G extends string = string,
-  >(
-    query: G,
-    params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
-    options: UnfilteredResponseWithoutQuery,
-  ): Promise<RawQuerylessQueryResponse<ClientReturn<G, R>>>
-  /**
-   * Fetch a single document with the given ID.
-   *
-   * @param id - Document ID to fetch
-   * @param options - Request options
-   */
-  getDocument<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options?: {
-      signal?: AbortSignal
-      tag?: string
-    },
-  ): Promise<SanityDocument<R> | undefined>
-  /**
-   * Fetch multiple documents in one request.
-   * Should be used sparingly - performing a query is usually a better option.
-   * The order/position of documents is preserved based on the original array of IDs.
-   * If any of the documents are missing, they will be replaced by a `null` entry in the returned array
-   *
-   * @param ids - Document IDs to fetch
-   * @param options - Request options
-   */
-  getDocuments<R extends Record<string, Any> = Record<string, Any>>(
-    ids: string[],
-    options?: {
-      signal?: AbortSignal
-      tag?: string
-    },
-  ): Promise<(SanityDocument<R> | null)[]>
-  /**
-   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
-   * Returns a promise that resolves to the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
-   * Returns a promise that resolves to an array containing the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
-  /**
-   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
-   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options: FirstDocumentIdMutationOptions,
-  ): Promise<SingleMutationResult>
-  /**
-   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
-   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options: AllDocumentIdsMutationOptions,
-  ): Promise<MultipleMutationResult>
-  /**
-   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
-   * Returns a promise that resolves to the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * Create a document if no document with the same ID already exists.
-   * Returns a promise that resolves to the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * Create a document if no document with the same ID already exists.
-   * Returns a promise that resolves to an array containing the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
-  /**
-   * Create a document if no document with the same ID already exists.
-   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentIdMutationOptions,
-  ): Promise<SingleMutationResult>
-  /**
-   * Create a document if no document with the same ID already exists.
-   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentIdsMutationOptions,
-  ): Promise<MultipleMutationResult>
-  /**
-   * Create a document if no document with the same ID already exists.
-   * Returns a promise that resolves to the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * Create a document if it does not exist, or replace a document with the same document ID
-   * Returns a promise that resolves to the created document.
-   *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
-   */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * Create a document if it does not exist, or replace a document with the same document ID
-   * Returns a promise that resolves to an array containing the created document.
-   *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
-   */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
-  /**
-   * Create a document if it does not exist, or replace a document with the same document ID
-   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
-   *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
-   */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentIdMutationOptions,
-  ): Promise<SingleMutationResult>
-  /**
-   * Create a document if it does not exist, or replace a document with the same document ID
-   * Returns a promise that resolves to a mutation result object containing the created document ID.
-   *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
-   */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentIdsMutationOptions,
-  ): Promise<MultipleMutationResult>
-  /**
-   * Create a document if it does not exist, or replace a document with the same document ID
-   * Returns a promise that resolves to the created document.
-   *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
-   */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * Deletes a document with the given document ID.
-   * Returns a promise that resolves to the deleted document.
-   *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
-   */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * Deletes a document with the given document ID.
-   * Returns a promise that resolves to an array containing the deleted document.
+   * Fetch a project by project ID
    *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * @param projectId - ID of the project to fetch
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
+  getById(projectId: string): Promise<SanityProject>
+}
+
+/**
+ * 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'
   /**
-   * Deletes a document with the given document ID.
-   * Returns a promise that resolves to a mutation result object containing the deleted document ID.
-   *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * Draft document ID to publish
    */
-  delete(id: string, options: FirstDocumentIdMutationOptions): Promise<SingleMutationResult>
+  draftId: string
   /**
-   * Deletes a document with the given document ID.
-   * Returns a promise that resolves to a mutation result object containing the deleted document ID.
-   *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * Draft revision ID to match
    */
-  delete(id: string, options: AllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
+  ifDraftRevisionId?: string
   /**
-   * Deletes a document with the given document ID.
-   * Returns a promise that resolves to the deleted document.
-   *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * Published document ID to replace
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
+  publishedId: string
   /**
-   * Deletes one or more documents matching the given query or document ID.
-   * Returns a promise that resolves to first deleted document.
-   *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * Published revision ID to match
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
+  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
+  | UnfilteredResponseQueryOptions
+  | UnfilteredResponseWithoutQuery
+
+/** @public */
+export declare interface QueryParams {
+  [key: string]: any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  body?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  cache?: 'next' extends keyof RequestInit ? never : any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  filterResponse?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  headers?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  method?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  next?: 'next' extends keyof RequestInit ? never : any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  perspective?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  query?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  resultSourceMap?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  returnQuery?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  signal?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  stega?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  tag?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  timeout?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  token?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  useCdn?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  lastLiveEventId?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  cacheMode?: never
+}
+
+/**
+ * This type can be used with `client.fetch` to indicate that the query has no GROQ parameters.
+ * @public
+ */
+export declare type QueryWithoutParams = Record<string, never> | undefined
+
+/** @public */
+export declare type RawQuerylessQueryResponse<R> = Omit<RawQueryResponse<R>, 'query'>
+
+/** @public */
+export declare interface RawQueryResponse<R> {
+  query: string
+  ms: number
+  result: R
+  resultSourceMap?: ContentSourceMap
+  /** Requires `apiVersion` to be `2021-03-25` or later. */
+  syncTags?: SyncTag[]
+}
+
+/** @internal */
+export declare interface RawRequestOptions {
+  url?: string
+  uri?: string
+  method?: string
+  token?: string
+  json?: boolean
+  tag?: string
+  useGlobalApi?: boolean
+  withCredentials?: boolean
+  query?: {
+    [key: string]: string | string[]
+  }
+  headers?: {
+    [key: string]: string
+  }
+  timeout?: number
+  proxy?: string
+  body?: Any
+  maxRedirects?: number
+  signal?: AbortSignal
+}
+
+/**
+ * The listener has been disconnected, and a reconnect attempt is scheduled.
+ *
+ * @public
+ */
+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 {
   /**
-   * Deletes one or more documents matching the given query or document ID.
-   * Returns a promise that resolves to an array containing the deleted documents.
-   *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * typically
+   * `_.releases.<name>`
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
-    options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
+  _id: string
   /**
-   * Deletes one or more documents matching the given query or document ID.
-   * Returns a promise that resolves to a mutation result object containing the ID of the first deleted document.
-   *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * where a release has _id `_.releases.foo`, the name is `foo`
    */
-  delete(
-    selection: MutationSelection,
-    options: FirstDocumentIdMutationOptions,
-  ): Promise<SingleMutationResult>
+  name: string
+  _type: 'system.release'
+  _createdAt: string
+  _updatedAt: string
+  _rev: string
+  state: ReleaseState
+  error?: {
+    message: string
+  }
+  finalDocumentStates?: {
+    /** Document ID */
+    id: string
+  }[]
   /**
-   * Deletes one or more documents matching the given query or document ID.
-   * Returns a promise that resolves to a mutation result object containing the document IDs that were deleted.
-   *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * If defined, it takes precedence over the intendedPublishAt, the state should be 'scheduled'
    */
-  delete(
-    selection: MutationSelection,
-    options: AllDocumentIdsMutationOptions,
-  ): Promise<MultipleMutationResult>
+  publishAt?: string
   /**
-   * Deletes one or more documents matching the given query or document ID.
-   * Returns a promise that resolves to first deleted document.
-   *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * If defined, it provides the time the release was actually published
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
+  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)
   /**
-   * Perform mutation operations against the configured dataset
-   * Returns a promise that resolves to the first mutated document.
-   *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
+   * @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>
   /**
-   * Perform mutation operations against the configured dataset.
-   * Returns a promise that resolves to an array of the mutated documents.
+   * @public
    *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
-    options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
-  /**
-   * Perform mutation operations against the configured dataset
-   * Returns a promise that resolves to a mutation result object containing the document ID of the first mutated document.
+   * Creates a new release under the given id, with metadata.
    *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
-    options: FirstDocumentIdMutationOptions,
-  ): Promise<SingleMutationResult>
+   * @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']
+    }
+  >
   /**
-   * Perform mutation operations against the configured dataset
-   * Returns a promise that resolves to a mutation result object containing the mutated document IDs.
+   * @public
    *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
-    options: AllDocumentIdsMutationOptions,
-  ): Promise<MultipleMutationResult>
-  /**
-   * Perform mutation operations against the configured dataset
-   * Returns a promise that resolves to the first mutated document.
+   * Edits an existing release, updating the metadata.
    *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * Create a new buildable patch of operations to perform
+   * @category Releases
    *
-   * @param documentId - Document ID to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
+   * @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`.
    */
-  patch(documentId: string, operations?: PatchOperations): Patch
+  edit(
+    {
+      releaseId,
+      patch,
+    }: {
+      releaseId: string
+      patch: PatchOperations
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
   /**
-   * Create a new buildable patch of operations to perform
+   * @public
    *
-   * @param documentIds - Array of document IDs to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
+   * 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`.
    */
-  patch(documentIds: string[], operations?: PatchOperations): Patch
+  publish(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
   /**
-   * Create a new buildable patch of operations to perform
+   * @public
    *
-   * @param selection - An object with `query` and optional `params`, defining which document(s) to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
+   * 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`.
    */
-  patch(selection: MutationSelection, operations?: PatchOperations): Patch
+  archive(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
   /**
-   * Create a new transaction of mutations
+   * @public
    *
-   * @param operations - Optional array of mutation operations to initialize the transaction instance with
+   * 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`.
    */
-  transaction<R extends Record<string, Any> = Record<string, Any>>(
-    operations?: Mutation<R>[],
-  ): Transaction
+  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>
   /**
-   * Perform action operations against the configured dataset
-   * Returns a promise that resolves to the transaction result
+   * @public
    *
-   * @param operations - Action operation(s) to execute
-   * @param options - Action options
+   * 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`.
    */
-  action(
-    operations: Action | Action[],
+  unschedule(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
     options?: BaseActionOptions,
-  ): Promise<SingleActionResult | MultipleActionResult>
+  ): Promise<SingleActionResult>
   /**
-   * Perform a request against the Sanity API
-   * NOTE: Only use this for Sanity API endpoints, not for your own APIs!
+   * @public
    *
-   * @param options - Request options
-   * @returns Promise resolving to the response body
+   * 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`.
    */
-  request<R = Any>(options: RawRequestOptions): Promise<R>
+  delete(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
   /**
-   * Perform an HTTP request a `/data` sub-endpoint
-   * NOTE: Considered internal, thus marked as deprecated. Use `request` instead.
+   * @public
    *
-   * @deprecated - Use `request()` or your own HTTP library instead
-   * @param endpoint - Endpoint to hit (mutate, query etc)
-   * @param body - Request body
-   * @param options - Request options
-   * @internal
+   * 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.
    */
-  dataRequest(endpoint: string, body: unknown, options?: BaseMutationOptions): Promise<Any>
+  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'
   /**
-   * Get a Sanity API URL for the URI provided
-   *
-   * @param uri - URI/path to build URL for
-   * @param canUseCdn - Whether or not to allow using the API CDN for this route
+   * Published document ID to create draft from, if draft does not exist
    */
-  getUrl(uri: string, canUseCdn?: boolean): string
+  publishedId: string
   /**
-   * Get a Sanity API URL for the data operation and path provided
-   *
-   * @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
-   * @param path - Path to append after the operation
+   * Document to create if it does not already exist. Requires `_id` and `_type` properties.
    */
-  getDataUrl(operation: string, path?: string): string
+  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
+
+/** @internal */
+export declare interface RequestObservableOptions extends Omit<RequestOptions, 'url'> {
+  url?: string
+  uri?: string
+  canUseCdn?: boolean
+  useCdn?: boolean
+  tag?: string
+  returnQuery?: boolean
+  resultSourceMap?: boolean | 'withKeyArraySelector'
+  perspective?: ClientPerspective
+  lastLiveEventId?: string
+  cacheMode?: 'noStale'
+}
+
+/** @public */
+export declare interface RequestOptions {
+  timeout?: number
+  token?: string
+  tag?: string
+  headers?: Record<string, string>
+  method?: string
+  query?: Any
+  body?: Any
+  signal?: AbortSignal
 }
 
-/**
- * Shared base type for the `SanityClient` and `ObservableSanityClient` classes.
- * TODO: refactor the Promise and Observable differences to use generics so we no longer suffer from all this duplication in TS docs
- */
-declare interface SanityClientBase {
-  live: LiveClient
-  listen: typeof _listen
-  /**
-   * Get a Sanity API URL for the URI provided
-   *
-   * @param uri - URI/path to build URL for
-   * @param canUseCdn - Whether or not to allow using the API CDN for this route
-   */
-  getUrl(uri: string, canUseCdn?: boolean): string
+export {ResolveStudioUrl}
+
+/** @public */
+export declare interface ResponseEvent<T = unknown> {
+  type: 'response'
+  body: T
+  url: string
+  method: string
+  statusCode: number
+  statusMessage?: string
+  headers: Record<string, string>
+}
+
+/** @public */
+export declare interface ResponseQueryOptions extends RequestOptions {
+  perspective?: ClientPerspective
+  resultSourceMap?: boolean | 'withKeyArraySelector'
+  returnQuery?: boolean
+  useCdn?: boolean
+  stega?: boolean | StegaConfig
+  cache?: 'next' extends keyof RequestInit ? RequestInit['cache'] : never
+  next?: ('next' extends keyof RequestInit ? RequestInit : never)['next']
+  lastLiveEventId?: string | string[] | null
   /**
-   * Get a Sanity API URL for the data operation and path provided
+   * When set to `noStale`, APICDN will not return a cached response if the content is stale.
+   * Tradeoff between latency and freshness of content.
    *
-   * @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
-   * @param path - Path to append after the operation
+   * Only to be used with live content queries and when useCdn is true.
    */
-  getDataUrl(operation: string, path?: string): string
+  cacheMode?: 'noStale'
 }
 
-/**
- * The interface implemented by the `SanityClient` class.
- * When writing code that wants to take an instance of `SanityClient` as input it's better to use this type,
- * as the `SanityClient` class has private properties and thus TypeScrict will consider the type incompatible
- * in cases where you might have multiple `@sanity/client` instances in your node_modules.
- * @public
- */
-export declare interface SanityClientType extends SanityClientBase {
-  assets: AssetsClientType
-  datasets: DatasetsClientType
-  projects: ProjectsClientType
-  users: UsersClientType
+/** @internal */
+export declare interface SanityAssetDocument extends SanityDocument {
+  url: string
+  path: string
+  size: number
+  assetId: string
+  mimeType: string
+  sha1hash: string
+  extension: string
+  uploadId?: string
+  originalFilename?: string
+}
+
+/** @public */
+export declare class SanityClient {
+  #private
+  assets: AssetsClient
+  datasets: DatasetsClient
+  live: LiveClient
+  projects: ProjectsClient
+  users: UsersClient
+  agent: {
+    action: AgentActionsClient
+  }
+  releases: ReleasesClient
   /**
    * Observable version of the Sanity client, with the same configuration as the promise-based one
    */
-  observable: ObservableSanityClientType
+  observable: ObservableSanityClient
+  /**
+   * Instance properties
+   */
+  listen: typeof _listen
+  constructor(httpRequest: HttpRequest, config?: ClientConfig)
   /**
    * Clone the client - returns a new instance
    */
-  clone(): SanityClientType
+  clone(): SanityClient
   /**
    * Returns the current client configuration
    */
@@ -3665,13 +4062,13 @@ export declare interface SanityClientType extends SanityClientBase {
   /**
    * Reconfigure the client. Note that this _mutates_ the current client.
    */
-  config(newConfig?: Partial<ClientConfig>): SanityClientType
+  config(newConfig?: Partial<ClientConfig>): this
   /**
    * Clone the client with a new (partial) configuration.
    *
    * @param newConfig - New client configuration properties, shallowly merged with existing configuration
    */
-  withConfig(newConfig?: Partial<ClientConfig>): SanityClientType
+  withConfig(newConfig?: Partial<ClientConfig>): SanityClient
   /**
    * Perform a GROQ-query against the configured dataset.
    *
@@ -3681,10 +4078,7 @@ export declare interface SanityClientType extends SanityClientBase {
     R = Any,
     Q extends QueryWithoutParams = QueryWithoutParams,
     const G extends string = string,
-  >(
-    query: G,
-    params?: Q | QueryWithoutParams,
-  ): Promise<ClientReturn<G, R>>
+  >(query: G, params?: Q | QueryWithoutParams): Promise<ClientReturn<G, R>>
   /**
    * Perform a GROQ-query against the configured dataset.
    *
@@ -3744,6 +4138,7 @@ export declare interface SanityClientType extends SanityClientBase {
     options?: {
       signal?: AbortSignal
       tag?: string
+      releaseId?: string
     },
   ): Promise<SanityDocument<R> | undefined>
   /**
@@ -3927,6 +4322,90 @@ export declare interface SanityClientType extends SanityClientBase {
     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.
@@ -4031,6 +4510,157 @@ export declare interface SanityClientType extends SanityClientBase {
     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.
@@ -4071,7 +4701,7 @@ export declare interface SanityClientType extends SanityClientBase {
    * @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>
@@ -4110,14 +4740,6 @@ export declare interface SanityClientType extends SanityClientBase {
    * @returns Patch instance - call `.commit()` to perform the operations defined
    */
   patch(selection: MutationSelection, operations?: PatchOperations): Patch
-  /**
-   * Create a new buildable patch of operations to perform
-   *
-   * @param selection - Document ID, an array of document IDs, or an object with `query` and optional `params`, defining which document(s) to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
-   */
-  patch(selection: PatchSelection, operations?: PatchOperations): Patch
   /**
    * Create a new transaction of mutations
    *
@@ -4156,6 +4778,20 @@ export declare interface SanityClientType extends SanityClientBase {
    * @internal
    */
   dataRequest(endpoint: string, body: unknown, options?: BaseMutationOptions): Promise<Any>
+  /**
+   * Get a Sanity API URL for the URI provided
+   *
+   * @param uri - URI/path to build URL for
+   * @param canUseCdn - Whether or not to allow using the API CDN for this route
+   */
+  getUrl(uri: string, canUseCdn?: boolean): string
+  /**
+   * Get a Sanity API URL for the data operation and path provided
+   *
+   * @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
+   * @param path - Path to append after the operation
+   */
+  getDataUrl(operation: string, path?: string): string
 }
 
 /** @internal */
@@ -4281,6 +4917,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']
@@ -4456,6 +5103,319 @@ export declare type TransactionMutationOptions =
   | TransactionAllDocumentsMutationOptions
   | TransactionAllDocumentIdsMutationOptions
 
+/** @beta */
+export declare type TransformDocument<T extends Record<string, Any> = Record<string, Any>> =
+  | TransformDocumentSync<T>
+  | TransformDocumentAsync
+
+/** @beta */
+declare type TransformDocumentAsync = TransformRequestBase & AgentActionAsync
+
+/** @beta */
+declare type TransformDocumentSync<T extends Record<string, Any> = Record<string, Any>> =
+  TransformRequestBase & AgentActionSync
+
+/** @beta */
+declare interface TransformRequestBase extends AgentActionRequestBase {
+  /** schemaId as reported by sanity deploy / sanity schema store */
+  schemaId: string
+  /**
+   * The source document the transformation will use as input.
+   */
+  documentId: string
+  /**
+   * The source document's content is first copied to the target,
+   * then it is transformed according to the instruction.
+   *
+   * When omitted, the source document (documentId) is also the target document.
+   */
+  targetDocument?: TransformTargetDocument
+  /**
+   * Instruct the LLM how to transform the input to th output.
+   *
+   * String template using $variable from instructionParams.
+   *
+   * Capped to 2000 characters, after variables has been injected.
+   * */
+  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 ---\nGenerate the full article.',
+   *   instructionParams: {
+   *     topic: 'Grapefruit'
+   *   },
+   * })
+   * ```
+   * ##### Object-form
+   *
+   * ```ts
+   * client.agent.action.transform({
+   *   schemaId,
+   *   documentId,
+   *   instruction: 'Give the following topic:\n $topic \n ---\nGenerate the full article.',
+   *   instructionParams: {
+   *     topic: {
+   *       type: 'constant',
+   *       value: 'Grapefruit'
+   *     },
+   *   },
+   * })
+   * ```
+   * #### Field
+   * ```ts
+   * client.agent.action.transform({
+   *   schemaId,
+   *   documentId,
+   *   instruction: 'Give the following field value:\n $pte \n ---\nGenerate keywords.',
+   *   instructionParams: {
+   *     pte: {
+   *       type: 'field',
+   *       path: ['pteField'],
+   *     },
+   *   },
+   *   target: {path: 'keywords' }
+   * })
+   * ```
+   * #### Document
+   * ```ts
+   * client.agent.action.transform({
+   *   schemaId,
+   *   documentId,
+   *   instruction: 'Give the following document value:\n $document \n ---\nGenerate keywords.',
+   *   instructionParams: {
+   *     document: {
+   *       type: 'document',
+   *     },
+   *   },
+   *   target: {path: 'keywords' }
+   * })
+   * ```
+   *
+   * #### GROQ
+   * ```ts
+   * client.agent.action.transform({
+   *   schemaId,
+   *   documentId,
+   *   instruction: 'Give the following list of titles:\n $list \n ---\nGenerate a similar title.',
+   *   instructionParams: {
+   *     list: {
+   *       type: 'groq',
+   *       query: '* [_type==$type].title',
+   *       params: {type: 'article'}
+   *     },
+   *   },
+   *   target: {path: 'title'}
+   * })
+   * ```
+   * */
+  instructionParams?: AgentActionParams
+  /**
+   * Target defines which parts of the document will be affected by the instruction.
+   * It can be an array, so multiple parts of the document can be separately configured in detail.
+   *
+   * Omitting target implies that the document itself is the root.
+   *
+   * Notes:
+   * - instruction can only affect fields up to `maxPathDepth`
+   * - when multiple targets are provided, they will be coalesced into a single target sharing a common target root.
+   * It is therefor an error to provide conflicting include/exclude across targets (ie, include title in one, and exclude it in another)
+   *
+   * Default max depth for transform: 12
+   * @see AgentActionRequestBase#conditionalPaths
+   */
+  target?: TransformTarget | TransformTarget[]
+}
+
+/**  @beta */
+export declare interface TransformTarget extends AgentActionTarget {
+  /**
+   * Specifies a tailored instruction of this target.
+   *
+   * string template using $variable from instructionParams.
+   * */
+  instruction?: string
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   *
+   * When `include` is specified, only segments explicitly listed will be included.
+   *
+   * Fields or array items not on the include list, are implicitly excluded.
+   */
+  include?: (AgentActionPathSegment | TransformTargetInclude)[]
+}
+
+/**  @beta */
+export declare type TransformTargetDocument =
+  | {
+      operation: 'edit'
+      _id: string
+    }
+  | {
+      operation: 'create'
+      _id?: string
+    }
+  | {
+      operation: 'createIfNotExists'
+      _id: string
+    }
+  | {
+      operation: 'createOrReplace'
+      _id: string
+    }
+
+/**  @beta */
+export declare interface TransformTargetInclude extends AgentActionTargetInclude {
+  /**
+   * Specifies a tailored instruction of this target.
+   *
+   * string template using $variable from instructionParams  */
+  instruction?: string
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   *
+   * When `include` is specified, only segments explicitly listed will be included.
+   *
+   * Fields or array items not on the include list, are implicitly excluded.
+   */
+  include?: (AgentActionPathSegment | TransformTargetInclude)[]
+}
+
+/** @beta */
+export declare type TranslateDocument<T extends Record<string, Any> = Record<string, Any>> =
+  | TranslateDocumentSync<T>
+  | TranslateDocumentAsync
+
+/** @beta */
+declare type TranslateDocumentAsync = TranslateRequestBase & AgentActionAsync
+
+/** @beta */
+declare type TranslateDocumentSync<T extends Record<string, Any> = Record<string, Any>> =
+  TranslateRequestBase & AgentActionSync
+
+/**  @beta */
+declare interface TranslateLanguage {
+  /**
+   * Language code
+   */
+  id: string
+  /**
+   * While optional, it is recommended to provide a language title
+   */
+  title?: string
+}
+
+/**  @beta */
+declare interface TranslateRequestBase extends AgentActionRequestBase {
+  /** schemaId as reported by sanity deploy / sanity schema store */
+  schemaId: string
+  /**
+   * The source document the transformation will use as input.
+   */
+  documentId: string
+  /**
+   * The target document will first get content copied over from the source,
+   * then it is translated according to the instruction.
+   *
+   * When omitted, the source document (documentId) is also the target document.
+   */
+  targetDocument?: TransformTargetDocument
+  /**
+   * While optional, it is recommended
+   */
+  fromLanguage?: TranslateLanguage
+  toLanguage: TranslateLanguage
+  /**
+   * `styleGuide` can be used to tailor how the translation should be preformed.
+   *
+   * String template using $variable from styleGuideParams.
+   *
+   * Capped to 2000 characters, after variables has been injected.
+   *
+   * @see #protectedPhrases
+   */
+  styleGuide?: string
+  /** param values for the string template, keys are the variable name, ie if the template has "$variable", one key must be "variable" */
+  styleGuideParams?: AgentActionParams
+  /**
+   * When the input string contains any phrase from `protectedPhrases`, the LLM will be instructed not
+   * to translate them.
+   *
+   * It is recommended to use `protectedPhrases` instead of `styleGuide` for deny-list words and phrases,
+   * since it keeps token cost low, resulting in faster responses, and limits how much information the LLM
+   * has to process, since only phrases that are actually in the input string will be included in the final prompt.
+   */
+  protectedPhrases?: string[]
+  /**
+   * When specified, the `toLanguage.id` will be stored in the specified path in the target document.
+   *
+   * The file _can_ be hidden: true (unlike other fields in the target, which will be ignored)
+   */
+  languageFieldPath?: AgentActionPathSegment | AgentActionPath
+  /**
+   * Target defines which parts of the document will be affected by the instruction.
+   * It can be an array, so multiple parts of the document can be separately configured in detail.
+   *
+   * Omitting target implies that the document itself is the root.
+   *
+   * Notes:
+   * - instruction can only affect fields up to `maxPathDepth`
+   * - when multiple targets are provided, they will be coalesced into a single target sharing a common target root.
+   * It is therefor an error to provide conflicting include/exclude across targets (ie, include title in one, and exclude it in another)
+   *
+   * @see AgentActionRequestBase#conditionalPaths
+   */
+  target?: TranslateTarget | TranslateTarget[]
+}
+
+/**  @beta */
+export declare interface TranslateTarget extends AgentActionTarget {
+  /** string template using $variable from instructionParams  */
+  styleGuide?: string
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   *
+   * When `include` is specified, only segments explicitly listed will be included.
+   *
+   * Fields or array items not on the include list, are implicitly excluded.
+   */
+  include?: (AgentActionPathSegment | TranslateTargetInclude)[]
+}
+
+/**  @beta */
+export declare interface TranslateTargetInclude extends AgentActionTargetInclude {
+  /** string template using $variable from instructionParams  */
+  styleGuide?: string
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   *
+   * When `include` is specified, only segments explicitly listed will be included.
+   *
+   * Fields or array items not on the include list, are implicitly excluded.
+   */
+  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
@@ -4497,6 +5457,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}
@@ -4566,7 +5548,7 @@ export declare interface UploadClientConfig {
 }
 
 /** @public */
-export declare class UsersClient implements UsersClientType {
+export declare class UsersClient {
   #private
   constructor(client: SanityClient, httpRequest: HttpRequest)
   /**
@@ -4577,16 +5559,6 @@ export declare class UsersClient implements UsersClientType {
   getById<T extends 'me' | string>(id: T): Promise<T extends 'me' ? CurrentSanityUser : SanityUser>
 }
 
-/** @internal */
-declare interface UsersClientType {
-  /**
-   * Fetch a user by user ID
-   *
-   * @param id - User ID of the user to fetch. If `me` is provided, a minimal response including the users role is returned.
-   */
-  getById<T extends 'me' | string>(id: T): Promise<T extends 'me' ? CurrentSanityUser : SanityUser>
-}
-
 /**
  * @internal - it may have breaking changes in any release
  */
@@ -4594,6 +5566,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_.