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

package/dist/index.browser.d.ts

@@ -1,6 +1,7 @@
 import type {ContentSourceMapDocuments as ContentSourceMapDocuments_2} from '@sanity/client/csm'
 import {ContentSourceMapParsedPath} from '@sanity/client/csm'
 import {ContentSourceMapParsedPathKeyedSegment} from '@sanity/client/csm'
+import type {HttpContext} from 'get-it'
 import {Observable} from 'rxjs'
 import {Requester} from 'get-it'
 import type {ResolveStudioUrl} from '@sanity/client/csm'
@@ -19,14 +20,14 @@ export declare type Action =
   | DiscardAction
   | PublishAction
   | UnpublishAction
+  | VersionAction
+  | ReleaseAction
 
 /** @internal */
 export declare interface ActionError {
-  error: {
-    type: 'actionError'
-    description: string
-    items?: ActionErrorItem[]
-  }
+  type: 'actionError'
+  description: string
+  items?: ActionErrorItem[]
 }
 
 /** @internal */
@@ -53,15 +54,27 @@ declare interface AgentActionAsync {
 }
 
 /** @beta */
-export declare type AgentActionParam =
+export declare type AgentActionParam<
+  TParamConfig extends {
+    docIdRequired: boolean
+  } = {
+    docIdRequired: false
+  },
+> =
   | string
   | ConstantAgentActionParam
-  | FieldAgentActionParam
-  | DocumentAgentActionParam
+  | FieldAgentActionParam<TParamConfig>
+  | DocumentAgentActionParam<TParamConfig>
   | GroqAgentActionParam
 
 /** @beta */
-export declare type AgentActionParams = Record<string, AgentActionParam>
+export declare type AgentActionParams<
+  TParamConfig extends {
+    docIdRequired: boolean
+  } = {
+    docIdRequired: false
+  },
+> = Record<string, AgentActionParam<TParamConfig>>
 
 /**  @beta */
 export declare type AgentActionPath = AgentActionPathSegment[]
@@ -74,39 +87,7 @@ export declare type AgentActionPathSegment =
     }
 
 /** @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
-    }[]
-  }
+declare interface AgentActionRequestBase extends AgentActionSchema {
   /**
    * When localeSettings is provided on the request, instruct can write to date and datetime fields.
    * Otherwise, such fields will be ignored.
@@ -147,6 +128,68 @@ declare interface AgentActionRequestBase {
   temperature?: number
 }
 
+/** @beta */
+declare interface AgentActionSchema {
+  /** schemaId as reported by sanity deploy / sanity schema store */
+  schemaId: string
+  /**
+   * ### forcePublishedWrite: false (default)
+   * By default, agent actions will never write to a published document.
+   *
+   * Instead, they will force the use of a draft ID ("drafts.some-id") instead of the published ID ("some-id"),
+   * even when a published ID is provided.
+   *
+   * Actions will use state from an existing draft if it exists,
+   * or use the published document to create a draft, if no draft exists.
+   *
+   * Successful responses contains the _id that was mutated by the action.
+   *
+   *
+   * ### forcePublishedWrite: true
+   *
+   * When forcePublishedWrite: true an agent action will write to the exact id provided.
+   * The action will also not fallback to published state for draft ids.
+   *
+   *
+   * ### Versioned ids (releases)
+   *
+   * When an ID on the form "versions.<release>.some-id" is provided, agent actions will
+   * always behave as if `forcePublishedWrite: true`.
+   * That is, only the exact document state of the id provided is considered and mutated.
+   * */
+  forcePublishedWrite?: boolean
+  /**
+   * 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
+    }[]
+  }
+}
+
 /** @public */
 declare class AgentActionsClient {
   #private
@@ -190,6 +233,27 @@ declare class AgentActionsClient {
         }
       : IdentifiedSanityDocumentStub & DocumentShape
   >
+  /**
+   * Run a raw instruction and return the result either as text or json
+   * @param request - prompt request
+   */
+  prompt<const DocumentShape extends Record<string, Any>>(
+    request: PromptRequest<DocumentShape>,
+  ): Promise<(typeof request)['format'] extends 'json' ? DocumentShape : string>
+  /**
+   * Patch a document using a schema aware API.
+   * Does not use an LLM, but uses the schema to ensure paths and values matches the schema.
+   * @param request - instruction request
+   */
+  patch<DocumentShape extends Record<string, Any>>(
+    request: PatchDocument<DocumentShape>,
+  ): Promise<
+    (typeof request)['async'] extends true
+      ? {
+          _id: string
+        }
+      : IdentifiedSanityDocumentStub & DocumentShape
+  >
 }
 
 /** @beta */
@@ -313,6 +377,8 @@ export declare type AllDocumentsMutationOptions = BaseMutationOptions & {
  */
 export declare type Any = any
 
+declare type AnyNonNullable = Exclude<any, null | undefined>
+
 /** @internal */
 export declare interface ApiError {
   error: string
@@ -320,6 +386,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'
@@ -616,6 +692,12 @@ export declare interface ClientConfig {
    * Optional request tag prefix for all request tags
    */
   requestTagPrefix?: string
+  /**
+   * Optional default headers to include with all requests
+   *
+   * @remarks request-specific headers will override any default headers with the same name.
+   */
+  headers?: Record<string, string>
   ignoreBrowserTokenWarning?: boolean
   withCredentials?: boolean
   allowReconfigure?: boolean
@@ -678,6 +760,7 @@ declare type ClientConfigResource =
   | {
       type: 'view'
       id: string
+      useEmulate?: boolean
     }
 
 /** @public */
@@ -686,7 +769,7 @@ export declare class ClientError extends Error {
   statusCode: ErrorProps['statusCode']
   responseBody: ErrorProps['responseBody']
   details: ErrorProps['details']
-  constructor(res: Any)
+  constructor(res: Any, context?: HttpContext)
 }
 
 /** @public */
@@ -892,6 +975,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
@@ -987,6 +1093,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
@@ -1004,6 +1120,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'
@@ -1017,6 +1134,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,
@@ -1043,6 +1171,23 @@ export declare type DisconnectEvent = {
   reason: string
 }
 
+declare type DocIdParam<
+  TParamConfig extends {
+    docIdRequired: boolean
+  } = {
+    docIdRequired: false
+  },
+> = TParamConfig['docIdRequired'] extends true
+  ? {
+      documentId: string
+    }
+  : {
+      /**
+       * If omitted, implicitly uses the documentId of the instruction target
+       */
+      documentId?: string
+    }
+
 /**
  *
  * Includes a LLM-friendly version of the document in the instruction
@@ -1063,12 +1208,23 @@ export declare type DisconnectEvent = {
  *
  * @beta
  * */
-export declare interface DocumentAgentActionParam {
+export declare type DocumentAgentActionParam<
+  TParamConfig extends {
+    docIdRequired: boolean
+  } = {
+    docIdRequired: false
+  },
+> = {
   type: 'document'
-  /**
-   * If omitted, implicitly uses the documentId of the instruction target
-   */
-  documentId?: string
+} & DocIdParam<TParamConfig>
+
+/** @internal */
+export declare type EditableReleaseDocument = Omit<
+  PartialExcept<ReleaseDocument, '_id'>,
+  'metadata' | '_type'
+> & {
+  _id: string
+  metadata: Partial<ReleaseDocument['metadata']>
 }
 
 /**
@@ -1094,6 +1250,25 @@ 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 EmulatedResponseQueryOptions extends ResponseQueryOptions {
+  useEmulate: boolean
+  connections?: ViewConnectionOverride[] | undefined
+  filterResponse?: false
+  returnQuery?: false
+}
+
 /** @public */
 export declare interface ErrorProps {
   message: string
@@ -1136,17 +1311,19 @@ export declare type EventSourceInstance = InstanceType<typeof globalThis.EventSo
  *
  * @beta
  * */
-export declare interface FieldAgentActionParam {
+export declare type FieldAgentActionParam<
+  TParamConfig extends {
+    docIdRequired: boolean
+  } = {
+    docIdRequired: false
+  },
+> = {
   type: 'field'
   /**
    * Examples: 'title', ['array', \{_key: 'arrayItemKey'\}, 'field']
    */
   path: AgentActionPathSegment | AgentActionPath
-  /**
-   * If omitted, implicitly uses the documentId of the instruction target
-   */
-  documentId?: string
-}
+} & DocIdParam<TParamConfig>
 
 /** @public */
 export declare type FilterDefault = (props: {
@@ -1214,6 +1391,16 @@ export declare type FirstDocumentMutationOptions = BaseMutationOptions & {
   returnDocuments?: true
 }
 
+/**
+ * Formats a GROQ query parse error into a human-readable string.
+ *
+ * @param error - The error object containing details about the parse error.
+ * @param tag - An optional tag to include in the error message.
+ * @returns A formatted error message string.
+ * @public
+ */
+export declare function formatQueryParseError(error: QueryParseError, tag?: string | null): string
+
 /** @beta */
 declare type GenerateAsyncInstruction<T extends Record<string, Any> = Record<string, Any>> = (
   | GenerateExistingDocumentRequest
@@ -1227,8 +1414,11 @@ declare type GenerateAsyncInstruction<T extends Record<string, Any> = Record<str
  * @beta
  */
 declare interface GenerateExistingDocumentRequest {
+  /**
+   * @see #AgentActionSchema.forcePublishedWrite
+   */
   documentId: string
-  createDocument?: never
+  targetDocument?: never
 }
 
 /** @beta */
@@ -1248,7 +1438,7 @@ declare interface GenerateRequestBase extends AgentActionRequestBase {
    *
    * The LLM only has access to information in the instruction, plus the target schema.
    *
-   * string template using $variable
+   * String template with support for $variable from `instructionParams`.
    * */
   instruction: string
   /**
@@ -1343,6 +1533,21 @@ declare interface GenerateRequestBase extends AgentActionRequestBase {
    * - 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)
    *
+   * ## Generating images
+   *
+   * Generate will generate images the same was as AI Assist, for images that have been configured using
+   * [AI Assist schema options](https://github.com/sanity-io/assist/tree/main/plugin#image-generation).
+   *
+   * To generate images _without_ changing the schema, directly target an image asset path.
+   *
+   * For example, all the following will generate an image into the provided asset:
+   * * `target: {path: ['image', 'asset'] }`
+   * * `target: {path: 'image', include: ['asset'] }`
+   *
+   * Image generation can be combined with regular content targets:
+   * * `target: [{path: ['image', 'asset'] }, {include: ['title', 'description']}]`
+   *
+   * Since Generate happens in a single LLM pass, the image will be contextually related to other generated content.
    * @see AgentActionRequestBase#conditionalPaths
    */
   target?: GenerateTarget | GenerateTarget[]
@@ -1389,6 +1594,7 @@ export declare interface GenerateTarget extends AgentActionTarget {
    * @see #AgentActionTargetInclude.operation
    * @see #include
    * @see #AgentActionTargetInclude.include
+   * @see #AgentActionSchema.forcePublishedWrite
    */
   operation?: GenerateOperation
   /**
@@ -1405,22 +1611,34 @@ export declare interface GenerateTarget extends AgentActionTarget {
 export declare type GenerateTargetDocument<T extends Record<string, Any> = Record<string, Any>> =
   | {
       operation: 'edit'
+      /**
+       * @see #AgentActionSchema.forcePublishedWrite
+       */
       _id: string
     }
   | {
       operation: 'create'
+      /**
+       * @see #AgentActionSchema.forcePublishedWrite
+       */
       _id?: string
       _type: string
       initialValues?: T
     }
   | {
       operation: 'createIfNotExists'
+      /**
+       * @see #AgentActionSchema.forcePublishedWrite
+       */
       _id: string
       _type: string
       initialValues?: T
     }
   | {
       operation: 'createOrReplace'
+      /**
+       * @see #AgentActionSchema.forcePublishedWrite
+       */
       _id: string
       _type: string
       initialValues?: T
@@ -1433,6 +1651,9 @@ export declare type GenerateTargetDocument<T extends Record<string, Any> = Recor
 declare interface GenerateTargetDocumentRequest<
   T extends Record<string, Any> = Record<string, Any>,
 > {
+  /**
+   * @see #AgentActionSchema.forcePublishedWrite
+   */
   targetDocument: GenerateTargetDocument<T>
   documentId?: never
 }
@@ -1499,6 +1720,24 @@ export declare type IdentifiedSanityDocumentStub<
   _id: string
 } & SanityDocumentStub
 
+/**
+ *
+ * @see #TransformOperation
+ * @beta
+ */
+export declare interface ImageDescriptionOperation {
+  type: 'image-description'
+  /**
+   * When omitted, parent image value will be inferred from the arget path.
+   *
+   * When specified, the `sourcePath` should be a path to an image (or image asset) field:
+   * - `['image']`
+   * - `['wrapper', 'mainImage']`
+   * - `['heroImage', 'asset'] // the asset segment is optional, but supported`
+   */
+  sourcePath?: AgentActionPath
+}
+
 /** @public */
 export declare interface InitializedClientConfig extends ClientConfig {
   apiHost: string
@@ -1521,6 +1760,12 @@ export declare interface InitializedClientConfig extends ClientConfig {
    * The fully initialized stega config, can be used to check if stega is enabled
    */
   stega: InitializedStegaConfig
+  /**
+   * Default headers to include with all requests
+   *
+   * @remarks request-specific headers will override any default headers with the same name.
+   */
+  headers?: Record<string, string>
 }
 
 /** @public */
@@ -1542,6 +1787,9 @@ export declare type InsertPatch =
       items: Any[]
     }
 
+/** @internal */
+export declare function isQueryParseError(error: object): error is QueryParseError
+
 /**
  * Set up a listener that will be notified when mutations occur on documents matching the provided query/filter.
  *
@@ -1775,11 +2023,9 @@ export declare type Mutation<R extends Record<string, Any> = Record<string, Any>
 
 /** @internal */
 export declare interface MutationError {
-  error: {
-    type: 'mutationError'
-    description: string
-    items?: MutationErrorItem[]
-  }
+  type: 'mutationError'
+  description: string
+  items?: MutationErrorItem[]
 }
 
 /** @internal */
@@ -2120,43 +2366,344 @@ export declare class ObservableProjectsClient {
 }
 
 /** @public */
-export declare class ObservableSanityClient {
+declare class ObservableReleasesClient {
   #private
-  assets: ObservableAssetsClient
-  datasets: ObservableDatasetsClient
-  live: LiveClient
-  projects: ObservableProjectsClient
-  users: ObservableUsersClient
-  agent: {
-    action: ObservableAgentsActionClient
-  }
-  /**
-   * Instance properties
-   */
-  listen: typeof _listen
-  constructor(httpRequest: HttpRequest, config?: ClientConfig)
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
   /**
-   * Clone the client - returns a new instance
+   * @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()
+   * ```
    */
-  clone(): ObservableSanityClient
+  get(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: {
+      signal?: AbortSignal
+      tag?: string
+    },
+  ): Observable<ReleaseDocument | undefined>
   /**
-   * Returns the current client configuration
+   * @public
+   *
+   * Creates a new release under the given id, with metadata.
+   *
+   * @remarks
+   * * If no releaseId is provided, a release id will be generated.
+   * * If no metadata is provided, then an `undecided` releaseType will be used.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to create.
+   *   - `metadata` - The metadata to associate with the release {@link ReleaseDocument}.
+   * @param options - Additional action options.
+   * @returns An observable that resolves to the `transactionId` and the release id and metadata.
+   *
+   * @example Creating a release with a custom id and metadata
+   * ```ts
+   * const releaseId = 'my-release'
+   * const metadata: ReleaseDocument['metadata'] = {
+   *   releaseType: 'asap',
+   * }
+   *
+   * client.observable.releases.create({releaseId, metadata}).pipe(
+   *   tap(({transactionId, releaseId, metadata}) => console.log(transactionId, releaseId, metadata)),
+   *   // {
+   *   //   transactionId: 'transaction-id',
+   *   //   releaseId: 'my-release',
+   *   //   metadata: {releaseType: 'asap'},
+   *   // }
+   * ).subscribe()
+   * ```
+   *
+   * @example Creating a release with generated id and metadata
+   * ```ts
+   * client.observable.releases.create().pipe(
+   *   tap(({metadata}) => console.log(metadata)),
+   *   // {
+   *   //   metadata: {releaseType: 'undecided'},
+   *   // }
+   * ).subscribe()
+   * ```
+   *
+   * @example Creating a release using a custom transaction id
+   * ```ts
+   * client.observable.releases.create({transactionId: 'my-transaction-id'}).pipe(
+   *   tap(({transactionId, metadata}) => console.log(transactionId, metadata)),
+   *   // {
+   *   //   transactionId: 'my-transaction-id',
+   *   //   metadata: {releaseType: 'undecided'},
+   *   // }
+   * ).subscribe()
+   * ```
    */
-  config(): InitializedClientConfig
+  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']
+    }
+  >
   /**
-   * Reconfigure the client. Note that this _mutates_ the current client.
+   * @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`.
    */
-  config(newConfig?: Partial<ClientConfig>): this
+  edit(
+    {
+      releaseId,
+      patch,
+    }: {
+      releaseId: string
+      patch: PatchOperations
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
   /**
-   * Clone the client with a new (partial) configuration.
+   * @public
    *
-   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
+   * 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`.
    */
-  withConfig(newConfig?: Partial<ClientConfig>): ObservableSanityClient
+  publish(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * @public
    *
-   * @param query - GROQ-query to perform
+   * An archive action removes an active release. The documents that comprise the release
+   * are deleted and therefore no longer queryable.
+   *
+   * While the documents remain in retention the last version can still be accessed using document history endpoint.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to archive.
+   * @param options - Additional action options.
+   * @returns An observable that resolves to the `transactionId`.
+   */
+  archive(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
+  /**
+   * @public
+   *
+   * An unarchive action restores an archived release and all documents
+   * with the content they had just prior to archiving.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to unarchive.
+   * @param options - Additional action options.
+   * @returns An observable that resolves to the `transactionId`.
+   */
+  unarchive(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
+  /**
+   * @public
+   *
+   * A schedule action queues a release for publishing at the given future time.
+   * The release is locked such that no documents in the release can be modified and
+   * no documents that it references can be deleted as this would make the publish fail.
+   * At the given time, the same logic as for the publish action is triggered.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to schedule.
+   *   - `publishAt` - The serialised date and time to publish the release. If the `publishAt` is in the past, the release will be published immediately.
+   * @param options - Additional action options.
+   * @returns An observable that resolves to the `transactionId`.
+   */
+  schedule(
+    {
+      releaseId,
+      publishAt,
+    }: {
+      releaseId: string
+      publishAt: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
+  /**
+   * @public
+   *
+   * An unschedule action stops a release from being published.
+   * The documents in the release are considered unlocked and can be edited again.
+   * This may fail if another release is scheduled to be published after this one and
+   * has a reference to a document created by this one.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to unschedule.
+   * @param options - Additional action options.
+   * @returns An observable that resolves to the `transactionId`.
+   */
+  unschedule(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
+  /**
+   * @public
+   *
+   * A delete action removes a published or archived release.
+   * The backing system document will be removed from the dataset.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to delete.
+   * @param options - Additional action options.
+   * @returns An observable that resolves to the `transactionId`.
+   */
+  delete(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult>
+  /**
+   * @public
+   *
+   * Fetch the documents in a release by release id.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to fetch documents for.
+   * @param options - Additional mutation options {@link BaseMutationOptions}.
+   * @returns An observable that resolves to the documents in the release.
+   */
+  fetchDocuments(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseMutationOptions,
+  ): Observable<RawQueryResponse<SanityDocument[]>>
+}
+
+/** @public */
+export declare class ObservableSanityClient {
+  #private
+  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)
+  /**
+   * Clone the client - returns a new instance
+   */
+  clone(): ObservableSanityClient
+  /**
+   * 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>): ObservableSanityClient
+  /**
+   * Perform a GROQ-query against the configured dataset.
+   *
+   * @param query - GROQ-query to perform
    */
   fetch<
     R = Any,
@@ -2220,7 +2767,9 @@ export declare class ObservableSanityClient {
   getDocument<R extends Record<string, Any> = Record<string, Any>>(
     id: string,
     options?: {
+      signal?: AbortSignal
       tag?: string
+      releaseId?: string
     },
   ): Observable<SanityDocument<R> | undefined>
   /**
@@ -2403,6 +2952,90 @@ export declare class ObservableSanityClient {
     document: IdentifiedSanityDocumentStub<R>,
     options?: BaseMutationOptions,
   ): Observable<SanityDocument<R>>
+  /**
+   * @public
+   *
+   * Creates a new version of a published document.
+   *
+   * @remarks
+   * * Requires a document with a `_type` property.
+   * * Creating a version with no `releaseId` will create a new draft version of the published document.
+   * * If the `document._id` is defined, it should be a draft or release version ID that matches the version ID generated from `publishedId` and `releaseId`.
+   * * If the `document._id` is not defined, it will be generated from `publishedId` and `releaseId`.
+   * * To create a version of an unpublished document, use the `client.create` method.
+   *
+   * @category Versions
+   *
+   * @param params - Version action parameters:
+   *   - `document` - The document to create as a new version (must include `_type`).
+   *   - `publishedId` - The ID of the published document being versioned.
+   *   - `releaseId` - The ID of the release to create the version for.
+   * @param options - Additional action options.
+   * @returns an observable that resolves to the `transactionId`.
+   *
+   * @example Creating a new version of a published document with a generated version ID
+   * ```ts
+   * client.observable.createVersion({
+   *   // The document does not need to include an `_id` property since it will be generated from `publishedId` and `releaseId`
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   *   releaseId: 'myRelease',
+   * })
+   *
+   * // The following document will be created:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Creating a new version of a published document with a specified version ID
+   * ```ts
+   * client.observable.createVersion({
+   *   document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
+   *   // `publishedId` and `releaseId` are not required since `document._id` has been specified
+   * })
+   *
+   * // The following document will be created:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Creating a new draft version of a published document
+   * ```ts
+   * client.observable.createVersion({
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   * })
+   *
+   * // The following document will be created:
+   * // {
+   * //   _id: 'drafts.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   */
+  createVersion<R extends Record<string, Any>>(
+    args: {
+      document: SanityDocumentStub<R>
+      publishedId: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
+  createVersion<R extends Record<string, Any>>(
+    args: {
+      document: IdentifiedSanityDocumentStub<R>
+      publishedId?: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
   /**
    * Deletes a document with the given document ID.
    * Returns an observable that resolves to the deleted document.
@@ -2507,6 +3140,157 @@ export declare class ObservableSanityClient {
     selection: MutationSelection,
     options?: BaseMutationOptions,
   ): Observable<SanityDocument<R>>
+  /**
+   * @public
+   *
+   * Deletes the draft or release version of a document.
+   *
+   * @remarks
+   * * Discarding a version with no `releaseId` will discard the draft version of the published document.
+   * * If the draft or release version does not exist, any error will throw.
+   *
+   * @param params - Version action parameters:
+   *   - `releaseId` - The ID of the release to discard the document from.
+   *   - `publishedId` - The published ID of the document to discard.
+   * @param purge - if `true` the document history is also discarded.
+   * @param options - Additional action options.
+   * @returns an observable that resolves to the `transactionId`.
+   *
+   * @example Discarding a release version of a document
+   * ```ts
+   * client.observable.discardVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
+   * // The document with the ID `versions.myRelease.myDocument` will be discarded.
+   * ```
+   *
+   * @example Discarding a draft version of a document
+   * ```ts
+   * client.observable.discardVersion({publishedId: 'myDocument'})
+   * // The document with the ID `drafts.myDocument` will be discarded.
+   * ```
+   */
+  discardVersion(
+    {
+      releaseId,
+      publishedId,
+    }: {
+      releaseId?: string
+      publishedId: string
+    },
+    purge?: boolean,
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
+  /**
+   * @public
+   *
+   * Replaces an existing version document.
+   *
+   * @remarks
+   * * Requires a document with a `_type` property.
+   * * If the `document._id` is defined, it should be a draft or release version ID that matches the version ID generated from `publishedId` and `releaseId`.
+   * * If the `document._id` is not defined, it will be generated from `publishedId` and `releaseId`.
+   * * Replacing a version with no `releaseId` will replace the draft version of the published document.
+   * * At least one of the **version** or **published** documents must exist.
+   *
+   * @param params - Version action parameters:
+   *   - `document` - The new document to replace the version with.
+   *   - `releaseId` - The ID of the release where the document version is replaced.
+   *   - `publishedId` - The ID of the published document to replace.
+   * @param options - Additional action options.
+   * @returns an observable that resolves to the `transactionId`.
+   *
+   * @example Replacing a release version of a published document with a generated version ID
+   * ```ts
+   * client.observable.replaceVersion({
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   *   releaseId: 'myRelease',
+   * })
+   *
+   * // The following document will be patched:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Replacing a release version of a published document with a specified version ID
+   * ```ts
+   * client.observable.replaceVersion({
+   *   document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
+   *   // `publishedId` and `releaseId` are not required since `document._id` has been specified
+   * })
+   *
+   * // The following document will be patched:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Replacing a draft version of a published document
+   * ```ts
+   * client.observable.replaceVersion({
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   * })
+   *
+   * // The following document will be patched:
+   * // {
+   * //   _id: 'drafts.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   */
+  replaceVersion<R extends Record<string, Any>>(
+    args: {
+      document: SanityDocumentStub<R>
+      publishedId: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
+  replaceVersion<R extends Record<string, Any>>(
+    args: {
+      document: IdentifiedSanityDocumentStub<R>
+      publishedId?: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
+  /**
+   * @public
+   *
+   * Used to indicate when a document within a release should be unpublished when
+   * the release is run.
+   *
+   * @remarks
+   * * If the published document does not exist, an error will be thrown.
+   *
+   * @param params - Version action parameters:
+   *   - `releaseId` - The ID of the release to unpublish the document from.
+   *   - `publishedId` - The published ID of the document to unpublish.
+   * @param options - Additional action options.
+   * @returns an observable that resolves to the `transactionId`.
+   *
+   * @example Unpublishing a release version of a published document
+   * ```ts
+   * client.observable.unpublishVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
+   * // The document with the ID `versions.myRelease.myDocument` will be unpublished. when `myRelease` is run.
+   * ```
+   */
+  unpublishVersion(
+    {
+      releaseId,
+      publishedId,
+    }: {
+      releaseId: string
+      publishedId: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
   /**
    * Perform mutation operations against the configured dataset
    * Returns an observable that resolves to the first mutated document.
@@ -2708,6 +3492,9 @@ export declare type OpenEvent = {
   type: 'open'
 }
 
+/** @internal */
+export declare type PartialExcept<T, K extends keyof T> = Pick<T, K> & Partial<Omit<T, K>>
+
 /** @public */
 export declare class Patch extends BasePatch {
   #private
@@ -2757,9 +3544,45 @@ export declare class Patch extends BasePatch {
 /** @public */
 export declare type PatchBuilder = (patch: Patch) => Patch
 
+/** @beta */
+export declare type PatchDocument<T extends Record<string, Any> = Record<string, Any>> =
+  | PatchDocumentSync<T>
+  | PatchDocumentAsync<T>
+
+/** @beta */
+declare type PatchDocumentAsync<T extends Record<string, Any> = Record<string, Any>> = (
+  | PatchExistingDocumentRequest
+  | PatchTargetDocumentRequest<T>
+) &
+  PatchRequestBase &
+  AgentActionAsync
+
+/** @beta */
+declare type PatchDocumentSync<T extends Record<string, Any> = Record<string, Any>> = (
+  | PatchExistingDocumentRequest
+  | PatchTargetDocumentRequest<T>
+) &
+  PatchRequestBase &
+  AgentActionSync
+
+/**
+ * Patches an existing document
+ * @beta
+ */
+declare interface PatchExistingDocumentRequest {
+  /**
+   * @see #AgentActionSchema.forcePublishedWrite
+   */
+  documentId: string
+  targetDocument?: never
+}
+
 /** @internal */
 export declare type PatchMutationOperation = PatchOperations & MutationSelection
 
+/**  @beta */
+export declare type PatchOperation = 'set' | 'append' | 'mixed' | 'unset'
+
 /** @internal */
 export declare interface PatchOperations {
   set?: {
@@ -2782,9 +3605,80 @@ export declare interface PatchOperations {
   ifRevisionID?: string
 }
 
+/**  @beta */
+declare interface PatchRequestBase extends AgentActionSchema {
+  /**
+   * 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 therefore an error to provide conflicting include/exclude across targets (ie, include title in one, and exclude it in another)
+   *
+   * @see AgentActionRequestBase#conditionalPaths
+   */
+  target: PatchTarget | PatchTarget[]
+}
+
 /** @internal */
 export declare type PatchSelection = string | string[] | MutationSelection
 
+/**  @beta */
+export declare type PatchTarget = {
+  /**
+   * Determines how the target path will be patched.
+   *
+   * ### Operation types
+   * - `'set'` – an *overwriting* operation: sets the full field value for primitive targets, and merges the provided value with existing values for objects
+   * - `'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'` –  sets non-array fields, and appends to array fields
+   * - `'unset'` – removes whatever value is on the target path
+   *
+   * All operations except unset requires a `value`.
+   *
+   * #### Appending in the middle of arrays
+   * To append to an array, use the 'append' operation, and provide an array value with one or more array items.
+   *
+   * `target: {path: ['array'], operation: 'append', value: [{_type: 'item' _key: 'a'}]}` will append the items in the value to the existing array.
+   *
+   * To insert in the middle of the array, use `target: {path: ['array', {_key: 'appendAfterKey'}], operation: 'append', value: [{_type: 'item' _key: 'a'}]}`.
+   * Here, `{_type: 'item' _key: 'a'}` will be appended after the array item with key `'appendAfterKey'`
+   *
+   * It is optional to provide a _key for inserted array items; if one isn't provided, it will be generated.
+   */
+  operation: PatchOperation
+  path: AgentActionPathSegment | AgentActionPath
+} & (
+  | {
+      operation: 'unset'
+      value?: never
+    }
+  | {
+      operation: Exclude<PatchOperation, 'unset'>
+      value: AnyNonNullable
+    }
+)
+
+/**
+ * Create a new document, then patch it
+ * @beta
+ */
+declare interface PatchTargetDocumentRequest<T extends Record<string, Any> = Record<string, Any>> {
+  /**
+   * @see #AgentActionSchema.forcePublishedWrite
+   */
+  targetDocument: GenerateTargetDocument<T>
+  documentId?: never
+}
+
 /** @public */
 declare interface ProgressEvent_2 {
   type: 'progress'
@@ -2816,6 +3710,131 @@ export declare class ProjectsClient {
   getById(projectId: string): Promise<SanityProject>
 }
 
+/**
+ * @beta
+ */
+declare interface PromptJsonResponse<T extends Record<string, Any> = Record<string, Any>> {
+  /**
+   *
+   * When true, the response body will be json according to the instruction.
+   * When false, the response is the raw text response to the instruction.
+   *
+   * Note: In addition to setting this to true,  `instruction` MUST include the word 'JSON', or 'json' for this to work.
+   */
+  format: 'json'
+}
+
+/** @beta */
+export declare type PromptRequest<T extends Record<string, Any> = Record<string, Any>> = (
+  | PromptTextResponse
+  | PromptJsonResponse<T>
+) &
+  PromptRequestBase
+
+/**  @beta */
+declare interface PromptRequestBase {
+  /**
+   * 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 with support for $variable from `instructionParams`.
+   * */
+  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.prompt({
+   *   instruction: 'Give the following topic:\n $topic \n ---\nReturns some facts about it',
+   *   instructionParams: {
+   *     topic: 'Grapefruit'
+   *   },
+   * })
+   * ```
+   * ##### Object-form
+   *
+   * ```ts
+   * client.agent.action.prompt({
+   *   instruction: 'Give the following topic:\n $topic \n ---\nReturns some facts about it.',
+   *   instructionParams: {
+   *     topic: {
+   *       type: 'constant',
+   *       value: 'Grapefruit'
+   *     },
+   *   },
+   * })
+   * ```
+   * #### Field
+   * ```ts
+   * client.agent.action.prompt({
+   *   instruction: 'Give the following field value:\n $pte \n ---\nGenerate keywords.',
+   *   instructionParams: {
+   *     pte: {
+   *       type: 'field',
+   *       path: ['pteField'],
+   *       documentId: 'someSanityDocId'
+   *     },
+   *   },
+   * })
+   * ```
+   * #### Document
+   * ```ts
+   * client.agent.action.prompt({
+   *   json: true,
+   *   instruction: 'Given the following document:$document\nCreate a JSON string[] array with keywords describing it.',
+   *   instructionParams: {
+   *     document: {
+   *       type: 'document',
+   *       documentId: 'someSanityDocId'
+   *     },
+   *   },
+   * })
+   * ```
+   *
+   * #### GROQ
+   * ```ts
+   * client.agent.action.prompt({
+   *   instruction: 'Return the best title amongst these: $titles.',
+   *   instructionParams: {
+   *     titles: {
+   *       type: 'groq',
+   *       query: '* [_type==$type].title',
+   *       params: {type: 'article'}
+   *     },
+   *   },
+   * })
+   * ```
+   * */
+  instructionParams?: AgentActionParams<{
+    docIdRequired: true
+  }>
+  /**
+   * Controls how much variance the instructions will run with.
+   *
+   * Value must be in the range [0, 1] (inclusive).
+   *
+   * Default: 0.3
+   */
+  temperature?: number
+}
+
+declare interface PromptTextResponse {
+  /**
+   *
+   * When true, the response body will be json according to the instruction.
+   * When false, the response is the raw text response to the instruction.
+   *
+   * Note: In addition to setting this to true,  `instruction` MUST include the word 'JSON', or 'json' for this to work.
+   */
+  format?: 'text'
+}
+
 /**
  * Publishes a draft document.
  * If a published version of the document already exists this is replaced by the current draft document.
@@ -2845,11 +3864,22 @@ export declare type PublishAction = {
   ifPublishedRevisionId?: string
 }
 
+/**
+ * Publishes all documents in a release at once.
+ *
+ * @public
+ */
+export declare interface PublishReleaseAction {
+  actionType: 'sanity.action.release.publish'
+  releaseId: string
+}
+
 /** @public */
 export declare type QueryOptions =
   | FilteredResponseQueryOptions
   | UnfilteredResponseQueryOptions
   | UnfilteredResponseWithoutQuery
+  | EmulatedResponseQueryOptions
 
 /** @public */
 export declare interface QueryParams {
@@ -2892,68 +3922,441 @@ export declare interface QueryParams {
   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[]
-}
+/**
+ * Returned from the Content Lake API when a query is malformed, usually with a start
+ * and end column to indicate where the error occurred, but not always. Can we used to
+ * provide a more structured error message to the user.
+ *
+ * This will be located under the response `error` property.
+ *
+ * @public
+ */
+export declare interface QueryParseError {
+  type: 'queryParseError'
+  description: string
+  start?: number
+  end?: number
+  query?: string
+}
+
+/**
+ * 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 {
+  /**
+   * typically
+   * `_.releases.<name>`
+   */
+  _id: string
+  /**
+   * where a release has _id `_.releases.foo`, the name is `foo`
+   */
+  name: string
+  _type: 'system.release'
+  _createdAt: string
+  _updatedAt: string
+  _rev: string
+  state: ReleaseState
+  error?: {
+    message: string
+  }
+  finalDocumentStates?: {
+    /** Document ID */
+    id: string
+  }[]
+  /**
+   * If defined, it takes precedence over the intendedPublishAt, the state should be 'scheduled'
+   */
+  publishAt?: string
+  /**
+   * If defined, it provides the time the release was actually published
+   */
+  publishedAt?: string
+  metadata: {
+    title?: string
+    description?: string
+    intendedPublishAt?: string
+    releaseType: ReleaseType
+  }
+}
+
+/**
+ * @public
+ * @deprecated – The `r`-prefix is not required, use `string` instead
+ */
+export declare type ReleaseId = `r${string}`
+
+/** @public */
+declare class ReleasesClient {
+  #private
+  constructor(client: SanityClient, httpRequest: HttpRequest)
+  /**
+   * @public
+   *
+   * Retrieve a release by id.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to retrieve.
+   * @param options - Additional query options including abort signal and query tag.
+   * @returns A promise that resolves to the release document {@link ReleaseDocument}.
+   *
+   * @example Retrieving a release by id
+   * ```ts
+   * const release = await client.releases.get({releaseId: 'my-release'})
+   * console.log(release)
+   * // {
+   * //   _id: '_.releases.my-release',
+   * //   name: 'my-release'
+   * //   _type: 'system.release',
+   * //   metadata: {releaseType: 'asap'},
+   * //   _createdAt: '2021-01-01T00:00:00.000Z',
+   * //   ...
+   * // }
+   * ```
+   */
+  get(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: {
+      signal?: AbortSignal
+      tag?: string
+    },
+  ): Promise<ReleaseDocument | undefined>
+  /**
+   * @public
+   *
+   * Creates a new release under the given id, with metadata.
+   *
+   * @remarks
+   * * If no releaseId is provided, a release id will be generated.
+   * * If no metadata is provided, then an `undecided` releaseType will be used.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to create.
+   *   - `metadata` - The metadata to associate with the release {@link ReleaseDocument}.
+   * @param options - Additional action options.
+   * @returns A promise that resolves to the `transactionId` and the release id and metadata.
+   *
+   * @example Creating a release with a custom id and metadata
+   * ```ts
+   * const releaseId = 'my-release'
+   * const releaseMetadata: ReleaseDocument['metadata'] = {
+   *   releaseType: 'asap',
+   * }
+   *
+   * const result =
+   *   await client.releases.create({releaseId, metadata: releaseMetadata})
+   * console.log(result)
+   * // {
+   * //   transactionId: 'transaction-id',
+   * //   releaseId: 'my-release',
+   * //   metadata: {releaseType: 'asap'},
+   * // }
+   * ```
+   *
+   * @example Creating a release with generated id and metadata
+   * ```ts
+   * const {metadata} = await client.releases.create()
+   * console.log(metadata.releaseType) // 'undecided'
+   * ```
+   *
+   * @example Creating a release with a custom transaction id
+   * ```ts
+   * const {transactionId, metadata} = await client.releases.create({transactionId: 'my-transaction-id'})
+   * console.log(metadata.releaseType) // 'undecided'
+   * console.log(transactionId) // 'my-transaction-id'
+   * ```
+   */
+  create(options: BaseActionOptions): Promise<
+    SingleActionResult & {
+      releaseId: string
+      metadata: ReleaseDocument['metadata']
+    }
+  >
+  create(
+    release: {
+      releaseId?: string
+      metadata?: Partial<ReleaseDocument['metadata']>
+    },
+    options?: BaseActionOptions,
+  ): Promise<
+    SingleActionResult & {
+      releaseId: string
+      metadata: ReleaseDocument['metadata']
+    }
+  >
+  /**
+   * @public
+   *
+   * Edits an existing release, updating the metadata.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to edit.
+   *   - `patch` - The patch operation to apply on the release metadata {@link PatchMutationOperation}.
+   * @param options - Additional action options.
+   * @returns A promise that resolves to the `transactionId`.
+   */
+  edit(
+    {
+      releaseId,
+      patch,
+    }: {
+      releaseId: string
+      patch: PatchOperations
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @public
+   *
+   * Publishes all documents in a release at once. For larger releases the effect of the publish
+   * will be visible immediately when querying but the removal of the `versions.<releasesId>.*`
+   * documents and creation of the corresponding published documents with the new content may
+   * take some time.
+   *
+   * During this period both the source and target documents are locked and cannot be
+   * modified through any other means.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to publish.
+   * @param options - Additional action options.
+   * @returns A promise that resolves to the `transactionId`.
+   */
+  publish(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @public
+   *
+   * An archive action removes an active release. The documents that comprise the release
+   * are deleted and therefore no longer queryable.
+   *
+   * While the documents remain in retention the last version can still be accessed using document history endpoint.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to archive.
+   * @param options - Additional action options.
+   * @returns A promise that resolves to the `transactionId`.
+   */
+  archive(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @public
+   *
+   * An unarchive action restores an archived release and all documents
+   * with the content they had just prior to archiving.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to unarchive.
+   * @param options - Additional action options.
+   * @returns A promise that resolves to the `transactionId`.
+   */
+  unarchive(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @public
+   *
+   * A schedule action queues a release for publishing at the given future time.
+   * The release is locked such that no documents in the release can be modified and
+   * no documents that it references can be deleted as this would make the publish fail.
+   * At the given time, the same logic as for the publish action is triggered.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to schedule.
+   *   - `publishAt` - The serialised date and time to publish the release. If the `publishAt` is in the past, the release will be published immediately.
+   * @param options - Additional action options.
+   * @returns A promise that resolves to the `transactionId`.
+   */
+  schedule(
+    {
+      releaseId,
+      publishAt,
+    }: {
+      releaseId: string
+      publishAt: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @public
+   *
+   * An unschedule action stops a release from being published.
+   * The documents in the release are considered unlocked and can be edited again.
+   * This may fail if another release is scheduled to be published after this one and
+   * has a reference to a document created by this one.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to unschedule.
+   * @param options - Additional action options.
+   * @returns A promise that resolves to the `transactionId`.
+   */
+  unschedule(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @public
+   *
+   * A delete action removes a published or archived release.
+   * The backing system document will be removed from the dataset.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to delete.
+   * @param options - Additional action options.
+   * @returns A promise that resolves to the `transactionId`.
+   */
+  delete(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult>
+  /**
+   * @public
+   *
+   * Fetch the documents in a release by release id.
+   *
+   * @category Releases
+   *
+   * @param params - Release action parameters:
+   *   - `releaseId` - The id of the release to fetch documents for.
+   * @param options - Additional mutation options {@link BaseMutationOptions}.
+   * @returns A promise that resolves to the documents in the release.
+   */
+  fetchDocuments(
+    {
+      releaseId,
+    }: {
+      releaseId: string
+    },
+    options?: BaseMutationOptions,
+  ): Promise<RawQueryResponse<SanityDocument[]>>
+}
+
+/** @beta */
+export declare type ReleaseState =
+  | 'active'
+  | 'archiving'
+  | 'unarchiving'
+  | 'archived'
+  | 'published'
+  | 'publishing'
+  | 'scheduled'
+  | 'scheduling'
 
 /** @internal */
-export declare 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}`
+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'
@@ -2967,6 +4370,16 @@ export declare type ReplaceDraftAction = {
   attributes: IdentifiedSanityDocumentStub
 }
 
+/**
+ * Replace an existing version of a document.
+ *
+ * @public
+ */
+export declare interface ReplaceVersionAction {
+  actionType: 'sanity.action.document.version.replace'
+  document: IdentifiedSanityDocumentStub
+}
+
 /** @public */
 export declare const requester: Requester
 
@@ -3052,6 +4465,7 @@ export declare class SanityClient {
   agent: {
     action: AgentActionsClient
   }
+  releases: ReleasesClient
   /**
    * Observable version of the Sanity client, with the same configuration as the promise-based one
    */
@@ -3148,6 +4562,7 @@ export declare class SanityClient {
     options?: {
       signal?: AbortSignal
       tag?: string
+      releaseId?: string
     },
   ): Promise<SanityDocument<R> | undefined>
   /**
@@ -3331,6 +4746,90 @@ export declare class SanityClient {
     document: IdentifiedSanityDocumentStub<R>,
     options?: BaseMutationOptions,
   ): Promise<SanityDocument<R>>
+  /**
+   * @public
+   *
+   * Creates a new version of a published document.
+   *
+   * @remarks
+   * * Requires a document with a `_type` property.
+   * * Creating a version with no `releaseId` will create a new draft version of the published document.
+   * * If the `document._id` is defined, it should be a draft or release version ID that matches the version ID generated from `publishedId` and `releaseId`.
+   * * If the `document._id` is not defined, it will be generated from `publishedId` and `releaseId`.
+   * * To create a version of an unpublished document, use the `client.create` method.
+   *
+   * @category Versions
+   *
+   * @param params - Version action parameters:
+   *   - `document` - The document to create as a new version (must include `_type`).
+   *   - `publishedId` - The ID of the published document being versioned.
+   *   - `releaseId` - The ID of the release to create the version for.
+   * @param options - Additional action options.
+   * @returns A promise that resolves to the `transactionId`.
+   *
+   * @example Creating a new version of a published document with a generated version ID
+   * ```ts
+   * const transactionId = await client.createVersion({
+   *   // The document does not need to include an `_id` property since it will be generated from `publishedId` and `releaseId`
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   *   releaseId: 'myRelease',
+   * })
+   *
+   * // The following document will be created:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Creating a new version of a published document with a specified version ID
+   * ```ts
+   * const transactionId = await client.createVersion({
+   *   document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
+   *   // `publishedId` and `releaseId` are not required since `document._id` has been specified
+   * })
+   *
+   * // The following document will be created:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Creating a new draft version of a published document
+   * ```ts
+   * const transactionId = await client.createVersion({
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   * })
+   *
+   * // The following document will be created:
+   * // {
+   * //   _id: 'drafts.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   */
+  createVersion<R extends Record<string, Any>>(
+    args: {
+      document: SanityDocumentStub<R>
+      publishedId: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
+  createVersion<R extends Record<string, Any>>(
+    args: {
+      document: IdentifiedSanityDocumentStub<R>
+      publishedId?: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
   /**
    * Deletes a document with the given document ID.
    * Returns a promise that resolves to the deleted document.
@@ -3435,6 +4934,157 @@ export declare class SanityClient {
     selection: MutationSelection,
     options?: BaseMutationOptions,
   ): Promise<SanityDocument<R>>
+  /**
+   * @public
+   *
+   * Deletes the draft or release version of a document.
+   *
+   * @remarks
+   * * Discarding a version with no `releaseId` will discard the draft version of the published document.
+   * * If the draft or release version does not exist, any error will throw.
+   *
+   * @param params - Version action parameters:
+   *   - `releaseId` - The ID of the release to discard the document from.
+   *   - `publishedId` - The published ID of the document to discard.
+   * @param purge - if `true` the document history is also discarded.
+   * @param options - Additional action options.
+   * @returns a promise that resolves to the `transactionId`.
+   *
+   * @example Discarding a release version of a document
+   * ```ts
+   * client.discardVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
+   * // The document with the ID `versions.myRelease.myDocument` will be discarded.
+   * ```
+   *
+   * @example Discarding a draft version of a document
+   * ```ts
+   * client.discardVersion({publishedId: 'myDocument'})
+   * // The document with the ID `drafts.myDocument` will be discarded.
+   * ```
+   */
+  discardVersion(
+    {
+      releaseId,
+      publishedId,
+    }: {
+      releaseId?: string
+      publishedId: string
+    },
+    purge?: boolean,
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
+  /**
+   * @public
+   *
+   * Replaces an existing version document.
+   *
+   * @remarks
+   * * Requires a document with a `_type` property.
+   * * If the `document._id` is defined, it should be a draft or release version ID that matches the version ID generated from `publishedId` and `releaseId`.
+   * * If the `document._id` is not defined, it will be generated from `publishedId` and `releaseId`.
+   * * Replacing a version with no `releaseId` will replace the draft version of the published document.
+   * * At least one of the **version** or **published** documents must exist.
+   *
+   * @param params - Version action parameters:
+   *   - `document` - The new document to replace the version with.
+   *   - `releaseId` - The ID of the release where the document version is replaced.
+   *   - `publishedId` - The ID of the published document to replace.
+   * @param options - Additional action options.
+   * @returns a promise that resolves to the `transactionId`.
+   *
+   * @example Replacing a release version of a published document with a generated version ID
+   * ```ts
+   * await client.replaceVersion({
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   *   releaseId: 'myRelease',
+   * })
+   *
+   * // The following document will be patched:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Replacing a release version of a published document with a specified version ID
+   * ```ts
+   * await client.replaceVersion({
+   *   document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
+   *   // `publishedId` and `releaseId` are not required since `document._id` has been specified
+   * })
+   *
+   * // The following document will be patched:
+   * // {
+   * //   _id: 'versions.myRelease.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   *
+   * @example Replacing a draft version of a published document
+   * ```ts
+   * await client.replaceVersion({
+   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   publishedId: 'myDocument',
+   * })
+   *
+   * // The following document will be patched:
+   * // {
+   * //   _id: 'drafts.myDocument',
+   * //   _type: 'myDocument',
+   * //   title: 'My Document',
+   * // }
+   * ```
+   */
+  replaceVersion<R extends Record<string, Any>>(
+    args: {
+      document: SanityDocumentStub<R>
+      publishedId: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
+  replaceVersion<R extends Record<string, Any>>(
+    args: {
+      document: IdentifiedSanityDocumentStub<R>
+      publishedId?: string
+      releaseId?: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
+  /**
+   * @public
+   *
+   * Used to indicate when a document within a release should be unpublished when
+   * the release is run.
+   *
+   * @remarks
+   * * If the published document does not exist, an error will be thrown.
+   *
+   * @param params - Version action parameters:
+   *   - `releaseId` - The ID of the release to unpublish the document from.
+   *   - `publishedId` - The published ID of the document to unpublish.
+   * @param options - Additional action options.
+   * @returns a promise that resolves to the `transactionId`.
+   *
+   * @example Unpublishing a release version of a published document
+   * ```ts
+   * await client.unpublishVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
+   * // The document with the ID `versions.myRelease.myDocument` will be unpublished. when `myRelease` is run.
+   * ```
+   */
+  unpublishVersion(
+    {
+      releaseId,
+      publishedId,
+    }: {
+      releaseId: string
+      publishedId: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
   /**
    * Perform mutation operations against the configured dataset
    * Returns a promise that resolves to the first mutated document.
@@ -3475,7 +5125,7 @@ export declare class SanityClient {
    * @param operations - Mutation operations to execute
    * @param options - Mutation options
    */
-  mutate<R extends Record<string, Any>>(
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
     operations: Mutation<R>[] | Patch | Transaction,
     options: AllDocumentIdsMutationOptions,
   ): Promise<MultipleMutationResult>
@@ -3691,6 +5341,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']
@@ -3878,12 +5539,47 @@ declare type TransformDocumentAsync = TransformRequestBase & AgentActionAsync
 declare type TransformDocumentSync<T extends Record<string, Any> = Record<string, Any>> =
   TransformRequestBase & AgentActionSync
 
+/**
+ *
+ * ## `set` by default
+ * By default, Transform will change the value of every target field in place using a set operation.
+ *
+ * ## Image description
+ *
+ * ### Targeting image fields
+ * Images can be transformed to a textual description by targeting a `string`, `text` or Portable Text field (`array` with `block`)
+ * with `operation: {type: 'image-description'}`.
+ *
+ * Custom instructions for image description targets will be used to generate the description.
+ *
+ * Such targets must be a descendant field of an image object.
+ *
+ * For example:
+ * - `target: {path: ['image', 'description'], operation: {type: 'image-description'} }`
+ * - `target: {path: ['array', {_key: 'abc'}, 'alt'], operation: {type: 'image-description'} } //assuming the item in the array on the key-ed path is an image`
+ * - `target: {path: ['image'], include: ['portableTextField'], operation: {type: 'image-description'}, instruction: 'Use formatting and headings to describe the image in great detail' }`
+ *
+ * ### Targeting non-image fields
+ * If the target image description lives outside an image object, use the `sourcePath` option to specify the path to the image field.
+ * `sourcePath` must be an image or image asset field.
+ *
+ * For example:
+ * - `target: {path: ['description'], operation: operation: {type: 'image-description', sourcePath: ['image', 'asset'] }`
+ * - `target: {path: ['wrapper', 'title'], operation: {type: 'image-description', sourcePath: ['array', {_key: 'abc'}, 'image'] }`
+ * - `target: {path: ['wrapper'], include: ['portableTextField'], operation: {type: 'image-description', sourcePath: ['image', 'asset'] }, instruction: 'Use formatting and headings to describe the image in great detail' }`
+ *
+ * @beta
+ */
+export declare type TransformOperation = 'set' | ImageDescriptionOperation
+
 /** @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.
+   *
+   * @see #AgentActionSchema.forcePublishedWrite
    */
   documentId: string
   /**
@@ -3891,12 +5587,14 @@ declare interface TransformRequestBase extends AgentActionRequestBase {
    * then it is transformed according to the instruction.
    *
    * When omitted, the source document (documentId) is also the target document.
+   *
+   *  @see #AgentActionSchema.forcePublishedWrite
    */
   targetDocument?: TransformTargetDocument
   /**
    * Instruct the LLM how to transform the input to th output.
    *
-   * String template using $variable from instructionParams.
+   * String template with support for $variable from `instructionParams`.
    *
    * Capped to 2000 characters, after variables has been injected.
    * */
@@ -3995,17 +5693,35 @@ declare interface TransformRequestBase extends AgentActionRequestBase {
    * 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
+   *
+   * ## Transforming images
+   *
+   * To transform an existing image, directly target an image asset path.
+   *
+   * For example, all the following will transform the image into the provided asset:
+   * * `target: {path: ['image', 'asset'] }`
+   * * `target: {path: 'image', include: ['asset'] }`
+   *
+   * Image transform can be combined with regular content targets:
+   * * `target: [{path: ['image', 'asset'] }, {include: ['title', 'description']}]`
+   *
+   * Image transform can have per-path instructions, just like any other target paths:
+   * * `target: [{path: ['image', 'asset'], instruction: 'Make the sky blue' }`
+   *
    * @see AgentActionRequestBase#conditionalPaths
    */
   target?: TransformTarget | TransformTarget[]
 }
 
-/**  @beta */
+/**
+ * @see #TransformOperation
+ * @beta
+ * */
 export declare interface TransformTarget extends AgentActionTarget {
   /**
    * Specifies a tailored instruction of this target.
    *
-   * string template using $variable from instructionParams.
+   * String template with support for $variable from `instructionParams`.
    * */
   instruction?: string
   /**
@@ -4016,9 +5732,18 @@ export declare interface TransformTarget extends AgentActionTarget {
    * Fields or array items not on the include list, are implicitly excluded.
    */
   include?: (AgentActionPathSegment | TransformTargetInclude)[]
+  /**
+   * Default: `set`
+   * @see #TransformOperation
+   */
+  operation?: TransformOperation
 }
 
-/**  @beta */
+/**
+ * @see #AgentActionSchema.forcePublishedWrite
+ *
+ * @beta
+ */
 export declare type TransformTargetDocument =
   | {
       operation: 'edit'
@@ -4037,12 +5762,15 @@ export declare type TransformTargetDocument =
       _id: string
     }
 
-/**  @beta */
+/**
+ * @see #TransformOperation
+ * @beta
+ * */
 export declare interface TransformTargetInclude extends AgentActionTargetInclude {
   /**
    * Specifies a tailored instruction of this target.
    *
-   * string template using $variable from instructionParams  */
+   * String template with support for $variable from `instructionParams`.  */
   instruction?: string
   /**
    * By default, all children up to `target.maxPathDepth` are included.
@@ -4052,6 +5780,11 @@ export declare interface TransformTargetInclude extends AgentActionTargetInclude
    * Fields or array items not on the include list, are implicitly excluded.
    */
   include?: (AgentActionPathSegment | TransformTargetInclude)[]
+  /**
+   * Default: `set`
+   * @see #TransformOperation
+   */
+  operation?: TransformOperation
 }
 
 /** @beta */
@@ -4084,6 +5817,7 @@ declare interface TranslateRequestBase extends AgentActionRequestBase {
   schemaId: string
   /**
    * The source document the transformation will use as input.
+   * @see #AgentActionSchema.forcePublishedWrite
    */
   documentId: string
   /**
@@ -4091,6 +5825,8 @@ declare interface TranslateRequestBase extends AgentActionRequestBase {
    * then it is translated according to the instruction.
    *
    * When omitted, the source document (documentId) is also the target document.
+   *
+   * @see #AgentActionSchema.forcePublishedWrite
    */
   targetDocument?: TransformTargetDocument
   /**
@@ -4143,7 +5879,7 @@ declare interface TranslateRequestBase extends AgentActionRequestBase {
 
 /**  @beta */
 export declare interface TranslateTarget extends AgentActionTarget {
-  /** string template using $variable from instructionParams  */
+  /** String template using $variable from styleGuideParams.  */
   styleGuide?: string
   /**
    * By default, all children up to `target.maxPathDepth` are included.
@@ -4157,7 +5893,7 @@ export declare interface TranslateTarget extends AgentActionTarget {
 
 /**  @beta */
 export declare interface TranslateTargetInclude extends AgentActionTargetInclude {
-  /** string template using $variable from instructionParams  */
+  /** String template using $variable from styleGuideParams.  */
   styleGuide?: string
   /**
    * By default, all children up to `target.maxPathDepth` are included.
@@ -4169,6 +5905,16 @@ export declare interface TranslateTargetInclude extends AgentActionTargetInclude
   include?: (AgentActionPathSegment | TranslateTargetInclude)[]
 }
 
+/**
+ * Unarchived an `archived` release, and restores all the release documents.
+ *
+ * @public
+ */
+export declare interface UnarchiveReleaseAction {
+  actionType: 'sanity.action.release.unarchive'
+  releaseId: string
+}
+
 /** @public */
 export declare interface UnfilteredResponseQueryOptions extends ResponseQueryOptions {
   filterResponse: false
@@ -4210,6 +5956,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}
@@ -4297,6 +6065,37 @@ export declare function validateApiPerspective(
   perspective: unknown,
 ): asserts perspective is ClientPerspective
 
+/** @public */
+export declare type VersionAction =
+  | CreateVersionAction
+  | DiscardVersionAction
+  | ReplaceVersionAction
+  | UnpublishVersionAction
+
+/** @public */
+export declare type ViewConnectionOverride = {
+  query: string
+  resourceType: ViewResourceType
+  resourceId: string
+}
+
+/** @public */
+export declare type ViewOverride = {
+  id: string
+  connections: ViewConnectionOverride[]
+}
+
+/** @public */
+export declare type ViewQueryOptions = Pick<
+  EmulatedResponseQueryOptions,
+  'perspective' | 'resultSourceMap' | 'filterResponse'
+>
+
+/** @public */
+export declare enum ViewResourceType {
+  Dataset = 'dataset',
+}
+
 /**
  * The listener has been established, and will start receiving events.
  * Note that this is also emitted upon _reconnection_.