@sanity/client 4.0.1 → 5.0.0-esm.0

package/{sanityClient.d.ts → dist/index.d.ts}

@@ -1,7 +1,20 @@
-/* eslint-disable no-dupe-class-members, @typescript-eslint/no-misused-new */
-import type {Observable} from 'rxjs'
+/// <reference types="node" />
 
-export type AssetMetadataType =
+import {BaseError} from 'make-error'
+import {Observable} from 'rxjs'
+import {Requester} from 'get-it'
+
+export declare type AllDocumentIdsMutationOptions = BaseMutationOptions & {
+  returnFirst: false
+  returnDocuments: false
+}
+
+export declare type AllDocumentsMutationOptions = BaseMutationOptions & {
+  returnFirst: false
+  returnDocuments?: true
+}
+
+export declare type AssetMetadataType =
   | 'location'
   | 'exif'
   | 'image'
@@ -9,222 +22,149 @@ export type AssetMetadataType =
   | 'lqip'
   | 'blurhash'
   | 'none'
-export type DatasetAclMode = 'public' | 'private' | 'custom'
-export type ListenVisibility = 'sync' | 'async' | 'query'
-export type ListenEventName = 'mutation' | 'welcome' | 'reconnect'
-export type MutationOperation = 'create' | 'delete' | 'update' | 'none'
 
-export interface ResponseEvent<T = unknown> {
-  type: 'response'
-  body: T
-  url: string
-  method: string
-  statusCode: number
-  statusMessage?: string
-  headers: Record<string, string>
+export declare class AssetsClient {
+  #private
+  constructor(client: SanityClient, httpRequest: HttpRequest)
+  /**
+   * Uploads a file 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',
+    body: File | Blob | Buffer | NodeJS.ReadableStream,
+    options?: UploadClientConfig
+  ): Promise<SanityAssetDocument>
+  /**
+   * Uploads 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: 'image',
+    body: File | Blob | Buffer | NodeJS.ReadableStream,
+    options?: UploadClientConfig
+  ): Promise<SanityImageAssetDocument>
 }
 
-export interface ProgressEvent {
-  type: 'progress'
-  stage: 'upload' | 'download'
-  percent: number
-  total?: number
-  loaded?: number
-  lengthComputable: boolean
+export declare type AttributeSet = {
+  [key: string]: any
 }
 
-type AttributeSet = {[key: string]: any}
-type QueryParams = {[key: string]: any}
-type MutationSelection = {query: string; params?: QueryParams} | {id: string}
-type SanityReference = {_ref: string}
-
-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
+export declare class AuthClient extends BaseAuthClient {
+  client: SanityClient
+  constructor(client: SanityClient)
 }
 
-interface AuthProvider {
+export declare interface AuthProvider {
   name: string
   title: string
   url: string
 }
 
-interface SanityUser {
-  id: string
-  projectId: string
-  displayName: string
-  familyName: string | null
-  givenName: string | null
-  middleName: string | null
-  imageUrl: string | null
-  createdAt: string
-  updatedAt: string
-  isCurrentUser: boolean
-}
-
-interface CurrentSanityUser {
-  id: string
-  name: string
-  email: string
-  profileImage: string | null
-  role: string
-}
-
-interface SanityProjectMember {
-  id: string
-  role: string
-  isRobot: boolean
-  isCurrentUser: boolean
-}
-
-interface SanityProject {
-  id: string
-  displayName: string
-  studioHost: string | null
-  organizationId: string | null
-  isBlocked: boolean
-  isDisabled: boolean
-  isDisabledByUser: boolean
-  createdAt: string
-  pendingInvites?: number
-  maxRetentionDays?: number
-  members: SanityProjectMember[]
-  metadata: {
-    color?: string
-    externalStudioHost?: string
-  }
-}
-
-type GetItRequester = {
-  use: (middleware: any) => GetItRequester
-  clone(): GetItRequester
+export declare type AuthProviderResponse = {
+  providers: AuthProvider[]
 }
 
-export interface UploadOptions {
-  /**
-   * Optional request tag for the upload
-   */
-  tag?: string
-
-  /**
-   * Whether or not to preserve the original filename (default: true)
-   */
-  preserveFilename?: boolean
-
-  /**
-   * Filename for this file (optional)
-   */
-  filename?: string
-
-  /**
-   * Milliseconds to wait before timing the request out
-   */
-  timeout?: number
-
-  /**
-   * Mime type of the file
-   */
-  contentType?: string
-
+export declare class BaseAuthClient {
+  client: SanityClient | ObservableSanityClient
   /**
-   * Array of metadata parts to extract from asset
+   * Fetch available login providers
    */
-  extract?: AssetMetadataType[]
-
+  getLoginProviders(this: AuthClient): Promise<AuthProviderResponse>
+  getLoginProviders(this: ObservableAuthClient): Observable<AuthProviderResponse>
   /**
-   * Optional freeform label for the asset. Generally not used.
+   * Revoke the configured session/token
    */
-  label?: string
+  logout(this: AuthClient): Promise<any>
+  logout(this: ObservableAuthClient): Observable<any>
+}
 
+export declare class BaseDatasetsClient {
+  #private
+  client: SanityClient | ObservableSanityClient
   /**
-   * Optional title for the asset
+   * Create a new dataset with the given name
+   *
+   * @param name - Name of the dataset to create
+   * @param options - Options for the dataset
    */
-  title?: string
-
+  create(
+    this: DatasetsClient,
+    name: string,
+    options?: {
+      aclMode?: DatasetAclMode
+    }
+  ): Promise<DatasetResponse>
+  create(
+    this: ObservableDatasetsClient,
+    name: string,
+    options?: {
+      aclMode?: DatasetAclMode
+    }
+  ): Observable<DatasetResponse>
   /**
-   * Optional description for the asset
+   * Edit a dataset with the given name
+   *
+   * @param name - Name of the dataset to edit
+   * @param options - New options for the dataset
    */
-  description?: string
-
+  edit(
+    this: DatasetsClient,
+    name: string,
+    options?: {
+      aclMode?: DatasetAclMode
+    }
+  ): Promise<DatasetResponse>
+  edit(
+    this: ObservableDatasetsClient,
+    name: string,
+    options?: {
+      aclMode?: DatasetAclMode
+    }
+  ): Observable<DatasetResponse>
   /**
-   * The credit to person(s) and/or organization(s) required by the supplier of the asset to be used when published
+   * Delete a dataset with the given name
+   *
+   * @param name - Name of the dataset to delete
    */
-  creditLine?: string
-
+  delete(
+    this: DatasetsClient,
+    name: string
+  ): Promise<{
+    deleted: true
+  }>
+  delete(
+    this: ObservableDatasetsClient,
+    name: string
+  ): Observable<{
+    deleted: true
+  }>
   /**
-   * Source data (when the asset is from an external service)
+   * Fetch a list of datasets for the configured project
    */
-  source?: {
-    /**
-     * The (u)id of the asset within the source, i.e. 'i-f323r1E'
-     */
-    id: string
-
-    /**
-     * The name of the source, i.e. 'unsplash'
-     */
-    name: string
-
-    /**
-     * A url to where to find the asset, or get more info about it in the source
-     */
-    url?: string
-  }
-}
-
-export type InsertPatch =
-  | {before: string; items: any[]}
-  | {after: string; items: any[]}
-  | {replace: string; items: any[]}
-
-// Note: this is actually incorrect/invalid, but implemented as-is for backwards compatibility
-export 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
-}
-
-export type PatchBuilder = (patch: Patch) => Patch
-
-export type PatchMutationOperation = PatchOperations & MutationSelection
-
-export type Mutation<R extends Record<string, any> = Record<string, any>> =
-  | {create: SanityDocumentStub<R>}
-  | {createOrReplace: IdentifiedSanityDocumentStub<R>}
-  | {createIfNotExists: IdentifiedSanityDocumentStub<R>}
-  | {delete: MutationSelection}
-  | {patch: PatchMutationOperation}
-
-export interface SingleMutationResult {
-  transactionId: string
-  documentId: string
-  results: {id: string; operation: MutationOperation}[]
+  list(this: DatasetsClient): Promise<DatasetsResponse>
+  list(this: ObservableDatasetsClient): Observable<DatasetsResponse>
 }
 
-export interface MultipleMutationResult {
-  transactionId: string
-  documentIds: string[]
-  results: {id: string; operation: MutationOperation}[]
+export declare type BaseMutationOptions = RequestOptions & {
+  visibility?: 'sync' | 'async' | 'deferred'
+  returnDocuments?: boolean
+  returnFirst?: boolean
+  dryRun?: boolean
+  autoGenerateArrayKeys?: boolean
+  skipCrossDatasetReferenceValidation?: boolean
 }
 
-export abstract class BasePatch {
+export declare class BasePatch {
+  protected selection: PatchSelection
+  protected operations: PatchOperations
+  constructor(selection: PatchSelection, operations?: PatchOperations)
   /**
    * DEPRECATED: Don't use.
    * The operation is added to the current patch, ready to be commited by `commit()`
@@ -233,7 +173,6 @@ export abstract class BasePatch {
    * @param attrs Attributes to replace
    */
   replace(attrs: AttributeSet): this
-
   /**
    * Sets the given attributes to the document. Does NOT merge objects.
    * The operation is added to the current patch, ready to be commited by `commit()`
@@ -241,7 +180,6 @@ export abstract class BasePatch {
    * @param attrs Attributes to set. To set a deep attribute, use JSONMatch, eg: {"nested.prop": "value"}
    */
   set(attrs: AttributeSet): this
-
   /**
    * Sets the given attributes to the document if they are not currently set. Does NOT merge objects.
    * The operation is added to the current patch, ready to be commited by `commit()`
@@ -249,7 +187,6 @@ export abstract class BasePatch {
    * @param attrs Attributes to set. To set a deep attribute, use JSONMatch, eg: {"nested.prop": "value"}
    */
   setIfMissing(attrs: AttributeSet): this
-
   /**
    * Performs a "diff-match-patch" operation on the string attributes provided.
    * The operation is added to the current patch, ready to be commited by `commit()`
@@ -257,7 +194,6 @@ export abstract class BasePatch {
    * @param attrs Attributes to perform operation on. To set a deep attribute, use JSONMatch, eg: {"nested.prop": "dmp"}
    */
   diffMatchPatch(attrs: AttributeSet): this
-
   /**
    * Unsets the attribute paths provided.
    * The operation is added to the current patch, ready to be commited by `commit()`
@@ -265,21 +201,18 @@ export abstract class BasePatch {
    * @param attrs Attribute paths to unset.
    */
   unset(attrs: string[]): this
-
   /**
    * Increment a numeric value. Each entry in the argument is either an attribute or a JSON path. The value may be a positive or negative integer or floating-point value. The operation will fail if target value is not a numeric value, or doesn't exist.
    *
    * @param attrs Object of attribute paths to increment, values representing the number to increment by.
    */
   inc(attrs: {[key: string]: number}): this
-
   /**
    * Decrement a numeric value. Each entry in the argument is either an attribute or a JSON path. The value may be a positive or negative integer or floating-point value. The operation will fail if target value is not a numeric value, or doesn't exist.
    *
    * @param attrs Object of attribute paths to decrement, values representing the number to decrement by.
    */
   dec(attrs: {[key: string]: number}): this
-
   /**
    * Provides methods for modifying arrays, by inserting, appending and replacing elements via a JSONPath expression.
    *
@@ -288,7 +221,6 @@ export abstract class BasePatch {
    * @param items Array of items to insert/replace
    */
   insert(at: 'before' | 'after' | 'replace', selector: string, items: any[]): this
-
   /**
    * Append the given items to the array at the given JSONPath
    *
@@ -296,7 +228,6 @@ export abstract class BasePatch {
    * @param items Array of items to append to the array
    */
   append(selector: string, items: any[]): this
-
   /**
    * Prepend the given items to the array at the given JSONPath
    *
@@ -304,7 +235,6 @@ export abstract class BasePatch {
    * @param items Array of items to prepend to the array
    */
   prepend(selector: string, items: any[]): this
-
   /**
    * Change the contents of an array by removing existing elements and/or adding new elements.
    *
@@ -314,306 +244,157 @@ export abstract class BasePatch {
    * @param items The elements to add to the array, beginning at the start index. If you don't specify any elements, splice() will only remove elements from the array.
    */
   splice(selector: string, start: number, deleteCount: number, items: any[]): this
-
   /**
    * Adds a revision clause, preventing the document from being patched if the `_rev` property does not match the given value
    *
    * @param rev Revision to lock the patch to
    */
   ifRevisionId(rev: string): this
-
   /**
    * Return a plain JSON representation of the patch
    */
   serialize(): PatchMutationOperation
-
   /**
    * Return a plain JSON representation of the patch
    */
   toJSON(): PatchMutationOperation
-
   /**
    * Clears the patch of all operations
    */
   reset(): this
+  protected _assign(op: keyof PatchOperations, props: any, merge?: boolean): this
+  protected _set(op: keyof PatchOperations, props: any): this
 }
 
-export class Patch extends BasePatch {
-  constructor(documentId: string, operations?: PatchOperations, client?: SanityClient)
-
+export declare class BaseProjectsClient {
+  client: SanityClient | ObservableSanityClient
   /**
-   * Clones the patch
+   * Fetch a list of projects the authenticated user has access to
    */
-  clone(): Patch
-
+  list(this: ProjectsClient): Promise<SanityProject[]>
+  list(this: ObservableProjectsClient): Observable<SanityProject[]>
   /**
-   * Commit the patch, returning a promise that resolves to the first patched document
+   * Fetch a project by project ID
    *
-   * @param options Options for the mutation operation
+   * @param projectId - ID of the project to fetch
    */
-  commit<R extends Record<string, any> = Record<string, any>>(
-    options: FirstDocumentMutationOptions
-  ): Promise<SanityDocument<R>>
+  getById(this: ProjectsClient, projectId: string): Promise<SanityProject>
+  getById(this: ObservableProjectsClient, projectId: string): Observable<SanityProject>
+}
 
+export declare class BaseSanityClient {
+  #private
+  constructor(config: ClientConfig)
+  /** @internal */
+  protected config(newConfig?: Partial<ClientConfig>): ClientConfig | this
   /**
-   * Commit the patch, returning a promise that resolves to an array of the mutated documents
-   *
-   * @param options Options for the mutation operation
+   * Returns whether or not this client is using the Promise API (otherwise it is using observables)
+   * @internal
+   * @deprecated Internals, should not be used externally
    */
-  commit<R extends Record<string, any> = Record<string, any>>(
-    options: AllDocumentsMutationOptions
-  ): Promise<SanityDocument<R>[]>
-
+  isPromiseAPI(): this is SanityClient
   /**
-   * Commit the patch, returning a promise that resolves to a mutation result object
+   * DEPRECATED: Get a Sanity API URL for the URI provided
    *
-   * @param options Options for the mutation operation
+   * @deprecated Should be an internal concern
+   * @param uri URI/path to build URL for
+   * @param canUseCdn Whether or not to allow using the API CDN for this route
    */
-  commit(options: FirstDocumentIdMutationOptions): Promise<SingleMutationResult>
-
+  getUrl(uri: string, canUseCdn?: boolean): string
   /**
-   * Commit the patch, returning a promise that resolves to a mutation result object
+   * DEPRECATED: Get a Sanity API URL for the data operation and path provided
    *
-   * @param options Options for the mutation operation
+   * @deprecated Should be an internal concern
+   * @param operation Data operation
+   * @param path Path to append
    */
-  commit(options: AllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
+  getDataUrl(operation: string, path?: string): string
+}
 
+export declare class BaseTransaction {
+  protected operations: Mutation[]
+  protected trxId?: string
+  constructor(operations?: Mutation[], transactionId?: string)
   /**
-   * Commit the patch, returning a promise that resolves to the first patched document
+   * Creates a new Sanity document. If `_id` is provided and already exists, the mutation will fail. If no `_id` is given, one will automatically be generated by the database.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
    *
-   * @param options Options for the mutation operation
+   * @param doc - Document to create. Requires a `_type` property.
    */
-  commit<R extends Record<string, any> = Record<string, any>>(
-    options?: BaseMutationOptions
-  ): Promise<SanityDocument<R>>
-}
-
-export class ObservablePatch extends BasePatch {
-  constructor(documentId: string, operations?: PatchOperations, client?: ObservableSanityClient)
-
+  create<R extends Record<string, any> = Record<string, any>>(doc: SanityDocumentStub<R>): this
   /**
-   * Clones the patch
+   * Creates a new Sanity document. If a document with the same `_id` already exists, the create operation will be ignored.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param doc - Document to create if it does not already exist. Requires `_id` and `_type` properties.
    */
-  clone(): ObservablePatch
-
+  createIfNotExists<R extends Record<string, any> = Record<string, any>>(
+    doc: IdentifiedSanityDocumentStub<R>
+  ): this
   /**
-   * Commit the patch, returning an observable that produces the first patched document
+   * Creates a new Sanity document, or replaces an existing one if the same `_id` is already used.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
    *
-   * @param options Options for the mutation operation
+   * @param doc - Document to create or replace. Requires `_id` and `_type` properties.
    */
-  commit<R extends Record<string, any> = Record<string, any>>(
-    options: FirstDocumentMutationOptions
-  ): Observable<SanityDocument<R>>
-
+  createOrReplace<R extends Record<string, any> = Record<string, any>>(
+    doc: IdentifiedSanityDocumentStub<R>
+  ): this
   /**
-   * Commit the patch, returning an observable that produces an array of the mutated documents
+   * Deletes the document with the given document ID
+   * The operation is added to the current transaction, ready to be commited by `commit()`
    *
-   * @param options Options for the mutation operation
-   */
-  commit<R extends Record<string, any> = Record<string, any>>(
-    options: AllDocumentsMutationOptions
-  ): Observable<SanityDocument<R>[]>
-
-  /**
-   * Commit the patch, returning an observable that produces a mutation result object
-   *
-   * @param options Options for the mutation operation
-   */
-  commit(options: FirstDocumentIdMutationOptions): Observable<SingleMutationResult>
-
-  /**
-   * Commit the patch, returning an observable that produces a mutation result object
-   *
-   * @param options Options for the mutation operation
-   */
-  commit(options: AllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
-
-  /**
-   * Commit the patch, returning an observable that produces the first patched document
-   *
-   * @param options Options for the mutation operation
-   */
-  commit<R extends Record<string, any> = Record<string, any>>(
-    options?: BaseMutationOptions
-  ): Observable<SanityDocument<R>>
-}
-
-export abstract class BaseTransaction {
-  /**
-   * Creates a new Sanity document. If `_id` is provided and already exists, the mutation will fail. If no `_id` is given, one will automatically be generated by the database.
-   * The operation is added to the current transaction, ready to be commited by `commit()`
-   *
-   * @param doc Document to create. Requires a `_type` property.
-   */
-  create<R extends Record<string, any> = Record<string, any>>(doc: SanityDocumentStub<R>): this
-
-  /**
-   * Creates a new Sanity document. If a document with the same `_id` already exists, the create operation will be ignored.
-   * The operation is added to the current transaction, ready to be commited by `commit()`
-   *
-   * @param doc Document to create if it does not already exist. Requires `_id` and `_type` properties.
-   */
-  createIfNotExists<R extends Record<string, any> = Record<string, any>>(
-    doc: IdentifiedSanityDocumentStub<R>
-  ): this
-
-  /**
-   * Creates a new Sanity document, or replaces an existing one if the same `_id` is already used.
-   * The operation is added to the current transaction, ready to be commited by `commit()`
-   *
-   * @param doc Document to create or replace. Requires `_id` and `_type` properties.
-   */
-  createOrReplace<R extends Record<string, any> = Record<string, any>>(
-    doc: IdentifiedSanityDocumentStub<R>
-  ): this
-
-  /**
-   * Deletes the document with the given document ID
-   * The operation is added to the current transaction, ready to be commited by `commit()`
-   *
-   * @param documentId Document ID to delete
+   * @param documentId - Document ID to delete
    */
   delete(documentId: string): this
-
-  /**
-   * 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?: PatchBuilder | 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 Patch to execute
+   * Gets the current transaction ID, if any
    */
-  patch(patch: Patch): this
-
+  transactionId(): string | undefined
   /**
-   * Set or gets the ID of this transaction.
-   * Should generally not be specified.
-   * If no ID is specified, the currently configured ID will be returned, if any.
+   * Set the ID of this transaction.
    *
-   * @param id Transaction ID
+   * @param id - Transaction ID
    */
-  transactionId<T extends string | undefined>(id: T): T extends string ? this : string | undefined
-
+  transactionId(id: string): this
   /**
    * Return a plain JSON representation of the transaction
    */
   serialize(): Mutation[]
-
   /**
    * Return a plain JSON representation of the transaction
    */
   toJSON(): Mutation[]
-
   /**
    * Clears the transaction of all operations
    */
   reset(): this
+  protected _add(mut: Mutation): this
 }
 
-export class Transaction extends BaseTransaction {
-  constructor(operations?: Mutation[], client?: SanityClient, transactionId?: string)
-
-  /**
-   * Clones the transaction
-   */
-  clone(): Transaction
-
-  /**
-   * Commit the transaction, returning a promise that resolves to the first mutated document
-   *
-   * @param options Options for the mutation operation
-   */
-  commit<R extends Record<string, any>>(
-    options: TransactionFirstDocumentMutationOptions
-  ): Promise<SanityDocument<R>>
-
-  /**
-   * Commit the transaction, 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>>(
-    options: TransactionAllDocumentsMutationOptions
-  ): Promise<SanityDocument<R>[]>
-
-  /**
-   * Commit the transaction, returning a promise that resolves to a mutation result object
-   *
-   * @param options Options for the mutation operation
-   */
-  commit(options: TransactionFirstDocumentIdMutationOptions): Promise<SingleMutationResult>
-
-  /**
-   * Commit the transaction, returning a promise that resolves to a mutation result object
-   *
-   * @param options Options for the mutation operation
-   */
-  commit(options: TransactionAllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
-
+export declare class BaseUsersClient {
+  client: SanityClient | ObservableSanityClient
   /**
-   * Commit the transaction, returning a promise that resolves to a mutation result object
+   * Fetch a user by user ID
    *
-   * @param options Options for the mutation operation
+   * @param id - User ID of the user to fetch. If `me` is provided, a minimal response including the users role is returned.
    */
-  commit(options?: BaseMutationOptions): Promise<MultipleMutationResult>
+  getById<T extends 'me' | string>(
+    this: UsersClient,
+    id: T
+  ): Promise<T extends 'me' ? CurrentSanityUser : SanityUser>
+  getById<T extends 'me' | string>(
+    this: ObservableUsersClient,
+    id: T
+  ): Observable<T extends 'me' ? CurrentSanityUser : SanityUser>
 }
 
-export class ObservableTransaction extends BaseTransaction {
-  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>
+export declare type ChannelErrorEvent = {
+  type: 'channelError'
+  message: string
 }
 
-export interface ClientConfig {
+export declare interface ClientConfig {
   projectId?: string
   dataset?: string
   useCdn?: boolean
@@ -626,90 +407,165 @@ export interface ClientConfig {
   withCredentials?: boolean
   allowReconfigure?: boolean
   timeout?: number
-
   /**
    * @deprecated Don't use
    */
   useProjectHostname?: boolean
-
   /**
    * @deprecated Don't use
    */
-  requester?: GetItRequester
+  requester?: Requester
 }
 
-/**
- * @deprecated Don't use
- */
-export type ProjectlessClientConfig = ClientConfig & {useProjectHostname: false}
+export declare class ClientError extends BaseError {
+  response: ErrorProps['response']
+  statusCode: ErrorProps['statusCode']
+  responseBody: ErrorProps['responseBody']
+  details: ErrorProps['details']
+  constructor(res: any)
+}
 
-/**
- * @deprecated Don't use
- */
-export type ProjectClientConfig = ClientConfig & {
-  useProjectHostname?: true
-  projectId: string
+export declare function createClient(config: ClientConfig): SanityClient
+
+export declare interface CurrentSanityUser {
+  id: string
+  name: string
+  email: string
+  profileImage: string | null
+  role: string
 }
 
-export interface RequestOptions {
-  timeout?: number
-  token?: string
-  tag?: string
-  headers?: Record<string, string>
+export declare type DatasetAclMode = 'public' | 'private' | 'custom'
+
+export declare type DatasetResponse = {
+  datasetName: string
+  aclMode: DatasetAclMode
 }
 
-type BaseMutationOptions = RequestOptions & {
-  visibility?: 'sync' | 'async' | 'deferred'
-  returnDocuments?: boolean
-  returnFirst?: boolean
-  dryRun?: boolean
-  autoGenerateArrayKeys?: boolean
-  skipCrossDatasetReferenceValidation?: boolean
+export declare class DatasetsClient extends BaseDatasetsClient {
+  client: SanityClient
+  constructor(client: SanityClient)
 }
 
-export type MutationEvent<R extends Record<string, any> = Record<string, any>> = {
-  type: 'mutation'
-  documentId: string
-  eventId: string
-  identity: string
-  mutations: Mutation[]
-  previousRev?: string
-  resultRev?: string
-  result?: SanityDocument<R>
-  previous?: SanityDocument<R> | null
-  effects?: {apply: unknown[]; revert: unknown[]}
-  timestamp: string
-  transactionId: string
-  transition: 'update' | 'appear' | 'disappear'
-  visibility: 'query' | 'transaction'
+export declare type DatasetsResponse = {
+  name: string
+  aclMode: DatasetAclMode
+}[]
+
+export declare type DisconnectEvent = {
+  type: 'disconnect'
+  reason: string
 }
 
-export type ChannelErrorEvent = {
-  type: 'channelError'
+export declare interface ErrorProps {
   message: string
+  response: any
+  statusCode: number
+  responseBody: any
+  details: any
 }
 
-export type DisconnectEvent = {
-  type: 'disconnect'
-  reason: string
+export declare type FilteredResponseQueryOptions = RequestOptions & {
+  filterResponse?: true
 }
 
-export type ReconnectEvent = {
-  type: 'reconnect'
+export declare type FirstDocumentIdMutationOptions = BaseMutationOptions & {
+  returnFirst?: true
+  returnDocuments: false
 }
 
-export type WelcomeEvent = {
-  type: 'welcome'
+export declare type FirstDocumentMutationOptions = BaseMutationOptions & {
+  returnFirst?: true
+  returnDocuments?: true
+}
+
+export declare type HttpRequest = {
+  defaultRequester: Requester
+  (options: RequestOptions, requester: Requester): ReturnType<Requester>
+}
+
+export declare type HttpRequestEvent<T = unknown> = ResponseEvent<T> | ProgressEvent_2
+
+export declare type IdentifiedSanityDocumentStub<
+  T extends Record<string, any> = Record<string, any>
+> = {
+  [P in keyof T]: T[P]
+} & {
+  _id: string
+} & SanityDocumentStub
+
+export declare interface InitializedClientConfig extends ClientConfig {
+  apiHost: string
+  apiVersion: string
+  useProjectHostname: boolean
+  useCdn: boolean
+  /**
+   * @deprecated Don't use
+   */
+  isDefaultApi: boolean
+  /**
+   * @deprecated Don't use
+   */
+  url: string
+  /**
+   * @deprecated Don't use
+   */
+  cdnUrl: string
 }
 
-export type ListenEvent<R extends Record<string, any>> =
-  | MutationEvent<R>
+export declare type InsertPatch =
+  | {
+      before: string
+      items: any[]
+    }
+  | {
+      after: string
+      items: any[]
+    }
+  | {
+      replace: string
+      items: any[]
+    }
+
+/**
+ * Set up a listener that will be notified when mutations occur on documents matching the provided query/filter.
+ *
+ * @param query GROQ-filter to listen to changes for
+ * @param params Optional query parameters
+ * @param options Listener options
+ * @internal
+ */
+export declare function _listen<R extends Record<string, any> = Record<string, any>>(
+  this: SanityClient,
+  query: string,
+  params?: QueryParams
+): Observable<MutationEvent_2<R>>
+
+/**
+ * Set up a listener that will be notified when mutations occur on documents matching the provided query/filter.
+ *
+ * @param query GROQ-filter to listen to changes for
+ * @param params Optional query parameters
+ * @param options Listener options
+ * @internal
+ */
+export declare function _listen<R extends Record<string, any> = Record<string, any>>(
+  this: SanityClient,
+  query: string,
+  params?: QueryParams,
+  options?: ListenOptions
+): Observable<ListenEvent<R>>
+
+export declare type ListenEvent<R extends Record<string, any>> =
+  | MutationEvent_2<R>
   | ChannelErrorEvent
   | DisconnectEvent
   | ReconnectEvent
   | WelcomeEvent
 
-export interface ListenOptions {
+export declare type ListenEventName = 'mutation' | 'welcome' | 'reconnect'
+
+export declare interface ListenOptions {
   includeResult?: boolean
   includePreviousRevision?: boolean
   visibility?: 'sync' | 'async' | 'query'
@@ -718,384 +574,199 @@ export interface ListenOptions {
   tag?: string
 }
 
-export type PreviousNextListenOptions = ListenOptions & {
-  includeResult: true
-  includePreviousRevision: true
-}
-
-export type PreviousListenOptions = ListenOptions & {
-  includePreviousRevision: true
-  includeResult: false
-}
-
-export type NextListenOptions = ListenOptions & {
-  includePreviousRevision: false
-  includeResult: true
+export declare interface MultipleMutationResult {
+  transactionId: string
+  documentIds: string[]
+  results: {
+    id: string
+    operation: MutationOperation
+  }[]
 }
 
-export type ResultlessListenOptions = ListenOptions & {
-  includeResult: false
-  includePreviousRevision: false
-}
-
-export type FilteredResponseQueryOptions = RequestOptions & {
-  filterResponse?: true
-}
-
-export type UnfilteredResponseQueryOptions = RequestOptions & {
-  filterResponse: false
-}
-
-export type QueryOptions = FilteredResponseQueryOptions | UnfilteredResponseQueryOptions
-
-type FirstDocumentMutationOptions = BaseMutationOptions & {
-  returnFirst?: true
-  returnDocuments?: true
-}
-
-type FirstDocumentIdMutationOptions = BaseMutationOptions & {
-  returnFirst?: true
-  returnDocuments: false
-}
-
-type AllDocumentsMutationOptions = BaseMutationOptions & {
-  returnFirst: false
-  returnDocuments?: true
-}
-
-type AllDocumentIdsMutationOptions = BaseMutationOptions & {
-  returnFirst: false
-  returnDocuments: false
-}
-
-export type MutationOptions =
-  | FirstDocumentMutationOptions
-  | FirstDocumentIdMutationOptions
-  | AllDocumentsMutationOptions
-  | AllDocumentIdsMutationOptions
-
-type TransactionFirstDocumentMutationOptions = BaseMutationOptions & {
-  returnFirst: true
-  returnDocuments: true
-}
-
-type TransactionFirstDocumentIdMutationOptions = BaseMutationOptions & {
-  returnFirst: true
-  returnDocuments?: false
-}
-
-type TransactionAllDocumentsMutationOptions = BaseMutationOptions & {
-  returnFirst?: false
-  returnDocuments: true
-}
+export declare type Mutation<R extends Record<string, any> = Record<string, any>> =
+  | {
+      create: SanityDocumentStub<R>
+    }
+  | {
+      createOrReplace: IdentifiedSanityDocumentStub<R>
+    }
+  | {
+      createIfNotExists: IdentifiedSanityDocumentStub<R>
+    }
+  | {
+      delete: MutationSelection
+    }
+  | {
+      patch: PatchMutationOperation
+    }
 
-type TransactionAllDocumentIdsMutationOptions = BaseMutationOptions & {
-  returnFirst?: false
-  returnDocuments?: false
+declare type MutationEvent_2<R extends Record<string, any> = Record<string, any>> = {
+  type: 'mutation'
+  documentId: string
+  eventId: string
+  identity: string
+  mutations: Mutation[]
+  previousRev?: string
+  resultRev?: string
+  result?: SanityDocument<R>
+  previous?: SanityDocument<R> | null
+  effects?: {
+    apply: unknown[]
+    revert: unknown[]
+  }
+  timestamp: string
+  transactionId: string
+  transition: 'update' | 'appear' | 'disappear'
+  visibility: 'query' | 'transaction'
 }
+export {MutationEvent_2 as MutationEvent}
 
-export type TransactionMutationOptions =
-  | TransactionFirstDocumentMutationOptions
-  | TransactionFirstDocumentIdMutationOptions
-  | TransactionAllDocumentsMutationOptions
-  | TransactionAllDocumentIdsMutationOptions
-
-export interface RawQueryResponse<R> {
-  q: string
-  ms: number
-  result: R
-}
+export declare type MutationOperation = 'create' | 'delete' | 'update' | 'none'
 
-export type SanityDocument<T extends Record<string, any> = Record<string, any>> = {
-  [P in keyof T]: T[P]
-} & {
-  _id: string
-  _rev: string
-  _type: string
-  _createdAt: string
-  _updatedAt: string
-}
+export declare type MutationSelection =
+  | {
+      query: string
+      params?: QueryParams
+    }
+  | {
+      id: string | string[]
+    }
 
-export type SanityDocumentStub<T extends Record<string, any> = Record<string, any>> = {
-  [P in keyof T]: T[P]
-} & {
-  _type: string
+export declare class ObservableAssetsClient {
+  #private
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
+  /**
+   * Uploads a file 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',
+    body: File | Blob | Buffer | NodeJS.ReadableStream,
+    options?: UploadClientConfig
+  ): Observable<
+    HttpRequestEvent<{
+      document: SanityAssetDocument
+    }>
+  >
+  /**
+   * Uploads 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: 'image',
+    body: File | Blob | Buffer | NodeJS.ReadableStream,
+    options?: UploadClientConfig
+  ): Observable<
+    HttpRequestEvent<{
+      document: SanityImageAssetDocument
+    }>
+  >
 }
 
-export type IdentifiedSanityDocumentStub<T extends Record<string, any> = Record<string, any>> = {
-  [P in keyof T]: T[P]
-} & {
-  _id: string
-} & SanityDocumentStub
-
-export interface SanityAssetDocument extends SanityDocument {
-  url: string
-  path: string
-  size: number
-  assetId: string
-  mimeType: string
-  sha1hash: string
-  extension: string
-  uploadId?: string
-  originalFilename?: string
+export declare class ObservableAuthClient extends BaseAuthClient {
+  client: ObservableSanityClient
+  constructor(client: ObservableSanityClient)
 }
 
-export interface SanityImagePalette {
-  background: string
-  foreground: string
-  population: number
-  title: string
+export declare class ObservableDatasetsClient extends BaseDatasetsClient {
+  client: ObservableSanityClient
+  constructor(client: ObservableSanityClient)
 }
 
-export interface SanityImageAssetDocument extends SanityAssetDocument {
-  metadata: {
-    _type: 'sanity.imageMetadata'
-    hasAlpha: boolean
-    isOpaque: boolean
-    lqip?: string
-    blurHash?: string
-    dimensions: {
-      _type: 'sanity.imageDimensions'
-      aspectRatio: number
-      height: number
-      width: number
-    }
-    palette?: {
-      _type: 'sanity.imagePalette'
-      darkMuted?: SanityImagePalette
-      darkVibrant?: SanityImagePalette
-      dominant?: SanityImagePalette
-      lightMuted?: SanityImagePalette
-      lightVibrant?: SanityImagePalette
-      muted?: SanityImagePalette
-      vibrant?: SanityImagePalette
-    }
-    image?: {
-      _type: 'sanity.imageExifTags'
-      [key: string]: any
-    }
-    exif?: {
-      _type: 'sanity.imageExifMetadata'
-      [key: string]: any
-    }
-  }
+export declare class ObservablePatch extends BasePatch {
+  #private
+  constructor(
+    selection: PatchSelection,
+    operations?: PatchOperations,
+    client?: ObservableSanityClient
+  )
+  /**
+   * Clones the patch
+   */
+  clone(): ObservablePatch
+  /**
+   * Commit the patch, returning an observable that produces the first patched document
+   *
+   * @param options Options for the mutation operation
+   */
+  commit<R extends Record<string, any> = Record<string, any>>(
+    options: FirstDocumentMutationOptions
+  ): Observable<SanityDocument<R>>
+  /**
+   * Commit the patch, returning an observable that produces an array of the mutated documents
+   *
+   * @param options Options for the mutation operation
+   */
+  commit<R extends Record<string, any> = Record<string, any>>(
+    options: AllDocumentsMutationOptions
+  ): Observable<SanityDocument<R>[]>
+  /**
+   * Commit the patch, returning an observable that produces a mutation result object
+   *
+   * @param options Options for the mutation operation
+   */
+  commit(options: FirstDocumentIdMutationOptions): Observable<SingleMutationResult>
+  /**
+   * Commit the patch, returning an observable that produces a mutation result object
+   *
+   * @param options Options for the mutation operation
+   */
+  commit(options: AllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
+  /**
+   * Commit the patch, returning an observable that produces the first patched document
+   *
+   * @param options Options for the mutation operation
+   */
+  commit<R extends Record<string, any> = Record<string, any>>(
+    options?: BaseMutationOptions
+  ): Observable<SanityDocument<R>>
 }
 
-export class ClientError extends Error {
-  response: any
-  statusCode: number
-  responseBody?: any
-  details?: any
-}
+export declare type ObservablePatchBuilder = (patch: ObservablePatch) => ObservablePatch
 
-export class ServerError extends Error {
-  response: any
-  statusCode: number
-  responseBody?: any
-  details?: any
+export declare class ObservableProjectsClient extends BaseProjectsClient {
+  client: ObservableSanityClient
+  constructor(client: ObservableSanityClient)
 }
 
-export class ObservableSanityClient {
-  static Patch: typeof Patch
-  static Transaction: typeof Transaction
-  static ClientError: typeof ClientError
-  static ServerError: typeof ServerError
-  static requester: GetItRequester
-
-  // Client/configuration
-  constructor(config: ClientConfig)
-
+export declare class ObservableSanityClient extends BaseSanityClient {
+  #private
+  assets: ObservableAssetsClient
+  auth: ObservableAuthClient
+  datasets: ObservableDatasetsClient
+  projects: ObservableProjectsClient
+  users: ObservableUsersClient
+  constructor(httpRequest: HttpRequest, config: ClientConfig)
   /**
    * Clone the client - returns a new instance
    */
   clone(): ObservableSanityClient
-
   /**
    * Returns the current client configuration
    */
-  config(): ClientConfig
-
+  config(): InitializedClientConfig
   /**
    * Reconfigure the client. Note that this _mutates_ the current client.
-   *
-   * @param newConfig New client configuration properties
    */
   config(newConfig?: Partial<ClientConfig>): this
-
   /**
    * Clone the client with a new (partial) configuration.
    *
    * @param newConfig New client configuration properties, shallowly merged with existing configuration
    */
   withConfig(newConfig?: Partial<ClientConfig>): ObservableSanityClient
-
-  /**
-   * @deprecated Use `client.config()` instead
-   */
-  clientConfig: ClientConfig
-
-  assets: {
-    /**
-     * Uploads a file 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: File | Blob | Buffer | NodeJS.ReadableStream,
-      options?: UploadOptions
-    ): Observable<
-      ResponseEvent<{document: SanityAssetDocument | SanityImageAssetDocument}> | ProgressEvent
-    >
-
-    /**
-     * Uploads a file 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',
-      body: File | Blob | Buffer | NodeJS.ReadableStream,
-      options?: UploadOptions
-    ): Observable<ResponseEvent<{document: SanityAssetDocument}> | ProgressEvent>
-
-    /**
-     * Uploads 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: 'image',
-      body: File | Blob | Buffer | NodeJS.ReadableStream,
-      options?: UploadOptions
-    ): Observable<ResponseEvent<{document: SanityImageAssetDocument}> | ProgressEvent>
-
-    /**
-     * DEPRECATED: Deletes an asset of the given type and ID
-     *
-     * @deprecated Use `client.delete(assetDocumentId)` instead
-     * @param assetType Asset type (file/image)
-     * @param id Document ID or asset document to delete
-     */
-    delete(
-      assetType: 'file' | 'image',
-      id: string | IdentifiedSanityDocumentStub
-    ): Observable<SanityAssetDocument | undefined>
-
-    /**
-     * DEPRECATED: Returns the URL for an asset with a given document ID
-     *
-     * @deprecated Use the `@sanity/image-url` module instead
-     * @param id Document ID or asset reference to get URL for
-     * @param query Optional object of query string parameters to append
-     */
-    getImageUrl(id: string | SanityReference, query: {[key: string]: string | number}): string
-  }
-
-  datasets: {
-    /**
-     * 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<{datasetName: string; aclMode: DatasetAclMode}>
-
-    /**
-     * 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<{datasetName: string; aclMode: DatasetAclMode}>
-
-    /**
-     * 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<{name: string; aclMode: DatasetAclMode}[]>
-  }
-
-  projects: {
-    /**
-     * Fetch a list of projects the authenticated user has access to
-     */
-    list(): Observable<SanityProject[]>
-
-    /**
-     * Fetch a project by project ID
-     *
-     * @param projectId ID of the project to fetch
-     */
-    getById(projectId: string): Observable<SanityProject>
-  }
-
-  users: {
-    /**
-     * 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
-    ): T extends 'me' ? Observable<CurrentSanityUser> : Observable<SanityUser>
-  }
-
-  auth: {
-    /**
-     * Fetch available login providers
-     */
-    getLoginProviders(): Observable<{providers: AuthProvider[]}>
-
-    /**
-     * Revoke the configured session/token
-     */
-    logout(): Observable<any>
-  }
-
-  /**
-   * Set up a listener that will be notified when mutations occur on documents matching the provided query/filter.
-   *
-   * @param query GROQ-filter to listen to changes for
-   * @param params Optional query parameters
-   * @param options Listener options
-   */
-  listen(query: string, params?: QueryParams): Observable<MutationEvent>
-
-  /**
-   * Set up a listener that will be notified when mutations occur on documents matching the provided query/filter.
-   *
-   * @param query GROQ-filter to listen to changes for
-   * @param params Optional query parameters
-   * @param options Listener options
-   */
-  listen(query: string, params?: QueryParams, options?: ListenOptions): Observable<ListenEvent<any>>
-
   /**
    * Perform a GROQ-query against the configured dataset.
    *
    * @param query GROQ-query to perform
    */
   fetch<R = any>(query: string): Observable<R>
-
   /**
    * Perform a GROQ-query against the configured dataset.
    *
@@ -1103,7 +774,6 @@ export class ObservableSanityClient {
    * @param params Query parameters
    */
   fetch<R = any>(query: string, params: QueryParams): Observable<R>
-
   /**
    * Perform a GROQ-query against the configured dataset.
    *
@@ -1116,7 +786,6 @@ export class ObservableSanityClient {
     params: QueryParams | undefined,
     options: FilteredResponseQueryOptions
   ): Observable<R>
-
   /**
    * Perform a GROQ-query against the configured dataset.
    *
@@ -1129,7 +798,6 @@ export class ObservableSanityClient {
     params: QueryParams | undefined,
     options: UnfilteredResponseQueryOptions
   ): Observable<RawQueryResponse<R>>
-
   /**
    * Fetch a single document with the given ID.
    *
@@ -1138,9 +806,10 @@ export class ObservableSanityClient {
    */
   getDocument<R extends Record<string, any> = Record<string, any>>(
     id: string,
-    options?: {tag?: string}
+    options?: {
+      tag?: string
+    }
   ): Observable<SanityDocument<R> | undefined>
-
   /**
    * Fetch multiple documents in one request.
    * Should be used sparingly - performing a query is usually a better option.
@@ -1152,9 +821,10 @@ export class ObservableSanityClient {
    */
   getDocuments<R extends Record<string, any> = Record<string, any>>(
     ids: string[],
-    options?: {tag?: string}
+    options?: {
+      tag?: string
+    }
   ): Observable<(SanityDocument<R> | null)[]>
-
   /**
    * 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.
@@ -1166,7 +836,6 @@ export class ObservableSanityClient {
     document: SanityDocumentStub<R>,
     options: FirstDocumentMutationOptions
   ): 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 an array containing the created document.
@@ -1178,7 +847,6 @@ export class ObservableSanityClient {
     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.
@@ -1190,7 +858,6 @@ export class ObservableSanityClient {
     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.
@@ -1202,7 +869,6 @@ export class ObservableSanityClient {
     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.
@@ -1214,7 +880,6 @@ export class ObservableSanityClient {
     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.
@@ -1226,7 +891,6 @@ export class ObservableSanityClient {
     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.
@@ -1238,7 +902,6 @@ export class ObservableSanityClient {
     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.
@@ -1250,7 +913,6 @@ export class ObservableSanityClient {
     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.
@@ -1262,7 +924,6 @@ export class ObservableSanityClient {
     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.
@@ -1274,7 +935,6 @@ export class ObservableSanityClient {
     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.
@@ -1286,7 +946,6 @@ export class ObservableSanityClient {
     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.
@@ -1298,7 +957,6 @@ export class ObservableSanityClient {
     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.
@@ -1310,7 +968,6 @@ export class ObservableSanityClient {
     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.
@@ -1322,7 +979,6 @@ export class ObservableSanityClient {
     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.
@@ -1334,7 +990,6 @@ export class ObservableSanityClient {
     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.
@@ -1346,7 +1001,6 @@ export class ObservableSanityClient {
     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.
@@ -1358,7 +1012,6 @@ export class ObservableSanityClient {
     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.
@@ -1367,7 +1020,6 @@ export class ObservableSanityClient {
    * @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.
@@ -1376,7 +1028,6 @@ export class ObservableSanityClient {
    * @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.
@@ -1388,7 +1039,6 @@ export class ObservableSanityClient {
     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.
@@ -1400,7 +1050,6 @@ export class ObservableSanityClient {
     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.
@@ -1412,7 +1061,6 @@ export class ObservableSanityClient {
     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.
@@ -1424,7 +1072,6 @@ export class ObservableSanityClient {
     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.
@@ -1436,7 +1083,6 @@ export class ObservableSanityClient {
     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.
@@ -1448,7 +1094,6 @@ export class ObservableSanityClient {
     selection: MutationSelection,
     options?: BaseMutationOptions
   ): Observable<SanityDocument<R>>
-
   /**
    * Perform mutation operations against the configured dataset
    * Returns an observable that resolves to the first mutated document.
@@ -1457,10 +1102,9 @@ export class ObservableSanityClient {
    * @param options Mutation options
    */
   mutate<R extends Record<string, any> = Record<string, any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
+    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.
@@ -1469,10 +1113,9 @@ export class ObservableSanityClient {
    * @param options Mutation options
    */
   mutate<R extends Record<string, any> = Record<string, any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
+    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.
@@ -1481,10 +1124,9 @@ export class ObservableSanityClient {
    * @param options Mutation options
    */
   mutate<R extends Record<string, any> = Record<string, any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
+    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.
@@ -1493,10 +1135,9 @@ export class ObservableSanityClient {
    * @param options Mutation options
    */
   mutate<R extends Record<string, any> = Record<string, any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
+    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.
@@ -1505,10 +1146,9 @@ export class ObservableSanityClient {
    * @param options Mutation options
    */
   mutate<R extends Record<string, any> = Record<string, any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
+    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
     options?: BaseMutationOptions
   ): Observable<SanityDocument<R>>
-
   /**
    * Create a new buildable patch of operations to perform
    *
@@ -1516,7 +1156,6 @@ export class ObservableSanityClient {
    * @param operations Optional object of patch operations to initialize the patch instance with
    */
   patch(documentId: string | MutationSelection, operations?: PatchOperations): ObservablePatch
-
   /**
    * Create a new transaction of mutations
    *
@@ -1525,247 +1164,281 @@ export class ObservableSanityClient {
   transaction<R extends Record<string, any> = Record<string, any>>(
     operations?: Mutation<R>[]
   ): ObservableTransaction
-
-  // "Internals", should generally not be used externally
   /**
-   * DEPRECATED: Returns whether or not this client is using the Observable API (otherwise it is using observables)
+   * DEPRECATED: Perform an HTTP request against the Sanity API
    *
-   * @deprecated Should be an internal concern
+   * @deprecated Use your own request library!
+   * @param options Request options
    */
-  isObservableAPI(): boolean
+  request<R = any>(options: RawRequestOptions): Observable<R>
+}
 
+export declare class ObservableTransaction extends BaseTransaction {
+  #private
+  constructor(operations?: Mutation[], client?: ObservableSanityClient, transactionId?: string)
   /**
-   * DEPRECATED: Get a Sanity API URL for the URI provided
+   * Clones the transaction
+   */
+  clone(): ObservableTransaction
+  /**
+   * Commit the transaction, returning an observable that produces the first mutated document
    *
-   * @deprecated Should be an internal concern
-   * @param uri URI/path to build URL for
-   * @param canUseCdn Whether or not to allow using the API CDN for this route
+   * @param options - Options for the mutation operation
    */
-  getUrl(uri: string, canUseCdn?: boolean): string
-
+  commit<R extends Record<string, any>>(
+    options: TransactionFirstDocumentMutationOptions
+  ): Observable<SanityDocument<R>>
   /**
-   * DEPRECATED: Get a Sanity API URL for the data operation and path provided
+   * Commit the transaction, returning an observable that produces an array of the mutated documents
    *
-   * @deprecated Should be an internal concern
-   * @param operation Data operation
-   * @param path Path to append
+   * @param options - Options for the mutation operation
    */
-  getDataUrl(operation: string, path?: string): string
-
+  commit<R extends Record<string, any>>(
+    options: TransactionAllDocumentsMutationOptions
+  ): Observable<SanityDocument<R>[]>
   /**
-   * DEPRECATED: Perform an HTTP request against the Sanity API
+   * Commit the transaction, returning an observable that produces a mutation result object
    *
-   * @deprecated Use your own request library!
-   * @param options Request options
+   * @param options - Options for the mutation operation
    */
-  request<T = any>(options: RawRequestOptions): Observable<T>
+  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
 }
 
-export interface SanityClient {
-  // Client/configuration
-  constructor(config: ClientConfig): SanityClient
+export declare class ObservableUsersClient extends BaseUsersClient {
+  client: ObservableSanityClient
+  constructor(client: ObservableSanityClient)
+}
 
+export declare class Patch extends BasePatch {
+  #private
+  constructor(selection: PatchSelection, operations?: PatchOperations, client?: SanityClient)
   /**
-   * Clone the client - returns a new instance
+   * Clones the patch
    */
-  clone(): SanityClient
-
+  clone(): Patch
   /**
-   * Returns the current client configuration
+   * Commit the patch, returning a promise that resolves to the first patched document
+   *
+   * @param options Options for the mutation operation
    */
-  config(): ClientConfig
-
+  commit<R extends Record<string, any> = Record<string, any>>(
+    options: FirstDocumentMutationOptions
+  ): Promise<SanityDocument<R>>
   /**
-   * Reconfigure the client. Note that this _mutates_ the current client.
+   * Commit the patch, returning a promise that resolves to an array of the mutated documents
    *
-   * @param newConfig New client configuration properties
+   * @param options Options for the mutation operation
    */
-  config(newConfig?: Partial<ClientConfig>): this
-
+  commit<R extends Record<string, any> = Record<string, any>>(
+    options: AllDocumentsMutationOptions
+  ): Promise<SanityDocument<R>[]>
   /**
-   * Clone the client with a new (partial) configuration.
+   * Commit the patch, returning a promise that resolves to 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>): SanityClient
-
+  commit(options: FirstDocumentIdMutationOptions): Promise<SingleMutationResult>
   /**
-   * @deprecated Use `client.config()` instead
+   * Commit the patch, returning a promise that resolves to a mutation result object
+   *
+   * @param options Options for the mutation operation
    */
-  clientConfig: ClientConfig
-
+  commit(options: AllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
   /**
-   * Observable version of the Sanity client, with the same configuration as the promise-based one
+   * Commit the patch, returning a promise that resolves to the first patched document
+   *
+   * @param options Options for the mutation operation
    */
-  observable: ObservableSanityClient
+  commit<R extends Record<string, any> = Record<string, any>>(
+    options?: BaseMutationOptions
+  ): Promise<SanityDocument<R>>
+}
 
-  assets: {
-    /**
-     * Uploads a file 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: File | Blob | Buffer | NodeJS.ReadableStream,
-      options?: UploadOptions
-    ): Promise<SanityAssetDocument | SanityImageAssetDocument>
+export declare type PatchBuilder = (patch: Patch) => Patch
 
-    /**
-     * Uploads a file 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',
-      body: File | Blob | Buffer | NodeJS.ReadableStream,
-      options?: UploadOptions
-    ): Promise<SanityAssetDocument>
+export declare type PatchMutationOperation = PatchOperations & MutationSelection
 
-    /**
-     * Uploads 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: 'image',
-      body: File | Blob | Buffer | NodeJS.ReadableStream,
-      options?: UploadOptions
-    ): Promise<SanityImageAssetDocument>
+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
+}
 
-    /**
-     * DEPRECATED: Deletes an asset of the given type and ID
-     *
-     * @deprecated Use `client.delete(assetDocumentId)` instead
-     * @param assetType Asset type (file/image)
-     * @param id Document ID or asset document to delete
-     */
-    delete(
-      assetType: 'file' | 'image',
-      id: string | IdentifiedSanityDocumentStub
-    ): Promise<SanityAssetDocument | undefined>
+export declare type PatchSelection = string | string[] | MutationSelection
 
-    /**
-     * DEPRECATED: Returns the URL for an asset with a given document ID
-     *
-     * @deprecated Use the `@sanity/image-url` module instead
-     * @param id Document ID or asset reference to get URL for
-     * @param query Optional object of query string parameters to append
-     */
-    getImageUrl(id: string | SanityReference, query: {[key: string]: string | number}): string
-  }
+declare interface ProgressEvent_2 {
+  type: 'progress'
+  stage: 'upload' | 'download'
+  percent: number
+  total?: number
+  loaded?: number
+  lengthComputable: boolean
+}
+export {ProgressEvent_2 as ProgressEvent}
 
-  datasets: {
-    /**
-     * 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<{datasetName: string; aclMode: DatasetAclMode}>
+export declare class ProjectsClient extends BaseProjectsClient {
+  client: SanityClient
+  constructor(client: SanityClient)
+}
 
-    /**
-     * 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<{datasetName: string; aclMode: DatasetAclMode}>
+export declare type QueryParams = {
+  [key: string]: any
+}
 
-    /**
-     * Delete a dataset with the given name
-     *
-     * @param name Name of the dataset to delete
-     */
-    delete(name: string): Promise<{deleted: true}>
+export declare interface RawQueryResponse<R> {
+  q: string
+  ms: number
+  result: R
+}
 
-    /**
-     * Fetch a list of datasets for the configured project
-     */
-    list(): Promise<{name: string; aclMode: DatasetAclMode}[]>
+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
+}
 
-  projects: {
-    /**
-     * Fetch a list of projects the authenticated user has access to
-     */
-    list(): Promise<SanityProject[]>
+export declare type ReconnectEvent = {
+  type: 'reconnect'
+}
 
-    /**
-     * Fetch a project by project ID
-     *
-     * @param projectId ID of the project to fetch
-     */
-    getById(projectId: string): Promise<SanityProject>
-  }
+export declare const requester: Requester
 
-  users: {
-    /**
-     * 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
-    ): T extends 'me' ? Promise<CurrentSanityUser> : Promise<SanityUser>
-  }
+export declare interface RequestObservableOptions extends Omit<RequestOptions, 'url'> {
+  url?: string
+  uri?: string
+  canUseCdn?: boolean
+  tag?: string
+}
 
-  auth: {
-    /**
-     * Fetch available login providers
-     */
-    getLoginProviders(): Promise<{providers: AuthProvider[]}>
+export declare interface RequestOptions {
+  timeout?: number
+  token?: string
+  tag?: string
+  headers?: Record<string, string>
+  method?: string
+  query?: any
+  body?: any
+}
 
-    /**
-     * Revoke the configured session/token
-     */
-    logout(): Promise<any>
-  }
+export declare interface ResponseEvent<T = unknown> {
+  type: 'response'
+  body: T
+  url: string
+  method: string
+  statusCode: number
+  statusMessage?: string
+  headers: Record<string, string>
+}
+
+export declare interface SanityAssetDocument extends SanityDocument {
+  url: string
+  path: string
+  size: number
+  assetId: string
+  mimeType: string
+  sha1hash: string
+  extension: string
+  uploadId?: string
+  originalFilename?: string
+}
 
+export declare class SanityClient extends BaseSanityClient {
+  #private
+  assets: AssetsClient
+  auth: AuthClient
+  datasets: DatasetsClient
+  projects: ProjectsClient
+  users: UsersClient
   /**
-   * Set up a listener that will be notified when mutations occur on documents matching the provided query/filter.
-   *
-   * @param query GROQ-filter to listen to changes for
-   * @param params Optional query parameters
-   * @param options Listener options
+   * Observable version of the Sanity client, with the same configuration as the promise-based one
    */
-  listen<R extends Record<string, any> = Record<string, any>>(
-    query: string,
-    params?: QueryParams
-  ): Observable<MutationEvent<R>>
-
+  observable: ObservableSanityClient
+  /**
+   * Instance properties
+   */
+  listen: typeof _listen
+  constructor(httpRequest: HttpRequest, config: ClientConfig)
+  /**
+   * Clone the client - returns a new instance
+   */
+  clone(): SanityClient
   /**
-   * Set up a listener that will be notified when mutations occur on documents matching the provided query/filter.
+   * 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 query GROQ-filter to listen to changes for
-   * @param params Optional query parameters
-   * @param options Listener options
+   * @param newConfig New client configuration properties, shallowly merged with existing configuration
    */
-  listen<R extends Record<string, any> = Record<string, any>>(
-    query: string,
-    params?: QueryParams,
-    options?: ListenOptions
-  ): Observable<ListenEvent<R>>
-
+  withConfig(newConfig?: Partial<ClientConfig>): SanityClient
   /**
    * Perform a GROQ-query against the configured dataset.
    *
    * @param query GROQ-query to perform
    */
   fetch<R = any>(query: string): Promise<R>
-
   /**
    * Perform a GROQ-query against the configured dataset.
    *
@@ -1773,7 +1446,6 @@ export interface SanityClient {
    * @param params Optional query parameters
    */
   fetch<R = any>(query: string, params: QueryParams): Promise<R>
-
   /**
    * Perform a GROQ-query against the configured dataset.
    *
@@ -1786,7 +1458,6 @@ export interface SanityClient {
     params: QueryParams | undefined,
     options: FilteredResponseQueryOptions
   ): Promise<R>
-
   /**
    * Perform a GROQ-query against the configured dataset.
    *
@@ -1799,7 +1470,6 @@ export interface SanityClient {
     params: QueryParams | undefined,
     options: UnfilteredResponseQueryOptions
   ): Promise<RawQueryResponse<R>>
-
   /**
    * Fetch a single document with the given ID.
    *
@@ -1808,9 +1478,10 @@ export interface SanityClient {
    */
   getDocument<R extends Record<string, any> = Record<string, any>>(
     id: string,
-    options?: {tag?: string}
+    options?: {
+      tag?: string
+    }
   ): Promise<SanityDocument<R> | undefined>
-
   /**
    * Fetch multiple documents in one request.
    * Should be used sparingly - performing a query is usually a better option.
@@ -1822,9 +1493,10 @@ export interface SanityClient {
    */
   getDocuments<R extends Record<string, any> = Record<string, any>>(
     ids: string[],
-    options?: {tag?: string}
+    options?: {
+      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.
@@ -1836,7 +1508,6 @@ export interface SanityClient {
     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.
@@ -1848,7 +1519,6 @@ export interface SanityClient {
     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.
@@ -1860,7 +1530,6 @@ export interface SanityClient {
     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.
@@ -1872,7 +1541,6 @@ export interface SanityClient {
     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.
@@ -1884,7 +1552,6 @@ export interface SanityClient {
     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.
@@ -1896,7 +1563,6 @@ export interface SanityClient {
     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.
@@ -1908,7 +1574,6 @@ export interface SanityClient {
     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.
@@ -1920,7 +1585,6 @@ export interface SanityClient {
     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.
@@ -1932,7 +1596,6 @@ export interface SanityClient {
     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.
@@ -1944,7 +1607,6 @@ export interface SanityClient {
     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.
@@ -1956,7 +1618,6 @@ export interface SanityClient {
     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.
@@ -1968,7 +1629,6 @@ export interface SanityClient {
     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.
@@ -1980,7 +1640,6 @@ export interface SanityClient {
     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.
@@ -1992,7 +1651,6 @@ export interface SanityClient {
     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.
@@ -2004,7 +1662,6 @@ export interface SanityClient {
     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.
@@ -2016,7 +1673,6 @@ export interface SanityClient {
     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.
@@ -2028,7 +1684,6 @@ export interface SanityClient {
     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.
@@ -2037,7 +1692,6 @@ export interface SanityClient {
    * @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.
@@ -2046,7 +1700,6 @@ export interface SanityClient {
    * @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.
@@ -2058,7 +1711,6 @@ export interface SanityClient {
     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.
@@ -2070,7 +1722,6 @@ export interface SanityClient {
     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.
@@ -2082,7 +1733,6 @@ export interface SanityClient {
     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.
@@ -2094,7 +1744,6 @@ export interface SanityClient {
     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.
@@ -2106,7 +1755,6 @@ export interface SanityClient {
     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.
@@ -2118,7 +1766,6 @@ export interface SanityClient {
     selection: MutationSelection,
     options?: BaseMutationOptions
   ): Promise<SanityDocument<R>>
-
   /**
    * Perform mutation operations against the configured dataset
    * Returns a promise that resolves to the first mutated document.
@@ -2130,7 +1777,6 @@ export interface SanityClient {
     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.
@@ -2142,7 +1788,6 @@ export interface SanityClient {
     operations: Mutation<R>[] | Patch | Transaction,
     options: AllDocumentsMutationOptions
   ): Promise<SanityDocument<R>[]>
-
   /**
    * Perform mutation operations against the configured dataset
    * Returns a promise that resolves to a mutation result object containing the document ID of the first mutated document.
@@ -2154,7 +1799,6 @@ export interface SanityClient {
     operations: Mutation<R>[] | Patch | Transaction,
     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.
@@ -2166,7 +1810,6 @@ export interface SanityClient {
     operations: Mutation<R>[] | Patch | Transaction,
     options: AllDocumentIdsMutationOptions
   ): Promise<MultipleMutationResult>
-
   /**
    * Perform mutation operations against the configured dataset
    * Returns a promise that resolves to the first mutated document.
@@ -2178,7 +1821,6 @@ export interface SanityClient {
     operations: Mutation<R>[] | Patch | Transaction,
     options?: BaseMutationOptions
   ): Promise<SanityDocument<R>>
-
   /**
    * Create a new buildable patch of operations to perform
    *
@@ -2186,7 +1828,6 @@ export interface SanityClient {
    * @param operations Optional object of patch operations to initialize the patch instance with
    */
   patch(documentId: string | MutationSelection, operations?: PatchOperations): Patch
-
   /**
    * Create a new transaction of mutations
    *
@@ -2195,62 +1836,295 @@ export interface SanityClient {
   transaction<R extends Record<string, any> = Record<string, any>>(
     operations?: Mutation<R>[]
   ): Transaction
-
-  // "Internals", should generally not be used externally
   /**
-   * DEPRECATED: Returns whether or not this client is using the Promise API (otherwise it is using observables)
+   * DEPRECATED: Perform an HTTP request against the Sanity API
    *
-   * @deprecated Should be an internal concern
+   * @deprecated Use your own request library!
+   * @param options Request options
    */
-  isPromiseAPI(): boolean
-
+  request<R = any>(options: RawRequestOptions): Promise<R>
   /**
-   * DEPRECATED: Get a Sanity API URL for the URI provided
+   * DEPRECATED: Perform an HTTP request a `/data` sub-endpoint
    *
-   * @deprecated Should be an internal concern
-   * @param uri URI/path to build URL for
-   * @param canUseCdn Whether or not to allow using the API CDN for this route
+   * @deprecated Use your own request library!
+   * @param endpoint Endpoint to hit (mutate, query etc)
+   * @param body Request body
+   * @param options Request options
    */
-  getUrl(uri: string, canUseCdn?: boolean): string
+  dataRequest(endpoint: string, body: unknown, options?: BaseMutationOptions): Promise<any>
+}
+
+export declare type SanityDocument<T extends Record<string, any> = Record<string, any>> = {
+  [P in keyof T]: T[P]
+} & {
+  _id: string
+  _rev: string
+  _type: string
+  _createdAt: string
+  _updatedAt: string
+}
+
+export declare type SanityDocumentStub<T extends Record<string, any> = Record<string, any>> = {
+  [P in keyof T]: T[P]
+} & {
+  _type: string
+}
 
+export declare interface SanityImageAssetDocument extends SanityAssetDocument {
+  metadata: {
+    _type: 'sanity.imageMetadata'
+    hasAlpha: boolean
+    isOpaque: boolean
+    lqip?: string
+    blurHash?: string
+    dimensions: {
+      _type: 'sanity.imageDimensions'
+      aspectRatio: number
+      height: number
+      width: number
+    }
+    palette?: {
+      _type: 'sanity.imagePalette'
+      darkMuted?: SanityImagePalette
+      darkVibrant?: SanityImagePalette
+      dominant?: SanityImagePalette
+      lightMuted?: SanityImagePalette
+      lightVibrant?: SanityImagePalette
+      muted?: SanityImagePalette
+      vibrant?: SanityImagePalette
+    }
+    image?: {
+      _type: 'sanity.imageExifTags'
+      [key: string]: any
+    }
+    exif?: {
+      _type: 'sanity.imageExifMetadata'
+      [key: string]: any
+    }
+  }
+}
+
+export declare interface SanityImagePalette {
+  background: string
+  foreground: string
+  population: number
+  title: string
+}
+
+export declare interface SanityProject {
+  id: string
+  displayName: string
+  studioHost: string | null
+  organizationId: string | null
+  isBlocked: boolean
+  isDisabled: boolean
+  isDisabledByUser: boolean
+  createdAt: string
+  pendingInvites?: number
+  maxRetentionDays?: number
+  members: SanityProjectMember[]
+  metadata: {
+    color?: string
+    externalStudioHost?: string
+  }
+}
+
+export declare interface SanityProjectMember {
+  id: string
+  role: string
+  isRobot: boolean
+  isCurrentUser: boolean
+}
+
+export declare interface SanityReference {
+  _ref: string
+}
+
+export declare interface SanityUser {
+  id: string
+  projectId: string
+  displayName: string
+  familyName: string | null
+  givenName: string | null
+  middleName: string | null
+  imageUrl: string | null
+  createdAt: string
+  updatedAt: string
+  isCurrentUser: boolean
+}
+
+export declare class ServerError extends BaseError {
+  response: ErrorProps['response']
+  statusCode: ErrorProps['statusCode']
+  responseBody: ErrorProps['responseBody']
+  details: ErrorProps['details']
+  constructor(res: any)
+}
+
+export declare interface SingleMutationResult {
+  transactionId: string
+  documentId: string
+  results: {
+    id: string
+    operation: MutationOperation
+  }[]
+}
+
+export declare class Transaction extends BaseTransaction {
+  #private
+  constructor(operations?: Mutation[], client?: SanityClient, transactionId?: string)
   /**
-   * DEPRECATED: Get a Sanity API URL for the data operation and path provided
+   * Clones the transaction
+   */
+  clone(): Transaction
+  /**
+   * Commit the transaction, returning a promise that resolves to the first mutated document
    *
-   * @deprecated Should be an internal concern
-   * @param operation Data operation
-   * @param path Path to append
+   * @param options - Options for the mutation operation
    */
-  getDataUrl(operation: string, path?: string): string
-
+  commit<R extends Record<string, any>>(
+    options: TransactionFirstDocumentMutationOptions
+  ): Promise<SanityDocument<R>>
   /**
-   * DEPRECATED: Perform an HTTP request against the Sanity API
+   * Commit the transaction, returning a promise that resolves to an array of the mutated documents
    *
-   * @deprecated Use your own request library!
-   * @param options Request options
+   * @param options - Options for the mutation operation
    */
-  request<T = any>(options: RawRequestOptions): Promise<T>
-
+  commit<R extends Record<string, any>>(
+    options: TransactionAllDocumentsMutationOptions
+  ): Promise<SanityDocument<R>[]>
   /**
-   * DEPRECATED: Perform an HTTP request a `/data` sub-endpoint
+   * Commit the transaction, returning a promise that resolves to a mutation result object
    *
-   * @deprecated Use your own request library!
-   * @param endpoint Endpoint to hit (mutate, query etc)
-   * @param body Request body
-   * @param options Request options
+   * @param options - Options for the mutation operation
    */
-  dataRequest(endpoint: string, body: unknown, options?: BaseMutationOptions): Promise<any>
+  commit(options: TransactionFirstDocumentIdMutationOptions): Promise<SingleMutationResult>
+  /**
+   * Commit the transaction, returning a promise that resolves to a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: TransactionAllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
+  /**
+   * Commit the transaction, returning a promise that resolves to a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options?: BaseMutationOptions): Promise<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?: PatchBuilder | 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 - Patch to execute
+   */
+  patch(patch: Patch): this
+}
+
+export declare type TransactionAllDocumentIdsMutationOptions = BaseMutationOptions & {
+  returnFirst?: false
+  returnDocuments?: false
+}
+
+export declare type TransactionAllDocumentsMutationOptions = BaseMutationOptions & {
+  returnFirst?: false
+  returnDocuments: true
+}
+
+export declare type TransactionFirstDocumentIdMutationOptions = BaseMutationOptions & {
+  returnFirst: true
+  returnDocuments?: false
+}
+
+export declare type TransactionFirstDocumentMutationOptions = BaseMutationOptions & {
+  returnFirst: true
+  returnDocuments: true
+}
+
+export declare type TransactionMutationOptions =
+  | TransactionFirstDocumentMutationOptions
+  | TransactionFirstDocumentIdMutationOptions
+  | TransactionAllDocumentsMutationOptions
+  | TransactionAllDocumentIdsMutationOptions
+
+export declare type UnfilteredResponseQueryOptions = RequestOptions & {
+  filterResponse: false
+}
+
+export declare interface UploadClientConfig {
+  /**
+   * Optional request tag for the upload
+   */
+  tag?: string
+  /**
+   * Whether or not to preserve the original filename (default: true)
+   */
+  preserveFilename?: boolean
+  /**
+   * Filename for this file (optional)
+   */
+  filename?: string
+  /**
+   * Milliseconds to wait before timing the request out
+   */
+  timeout?: number
+  /**
+   * Mime type of the file
+   */
+  contentType?: string
+  /**
+   * Array of metadata parts to extract from asset
+   */
+  extract?: AssetMetadataType[]
+  /**
+   * Optional freeform label for the asset. Generally not used.
+   */
+  label?: string
+  /**
+   * Optional title for the asset
+   */
+  title?: string
+  /**
+   * Optional description for the asset
+   */
+  description?: string
+  /**
+   * The credit to person(s) and/or organization(s) required by the supplier of the asset to be used when published
+   */
+  creditLine?: string
+  /**
+   * Source data (when the asset is from an external service)
+   */
+  source?: {
+    /**
+     * The (u)id of the asset within the source, i.e. 'i-f323r1E'
+     */
+    id: string
+    /**
+     * The name of the source, i.e. 'unsplash'
+     */
+    name: string
+    /**
+     * A url to where to find the asset, or get more info about it in the source
+     */
+    url?: string
+  }
 }
 
-export interface ClientConstructor {
-  Patch: typeof Patch
-  Transaction: typeof Transaction
-  ClientError: typeof ClientError
-  ServerError: typeof ServerError
-  requester: GetItRequester
+export declare class UsersClient extends BaseUsersClient {
+  client: SanityClient
+  constructor(client: SanityClient)
+}
 
-  new (config: ClientConfig): SanityClient
-  (config: ClientConfig): SanityClient
+export declare type WelcomeEvent = {
+  type: 'welcome'
 }
 
-declare const SanityClientConstructor: ClientConstructor
-export default SanityClientConstructor
+export {}