@sanity/client 7.0.1-canary.2 → 7.1.0

package/dist/index.d.ts

@@ -39,6 +39,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
@@ -75,7 +331,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 +372,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 +731,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
@@ -657,7 +910,7 @@ export declare type DatasetResponse = {
 }
 
 /** @internal */
-export declare class DatasetsClient implements DatasetsClientType {
+export declare class DatasetsClient {
   #private
   constructor(client: SanityClient, httpRequest: HttpRequest)
   /**
@@ -698,46 +951,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
@@ -829,6 +1042,34 @@ 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
+}
+
 /**
  * Modifies an existing draft document.
  * It applies the given patch to the document referenced by draftId.
@@ -871,6 +1112,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: {
   /**
@@ -937,6 +1213,274 @@ export declare type FirstDocumentMutationOptions = BaseMutationOptions & {
   returnDocuments?: true
 }
 
+/** @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
+}
+
+/** @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[]
+}
+
+/** @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>
@@ -1066,15 +1610,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),
@@ -1369,62 +1904,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
    *
@@ -1476,7 +2004,7 @@ declare interface ObservableAssetsClientType {
 }
 
 /** @internal */
-export declare class ObservableDatasetsClient implements ObservableDatasetsClientType {
+export declare class ObservableDatasetsClient {
   #private
   constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
   /**
@@ -1517,46 +2045,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
@@ -1611,38 +2099,17 @@ 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)
-   */
-  list(options?: {includeMembers?: true}): Observable<SanityProject[]>
-  list(options?: {includeMembers?: false}): Observable<Omit<SanityProject, 'members'>[]>
-  /**
-   * Fetch a project by project ID
-   *
-   * @param projectId - ID of the project to fetch
-   */
-  getById(projectId: string): Observable<SanityProject>
-}
-
-/** @internal */
-declare interface ObservableProjectsClientType {
-  /**
-   * 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'>[]>
-  list(options?: {
-    includeMembers?: boolean
-  }): Observable<SanityProject[] | Omit<SanityProject, 'members'>[]>
   /**
    * Fetch a project by project ID
    *
@@ -1652,13 +2119,19 @@ declare interface ObservableProjectsClientType {
 }
 
 /** @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
+  }
+  /**
+   * Instance properties
+   */
   listen: typeof _listen
   constructor(httpRequest: HttpRequest, config?: ClientConfig)
   /**
@@ -1717,7 +2190,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>>>
@@ -2152,1516 +2625,445 @@ 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'
+}
+
+/** @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>,
-    options: AllDocumentsMutationOptions,
-  ): Observable<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.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options: FirstDocumentIdMutationOptions,
-  ): Observable<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.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options: AllDocumentIdsMutationOptions,
-  ): Observable<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.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
-   */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options?: BaseMutationOptions,
-  ): Observable<SanityDocument<R>>
-  /**
-   * 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: FirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
-  /**
-   * 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.
-   *
-   * @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,
-  ): Promise<SanityDocument<R>[]>
-  /**
-   * 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
-   */
-  delete(id: string, options: FirstDocumentIdMutationOptions): Promise<SingleMutationResult>
-  /**
-   * 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
-   */
-  delete(id: string, options: AllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
-  /**
-   * 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?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * 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
-   */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * 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
-   */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
-    options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
-  /**
-   * 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
-   */
-  delete(
-    selection: MutationSelection,
-    options: FirstDocumentIdMutationOptions,
-  ): Promise<SingleMutationResult>
-  /**
-   * 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
-   */
-  delete(
-    selection: MutationSelection,
-    options: AllDocumentIdsMutationOptions,
-  ): Promise<MultipleMutationResult>
-  /**
-   * 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
-   */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * 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>>
-  /**
-   * Perform mutation operations against the configured dataset.
-   * Returns a promise 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>[] | Patch | Transaction,
+  commit<R extends Record<string, Any> = Record<string, Any>>(
     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.
+   * Commit the patch, returning a promise that resolves to a mutation result object
    *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
-    options: FirstDocumentIdMutationOptions,
-  ): Promise<SingleMutationResult>
+  commit(options: FirstDocumentIdMutationOptions): Promise<SingleMutationResult>
   /**
-   * Perform mutation operations against the configured dataset
-   * Returns a promise that resolves to a mutation result object containing the mutated document IDs.
+   * Commit the patch, returning a promise that resolves to a mutation result object
    *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  mutate<R extends Record<string, Any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
-    options: AllDocumentIdsMutationOptions,
-  ): Promise<MultipleMutationResult>
+  commit(options: AllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
   /**
-   * Perform mutation operations against the configured dataset
-   * Returns a promise that resolves to the first mutated document.
+   * Commit the patch, returning a promise that resolves to the first patched document
    *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
+  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 {
+  #private
+  constructor(client: SanityClient, httpRequest: HttpRequest)
   /**
-   * 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): Patch
-  /**
-   * 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): Patch
-  /**
-   * 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): Patch
-  /**
-   * Create a new transaction of mutations
+   * Fetch a list of projects the authenticated user has access to.
    *
-   * @param operations - Optional array of mutation operations to initialize the transaction instance with
+   * @param options - Options for the list request
+   *   - `includeMembers` - Whether to include members in the response (default: true)
    */
-  transaction<R extends Record<string, Any> = Record<string, Any>>(
-    operations?: Mutation<R>[],
-  ): Transaction
+  list(options?: {includeMembers?: true}): Promise<SanityProject[]>
+  list(options?: {includeMembers?: false}): Promise<Omit<SanityProject, 'members'>[]>
   /**
-   * Perform action operations against the configured dataset
-   * Returns a promise that resolves to the transaction result
+   * Fetch a project by project ID
    *
-   * @param operations - Action operation(s) to execute
-   * @param options - Action options
+   * @param projectId - ID of the project to fetch
    */
-  action(
-    operations: Action | Action[],
-    options?: BaseActionOptions,
-  ): Promise<SingleActionResult | MultipleActionResult>
+  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'
   /**
-   * Perform a request against the Sanity API
-   * NOTE: Only use this for Sanity API endpoints, not for your own APIs!
-   *
-   * @param options - Request options
-   * @returns Promise resolving to the response body
+   * Draft document ID to publish
    */
-  request<R = Any>(options: RawRequestOptions): Promise<R>
+  draftId: string
   /**
-   * Perform an HTTP request a `/data` sub-endpoint
-   * NOTE: Considered internal, thus marked as deprecated. Use `request` instead.
-   *
-   * @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
+   * Draft revision ID to match
    */
-  dataRequest(endpoint: string, body: unknown, options?: BaseMutationOptions): Promise<Any>
+  ifDraftRevisionId?: string
   /**
-   * 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 replace
    */
-  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
+   * Published revision ID to match
    */
-  getDataUrl(operation: string, path?: string): string
+  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
 }
 
 /**
- * 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
+ * The listener has been disconnected, and a reconnect attempt is scheduled.
+ *
+ * @public
  */
-declare interface SanityClientBase {
-  live: LiveClient
-  listen: typeof _listen
+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'
   /**
-   * 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
+   * 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.
    *
-   * @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
+  }
   /**
    * 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
    */
@@ -3669,13 +3071,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.
    *
@@ -3685,10 +3087,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.
    *
@@ -4114,14 +3513,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
    *
@@ -4160,6 +3551,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 */
@@ -4460,6 +3865,309 @@ 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)[]
+}
+
 /** @public */
 export declare interface UnfilteredResponseQueryOptions extends ResponseQueryOptions {
   filterResponse: false
@@ -4570,7 +4278,7 @@ export declare interface UploadClientConfig {
 }
 
 /** @public */
-export declare class UsersClient implements UsersClientType {
+export declare class UsersClient {
   #private
   constructor(client: SanityClient, httpRequest: HttpRequest)
   /**
@@ -4581,16 +4289,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
  */