@sanity/client 6.11.3 → 6.11.4-canary.1

package/dist/stega.d.ts

@@ -42,8 +42,9 @@ export declare type AssetMetadataType =
 
 /** @internal */
 export declare class AssetsClient {
-  #private
-  constructor(client: INTERNAL_DO_NOT_USE_DIRECTLY_SanityClient, httpRequest: HttpRequest)
+  private [clientSymbol]
+  private [httpRequestSymbol]
+  constructor(client: SanityClient, httpRequest: HttpRequest)
   /**
    * Uploads a file asset to the configured dataset
    *
@@ -325,8 +326,14 @@ export declare interface ClientConfig {
    *@deprecated set `cache` and `next` options on `client.fetch` instead
    */
   fetch?: RequestFetchOptions | boolean
+  /**
+   * Options for how, if enabled, Content Source Maps are encoded into query results using steganography
+   */
+  stega?: StegaConfig | boolean
 }
 
+declare const clientConfigSymbol: unique symbol
+
 /** @public */
 export declare class ClientError extends Error {
   response: ErrorProps['response']
@@ -339,10 +346,23 @@ export declare class ClientError extends Error {
 /** @public */
 export declare type ClientPerspective = 'previewDrafts' | 'published' | 'raw'
 
-/** @public */
-export declare interface ClientStegaConfig extends ClientConfig {
-  stega?: StegaConfig | boolean
-}
+/**
+ * @public
+ * @deprecated -- use `ClientConfig` instead
+ */
+export declare interface ClientStegaConfig extends ClientConfig {}
+
+declare const clientSymbol: unique symbol
+
+declare const clientSymbol_2: unique symbol
+
+declare const clientSymbol_3: unique symbol
+
+declare const clientSymbol_4: unique symbol
+
+declare const clientSymbol_5: unique symbol
+
+declare const clientSymbol_6: unique symbol
 
 /** @public */
 export declare interface ContentSourceMap {
@@ -445,7 +465,7 @@ export declare interface ContentSourceMapValueMapping {
 }
 
 /** @public */
-export declare const createClient: (config: ClientStegaConfig) => SanityStegaClient
+export declare const createClient: (config: ClientConfig) => SanityClient
 
 /** @internal */
 export declare interface CurrentSanityUser {
@@ -467,8 +487,9 @@ export declare type DatasetResponse = {
 
 /** @internal */
 export declare class DatasetsClient {
-  #private
-  constructor(client: INTERNAL_DO_NOT_USE_DIRECTLY_SanityClient, httpRequest: HttpRequest)
+  private [clientSymbol_2]
+  private [httpRequestSymbol_2]
+  constructor(client: SanityClient, httpRequest: HttpRequest)
   /**
    * Create a new dataset with the given name
    *
@@ -605,7 +626,7 @@ export declare type FilterDefault = (props: {
 }) => boolean
 
 /** @public */
-export declare type FilteredResponseQueryOptions = ResponseQueryOptions & {
+export declare interface FilteredResponseQueryOptions extends ResponseQueryOptions {
   filterResponse?: true
 }
 
@@ -630,6 +651,16 @@ export declare type HttpRequest = {
 /** @public */
 export declare type HttpRequestEvent<T = unknown> = ResponseEvent<T> | ProgressEvent_2
 
+declare const httpRequestSymbol: unique symbol
+
+declare const httpRequestSymbol_2: unique symbol
+
+declare const httpRequestSymbol_3: unique symbol
+
+declare const httpRequestSymbol_4: unique symbol
+
+declare const httpRequestSymbol_5: unique symbol
+
 /** @public */
 export declare type IdentifiedSanityDocumentStub<
   T extends Record<string, Any> = Record<string, Any>,
@@ -657,13 +688,18 @@ export declare interface InitializedClientConfig extends ClientConfig {
    * @deprecated Internal, don't use
    */
   cdnUrl: string
-}
-
-/** @public */
-export declare interface InitializedClientStegaConfig extends InitializedClientConfig {
+  /**
+   * The fully initialized stega config, can be used to check if stega is enabled
+   */
   stega: InitializedStegaConfig
 }
 
+/**
+ * @public
+ * @deprecated -- use `InitializedClientConfig` instead
+ */
+export declare interface InitializedClientStegaConfig extends InitializedClientConfig {}
+
 /** @public */
 export declare type InitializedStegaConfig = Omit<StegaConfig, StegaConfigRequiredKeys> &
   Required<Pick<StegaConfig, StegaConfigRequiredKeys>>
@@ -683,1778 +719,1809 @@ export declare type InsertPatch =
       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 - Optional listener options
+ * @public
+ */
+export declare function _listen<R extends Record<string, Any> = Record<string, Any>>(
+  this: SanityClient | ObservableSanityClient,
+  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 - Optional listener options
+ * @public
+ */
+export declare function _listen<R extends Record<string, Any> = Record<string, Any>>(
+  this: SanityClient | ObservableSanityClient,
+  query: string,
+  params?: QueryParams,
+  options?: ListenOptions,
+): Observable<ListenEvent<R>>
+
 /** @public */
-export declare class INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient {
-  #private
-  assets: ObservableAssetsClient
-  datasets: ObservableDatasetsClient
-  projects: ObservableProjectsClient
-  users: ObservableUsersClient
-  /**
-   * Instance properties
-   */
-  listen: typeof _listen
-  constructor(httpRequest: HttpRequest, config?: ClientConfig)
+export declare type ListenEvent<R extends Record<string, Any>> =
+  | MutationEvent_2<R>
+  | ChannelErrorEvent
+  | DisconnectEvent
+  | ReconnectEvent
+  | WelcomeEvent
+
+/** @public */
+export declare type ListenEventName =
+  /** A mutation was performed */
+  | 'mutation'
+  /** The listener has been (re)established */
+  | 'welcome'
+  /** The listener has been disconnected, and a reconnect attempt is scheduled */
+  | 'reconnect'
+
+/** @public */
+export declare interface ListenOptions {
   /**
-   * Clone the client - returns a new instance
+   * Whether or not to include the resulting document in addition to the mutations performed.
+   * If you do not need the actual document, set this to `false` to reduce bandwidth usage.
+   * The result will be available on the `.result` property of the events.
+   * @defaultValue `true`
    */
-  clone(): INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient
+  includeResult?: boolean
   /**
-   * Returns the current client configuration
+   * Whether or not to include the document as it looked before the mutation event.
+   * The previous revision will be available on the `.previous` property of the events,
+   * and may be `null` in the case of a new document.
+   * @defaultValue `false`
    */
-  config(): InitializedClientConfig
+  includePreviousRevision?: boolean
   /**
-   * Reconfigure the client. Note that this _mutates_ the current client.
+   * Whether events should be sent as soon as a transaction has been committed (`transaction`, default),
+   * or only after they are available for queries (query). Note that this is on a best-effort basis,
+   * and listeners with `query` may in certain cases (notably with deferred transactions) receive events
+   * that are not yet visible to queries.
+   *
+   * @defaultValue `'transaction'`
    */
-  config(newConfig?: Partial<ClientConfig>): this
+  visibility?: 'transaction' | 'query'
   /**
-   * Clone the client with a new (partial) configuration.
+   * Array of event names to include in the observable. By default, only mutation events are included.
    *
-   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
+   * @defaultValue `['mutation']`
    */
-  withConfig(newConfig?: Partial<ClientConfig>): INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient
+  events?: ListenEventName[]
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Format of "effects", eg the resulting changes of a mutation.
+   * Currently only `mendoza` is supported, and (if set) will include `apply` and `revert` arrays
+   * in the mutation events under the `effects` property.
    *
-   * @param query - GROQ-query to perform
+   * See {@link https://github.com/sanity-io/mendoza | The mendoza docs} for more info
+   *
+   * @defaultValue `undefined`
    */
-  fetch<R = Any>(query: string): Observable<R>
+  effectFormat?: 'mendoza'
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Optional request tag for the listener. Use to identify the request in logs.
    *
-   * @param query - GROQ-query to perform
-   * @param params - Query parameters
+   * @defaultValue `undefined`
    */
-  fetch<R = Any, Q = QueryParams>(query: string, params: Q): Observable<R>
+  tag?: string
+}
+
+/** @public */
+export declare type Logger =
+  | typeof console
+  | Partial<
+      Pick<typeof console, 'debug' | 'error' | 'groupCollapsed' | 'groupEnd' | 'log' | 'table'>
+    >
+
+/** @internal */
+export declare interface MultipleMutationResult {
+  transactionId: string
+  documentIds: string[]
+  results: {
+    id: string
+    operation: MutationOperation
+  }[]
+}
+
+/** @public */
+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
+    }
+
+/** @internal */
+export declare interface MutationError {
+  error: {
+    type: 'mutationError'
+    description: string
+    items?: MutationErrorItem[]
+  }
+}
+
+/** @internal */
+export declare interface MutationErrorItem {
+  error: {
+    type: string
+    description: string
+    value?: unknown
+  }
+}
+
+/**
+ * A mutation was performed. Note that when updating multiple documents in a transaction,
+ * each document affected will get a separate mutation event.
+ *
+ * @public
+ */
+declare type MutationEvent_2<R extends Record<string, Any> = Record<string, Any>> = {
+  type: 'mutation'
   /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Query parameters
-   * @param options - Request options
+   * The ID of the document that was affected
    */
-  fetch<R = Any, Q = QueryParams>(
-    query: string,
-    params: Q | undefined,
-    options: FilteredResponseQueryOptions,
-  ): Observable<R>
+  documentId: string
   /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Query parameters
-   * @param options - Request options
+   * A unique ID for this event
    */
-  fetch<R = Any, Q = QueryParams>(
-    query: string,
-    params: Q | undefined,
-    options: UnfilteredResponseQueryOptions,
-  ): Observable<RawQueryResponse<R>>
+  eventId: string
   /**
-   * Fetch a single document with the given ID.
-   *
-   * @param id - Document ID to fetch
-   * @param options - Request options
+   * The user ID of the user that performed the mutation
    */
-  getDocument<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options?: {
-      tag?: string
-    },
-  ): Observable<SanityDocument<R> | undefined>
+  identity: string
   /**
-   * Fetch multiple documents in one request.
-   * Should be used sparingly - performing a query is usually a better option.
-   * The order/position of documents is preserved based on the original array of IDs.
-   * If any of the documents are missing, they will be replaced by a `null` entry in the returned array
-   *
-   * @param ids - Document IDs to fetch
-   * @param options - Request options
+   * An array of mutations that were performed. Note that this can differ slightly from the
+   * mutations sent to the server, as the server may perform some mutations automatically.
    */
-  getDocuments<R extends Record<string, Any> = Record<string, Any>>(
-    ids: string[],
-    options?: {
-      tag?: string
-    },
-  ): Observable<(SanityDocument<R> | null)[]>
+  mutations: Mutation[]
   /**
-   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
-   * Returns an observable that resolves to the created document.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * The revision ID of the document before the mutation was performed
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options: FirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
+  previousRev?: string
   /**
-   * 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.
-   *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * The revision ID of the document after the mutation was performed
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options: AllDocumentsMutationOptions,
-  ): Observable<SanityDocument<R>[]>
+  resultRev?: string
   /**
-   * 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.
+   * The document as it looked after the mutation was performed. This is only included if
+   * the listener was configured with `includeResult: true`.
+   */
+  result?: SanityDocument<R>
+  /**
+   * The document as it looked before the mutation was performed. This is only included if
+   * the listener was configured with `includePreviousRevision: true`.
+   */
+  previous?: SanityDocument<R> | null
+  /**
+   * The effects of the mutation, if the listener was configured with `effectFormat: 'mendoza'`.
+   * Object with `apply` and `revert` arrays, see {@link https://github.com/sanity-io/mendoza}.
+   */
+  effects?: {
+    apply: unknown[]
+    revert: unknown[]
+  }
+  /**
+   * A timestamp for when the mutation was performed
+   */
+  timestamp: string
+  /**
+   * The transaction ID for the mutation
+   */
+  transactionId: string
+  /**
+   * The type of transition the document went through.
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * - `update` means the document was previously part of the subscribed set of documents,
+   *   and still is.
+   * - `appear` means the document was not previously part of the subscribed set of documents,
+   *   but is now. This can happen both on create or if updating to a state where it now matches
+   *   the filter provided to the listener.
+   * - `disappear` means the document was previously part of the subscribed set of documents,
+   *   but is no longer. This can happen both on delete or if updating to a state where it no
+   *   longer matches the filter provided to the listener.
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options: FirstDocumentIdMutationOptions,
-  ): Observable<SingleMutationResult>
+  transition: 'update' | 'appear' | 'disappear'
   /**
-   * 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.
+   * Whether the change that triggered this event is visible to queries (query) or only to
+   * subsequent transactions (transaction). The listener client can specify a preferred visibility
+   * through the `visibility` parameter on the listener, but this is only on a best-effort basis,
+   * and may yet not be accurate.
+   */
+  visibility: 'query' | 'transaction'
+  /**
+   * The total number of events that will be sent for this transaction.
+   * Note that this may differ from the amount of _documents_ affected by the transaction, as this
+   * number only includes the documents that matches the given filter.
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * This can be useful if you need to perform changes to all matched documents atomically,
+   * eg you would wait for `transactionTotalEvents` events with the same `transactionId` before
+   * applying the changes locally.
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options: AllDocumentIdsMutationOptions,
-  ): Observable<MultipleMutationResult>
+  transactionTotalEvents: number
   /**
-   * 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.
+   * The index of this event within the transaction. Note that events may be delivered out of order,
+   * and that the index is zero-based.
+   */
+  transactionCurrentEvent: number
+}
+export {MutationEvent_2 as MutationEvent}
+
+/** @internal */
+export declare type MutationOperation = 'create' | 'delete' | 'update' | 'none'
+
+/** @internal */
+export declare type MutationSelection =
+  | {
+      query: string
+      params?: QueryParams
+    }
+  | {
+      id: string | string[]
+    }
+
+/** @internal */
+export declare class ObservableAssetsClient {
+  private [clientSymbol]
+  private [httpRequestSymbol]
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
+  /**
+   * Uploads a file asset to the configured dataset
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param assetType - Asset type (file)
+   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
+   * @param options - Options to use for the upload
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
-    options?: BaseMutationOptions,
-  ): Observable<SanityDocument<R>>
+  upload(
+    assetType: 'file',
+    body: UploadBody,
+    options?: UploadClientConfig,
+  ): Observable<
+    HttpRequestEvent<{
+      document: SanityAssetDocument
+    }>
+  >
   /**
-   * Create a document if no document with the same ID already exists.
-   * Returns an observable that resolves to the created document.
+   * Uploads an image asset to the configured dataset
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param assetType - Asset type (image)
+   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
+   * @param options - Options to use for the upload
    */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
+  upload(
+    assetType: 'image',
+    body: UploadBody,
+    options?: UploadClientConfig,
+  ): Observable<
+    HttpRequestEvent<{
+      document: SanityImageAssetDocument
+    }>
+  >
   /**
-   * Create a document if no document with the same ID already exists.
-   * Returns an observable that resolves to an array containing the created document.
+   * Uploads a file or an image asset to the configured dataset
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @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
    */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentsMutationOptions,
-  ): Observable<SanityDocument<R>[]>
+  upload(
+    assetType: 'file' | 'image',
+    body: UploadBody,
+    options?: UploadClientConfig,
+  ): Observable<
+    HttpRequestEvent<{
+      document: SanityAssetDocument | SanityImageAssetDocument
+    }>
+  >
+}
+
+/** @internal */
+export declare class ObservableDatasetsClient {
+  private [clientSymbol_2]
+  private [httpRequestSymbol_2]
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
   /**
-   * 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.
+   * Create a new dataset with the given name
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param name - Name of the dataset to create
+   * @param options - Options for the dataset
    */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentIdMutationOptions,
-  ): Observable<SingleMutationResult>
+  create(
+    name: string,
+    options?: {
+      aclMode?: DatasetAclMode
+    },
+  ): Observable<DatasetResponse>
   /**
-   * 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.
+   * Edit a dataset with the given name
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param name - Name of the dataset to edit
+   * @param options - New options for the dataset
    */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentIdsMutationOptions,
-  ): Observable<MultipleMutationResult>
+  edit(
+    name: string,
+    options?: {
+      aclMode?: DatasetAclMode
+    },
+  ): Observable<DatasetResponse>
   /**
-   * Create a document if no document with the same ID already exists.
-   * Returns an observable that resolves to the created document.
+   * Delete a dataset with the given name
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param name - Name of the dataset to delete
    */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options?: BaseMutationOptions,
-  ): Observable<SanityDocument<R>>
+  delete(name: string): Observable<{
+    deleted: true
+  }>
   /**
-   * 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.
+   * Fetch a list of datasets for the configured project
+   */
+  list(): Observable<DatasetsResponse>
+}
+
+/** @public */
+export declare class ObservablePatch extends BasePatch {
+  private [clientSymbol_5]?
+  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 document - Document to either create or replace
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
+  commit<R extends Record<string, Any> = Record<string, Any>>(
     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.
+   * Commit the patch, returning an observable that produces an array of the mutated documents
    *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
+  commit<R extends Record<string, Any> = Record<string, Any>>(
     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.
+   * Commit the patch, returning an observable that produces a mutation result object
    *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentIdMutationOptions,
-  ): Observable<SingleMutationResult>
+  commit(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.
+   * Commit the patch, returning an observable that produces a mutation result object
    *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentIdsMutationOptions,
-  ): Observable<MultipleMutationResult>
+  commit(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.
+   * Commit the patch, returning an observable that produces the first patched document
    *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
+  commit<R extends Record<string, Any> = Record<string, Any>>(
     options?: BaseMutationOptions,
   ): Observable<SanityDocument<R>>
+}
+
+/** @public */
+export declare type ObservablePatchBuilder = (patch: ObservablePatch) => ObservablePatch
+
+/** @internal */
+export declare class ObservableProjectsClient {
+  private [clientSymbol_3]
+  private [httpRequestSymbol_3]
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
   /**
-   * Deletes a document with the given document ID.
-   * Returns an observable that resolves to the deleted document.
+   * Fetch a list of projects the authenticated user has access to.
    *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * @param options - Options for the list request
+   * @param options.includeMembers - Whether to include members in the response (default: true)
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options: FirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
+  list(options?: {includeMembers?: true}): Observable<SanityProject[]>
+  list(options?: {includeMembers?: false}): Observable<Omit<SanityProject, 'members'>[]>
   /**
-   * Deletes a document with the given document ID.
-   * Returns an observable that resolves to an array containing the deleted document.
+   * Fetch a project by project ID
    *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * @param projectId - ID of the project to fetch
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options: AllDocumentsMutationOptions,
-  ): Observable<SanityDocument<R>[]>
+  getById(projectId: string): Observable<SanityProject>
+}
+
+/** @public */
+export declare class ObservableSanityClient {
+  assets: ObservableAssetsClient
+  datasets: ObservableDatasetsClient
+  projects: ObservableProjectsClient
+  users: ObservableUsersClient
   /**
-   * Deletes a document with the given document ID.
-   * Returns an observable that resolves to a mutation result object containing the deleted document ID.
+   * Private properties
+   */
+  private [clientConfigSymbol]
+  private [httpRequestSymbol_5]
+  /**
+   * Instance properties
+   */
+  listen: typeof _listen
+  constructor(httpRequest: HttpRequest, config?: ClientConfig)
+  /**
+   * Clone the client - returns a new instance
+   */
+  clone(): ObservableSanityClient
+  /**
+   * Returns the current client configuration
+   */
+  config(): InitializedClientConfig
+  /**
+   * Reconfigure the client. Note that this _mutates_ the current client.
+   */
+  config(newConfig?: Partial<ClientConfig>): this
+  /**
+   * Clone the client with a new (partial) configuration.
    *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
    */
-  delete(id: string, options: FirstDocumentIdMutationOptions): Observable<SingleMutationResult>
+  withConfig(newConfig?: Partial<ClientConfig>): ObservableSanityClient
   /**
-   * Deletes a document with the given document ID.
-   * Returns an observable that resolves to a mutation result object containing the deleted document ID.
+   * Perform a GROQ-query against the configured dataset.
    *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * @param query - GROQ-query to perform
    */
-  delete(id: string, options: AllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
+  fetch<R = Any, Q extends never | undefined | Record<string, never> = never>(
+    query: string,
+  ): Observable<R>
   /**
-   * Deletes a document with the given document ID.
-   * Returns an observable that resolves to the deleted document.
+   * Perform a GROQ-query against the configured dataset.
    *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * @param query - GROQ-query to perform
+   * @param params - Optional query parameters
+   * @param options - Optional request options
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
+  fetch<R = Any, Q = QueryParamsWithoutQueryOptions>(
+    query: string,
+    params: QueryParamsParameter<Q>,
+    options?: FilteredResponseQueryOptions,
+  ): Observable<R>
+  /**
+   * Perform a GROQ-query against the configured dataset.
+   *
+   * @param query - GROQ-query to perform
+   * @param params - Optional query parameters
+   * @param options - Request options
+   */
+  fetch<R = Any, Q = QueryParamsWithoutQueryOptions>(
+    query: string,
+    params: QueryParamsParameter<Q>,
+    options: UnfilteredResponseQueryOptions,
+  ): Observable<RawQueryResponse<R>>
+  /**
+   * You're passing in query parameters to a GROQ query that looks like query options.
+   * This is likely a mistake, you can either:
+   * a) replace the second argument with an empty object, and move the options to the third argument
+   * ```diff
+   * -client.fetch(query, {cache: 'no-store'})
+   * +client.fetch(query, {}, {cache: 'no-store'})
+   * ```
+   * b) add a generic type parameter that allows the query parameters to be passed in to silence the error
+   * @deprecated not actually deprecated, marking it as deprecated makes this error easier to spot
+   */
+  fetch<R = Any>(
+    query: string,
+    params: QueryParamsLikelyByMistake & QueryParams,
+    options?: QueryOptions,
+  ): unknown
+  /**
+   * Fetch a single document with the given ID.
+   *
+   * @param id - Document ID to fetch
+   * @param options - Request options
+   */
+  getDocument<R extends Record<string, Any> = Record<string, Any>>(
     id: string,
-    options?: BaseMutationOptions,
-  ): Observable<SanityDocument<R>>
+    options?: {
+      tag?: string
+    },
+  ): Observable<SanityDocument<R> | undefined>
   /**
-   * Deletes one or more documents matching the given query or document ID.
-   * Returns an observable that resolves to first deleted document.
+   * Fetch multiple documents in one request.
+   * Should be used sparingly - performing a query is usually a better option.
+   * The order/position of documents is preserved based on the original array of IDs.
+   * If any of the documents are missing, they will be replaced by a `null` entry in the returned array
    *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * @param ids - Document IDs to fetch
+   * @param options - Request options
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
+  getDocuments<R extends Record<string, Any> = Record<string, Any>>(
+    ids: 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.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
     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.
+   * 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.
    *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * @param document - Document to create
+   * @param options - Mutation options
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
     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.
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
    *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * @param document - Document to create
+   * @param options - Mutation options
    */
-  delete(
-    selection: MutationSelection,
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
     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.
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
    *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * @param document - Document to create
+   * @param options - Mutation options
    */
-  delete(
-    selection: MutationSelection,
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
     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.
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns an observable that resolves to the created document.
    *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * @param document - Document to create
+   * @param options - Mutation options
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
     options?: BaseMutationOptions,
   ): Observable<SanityDocument<R>>
   /**
-   * Perform mutation operations against the configured dataset
-   * Returns an observable that resolves to the first mutated document.
+   * Create a document if no document with the same ID already exists.
+   * Returns an observable that resolves to the created document.
    *
-   * @param operations - Mutation operations to execute
+   * @param document - Document to create
    * @param options - Mutation options
    */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
     options: FirstDocumentMutationOptions,
   ): Observable<SanityDocument<R>>
   /**
-   * Perform mutation operations against the configured dataset.
-   * Returns an observable that resolves to an array of the mutated documents.
+   * Create a document if no document with the same ID already exists.
+   * Returns an observable that resolves to an array containing the created document.
    *
-   * @param operations - Mutation operations to execute
+   * @param document - Document to create
    * @param options - Mutation options
    */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
     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.
+   * Create a document if no document with the same ID already exists.
+   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
    *
-   * @param operations - Mutation operations to execute
+   * @param document - Document to create
    * @param options - Mutation options
    */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
     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.
+   * Create a document if no document with the same ID already exists.
+   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
    *
-   * @param operations - Mutation operations to execute
+   * @param document - Document to create
    * @param options - Mutation options
    */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
     options: AllDocumentIdsMutationOptions,
   ): Observable<MultipleMutationResult>
   /**
-   * Perform mutation operations against the configured dataset
-   * Returns an observable that resolves to the first mutated document.
+   * Create a document if no document with the same ID already exists.
+   * Returns an observable that resolves to the created document.
    *
-   * @param operations - Mutation operations to execute
+   * @param document - Document to create
    * @param options - Mutation options
    */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
     options?: BaseMutationOptions,
   ): Observable<SanityDocument<R>>
   /**
-   * Create a new buildable patch of operations to perform
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns an observable that resolves to the created document.
    *
-   * @param documentId - Document ID to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
    */
-  patch(documentId: string, operations?: PatchOperations): ObservablePatch
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentMutationOptions,
+  ): Observable<SanityDocument<R>>
   /**
-   * Create a new buildable patch of operations to perform
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns an observable that resolves to an array containing the created document.
    *
-   * @param documentIds - Array of document IDs to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
    */
-  patch(documentIds: string[], operations?: PatchOperations): ObservablePatch
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentsMutationOptions,
+  ): Observable<SanityDocument<R>[]>
   /**
-   * Create a new buildable patch of operations to perform
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
    *
-   * @param selection - An object with `query` and optional `params`, defining which document(s) to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
    */
-  patch(selection: MutationSelection, operations?: PatchOperations): ObservablePatch
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentIdMutationOptions,
+  ): Observable<SingleMutationResult>
   /**
-   * Create a new transaction of mutations
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns an observable that resolves to a mutation result object containing the created document ID.
    *
-   * @param operations - Optional array of mutation operations to initialize the transaction instance with
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
    */
-  transaction<R extends Record<string, Any> = Record<string, Any>>(
-    operations?: Mutation<R>[],
-  ): ObservableTransaction
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentIdsMutationOptions,
+  ): Observable<MultipleMutationResult>
   /**
-   * Perform an HTTP request against the Sanity API
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns an observable that resolves to the created document.
    *
-   * @param options - Request options
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
    */
-  request<R = Any>(options: RawRequestOptions): Observable<R>
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options?: BaseMutationOptions,
+  ): Observable<SanityDocument<R>>
   /**
-   * Get a Sanity API URL for the URI provided
+   * Deletes a document with the given document ID.
+   * Returns an observable that resolves to the deleted document.
    *
-   * @param uri - URI/path to build URL for
-   * @param canUseCdn - Whether or not to allow using the API CDN for this route
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
    */
-  getUrl(uri: string, canUseCdn?: boolean): string
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options: FirstDocumentMutationOptions,
+  ): Observable<SanityDocument<R>>
   /**
-   * Get a Sanity API URL for the data operation and path provided
+   * Deletes a document with the given document ID.
+   * Returns an observable that resolves to an array containing the deleted document.
    *
-   * @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
-   * @param path - Path to append after the operation
-   */
-  getDataUrl(operation: string, path?: string): string
-}
-
-/** @public */
-export declare class INTERNAL_DO_NOT_USE_DIRECTLY_SanityClient {
-  #private
-  assets: AssetsClient
-  datasets: DatasetsClient
-  projects: ProjectsClient
-  users: UsersClient
-  /**
-   * Observable version of the Sanity client, with the same configuration as the promise-based one
-   */
-  observable: INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient
-  /**
-   * Instance properties
-   */
-  listen: typeof _listen
-  constructor(httpRequest: HttpRequest, config?: ClientConfig)
-  /**
-   * Clone the client - returns a new instance
-   */
-  clone(): INTERNAL_DO_NOT_USE_DIRECTLY_SanityClient
-  /**
-   * Returns the current client configuration
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
    */
-  config(): InitializedClientConfig
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options: AllDocumentsMutationOptions,
+  ): Observable<SanityDocument<R>[]>
   /**
-   * Reconfigure the client. Note that this _mutates_ the current client.
+   * Deletes a document with the given document ID.
+   * Returns an observable that resolves to a mutation result object containing the deleted document ID.
+   *
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
    */
-  config(newConfig?: Partial<ClientConfig>): this
+  delete(id: string, options: FirstDocumentIdMutationOptions): Observable<SingleMutationResult>
   /**
-   * Clone the client with a new (partial) configuration.
+   * Deletes a document with the given document ID.
+   * Returns an observable that resolves to a mutation result object containing the deleted document ID.
    *
-   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
    */
-  withConfig(newConfig?: Partial<ClientConfig>): INTERNAL_DO_NOT_USE_DIRECTLY_SanityClient
+  delete(id: string, options: AllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Deletes a document with the given document ID.
+   * Returns an observable that resolves to the deleted document.
    *
-   * @param query - GROQ-query to perform
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
    */
-  fetch<R = Any>(query: string): Promise<R>
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options?: BaseMutationOptions,
+  ): Observable<SanityDocument<R>>
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns an observable that resolves to first deleted document.
    *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
    */
-  fetch<R = Any, Q = QueryParams>(query: string, params: Q): Promise<R>
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    selection: MutationSelection,
+    options: FirstDocumentMutationOptions,
+  ): Observable<SanityDocument<R>>
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns an observable that resolves to an array containing the deleted documents.
    *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Request options
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
    */
-  fetch<R = Any, Q = QueryParams>(
-    query: string,
-    params: Q | undefined,
-    options: FilteredResponseQueryOptions,
-  ): Promise<R>
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    selection: MutationSelection,
+    options: AllDocumentsMutationOptions,
+  ): Observable<SanityDocument<R>[]>
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns an observable that resolves to a mutation result object containing the ID of the first deleted document.
    *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Request options
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
    */
-  fetch<R = Any, Q = QueryParams>(
-    query: string,
-    params: Q | undefined,
-    options: UnfilteredResponseQueryOptions,
-  ): Promise<RawQueryResponse<R>>
+  delete(
+    selection: MutationSelection,
+    options: FirstDocumentIdMutationOptions,
+  ): Observable<SingleMutationResult>
   /**
-   * Fetch a single document with the given ID.
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns an observable that resolves to a mutation result object containing the document IDs that were deleted.
    *
-   * @param id - Document ID to fetch
-   * @param options - Request options
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
    */
-  getDocument<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options?: {
-      tag?: string
-    },
-  ): Promise<SanityDocument<R> | undefined>
+  delete(
+    selection: MutationSelection,
+    options: AllDocumentIdsMutationOptions,
+  ): Observable<MultipleMutationResult>
   /**
-   * Fetch multiple documents in one request.
-   * Should be used sparingly - performing a query is usually a better option.
-   * The order/position of documents is preserved based on the original array of IDs.
-   * If any of the documents are missing, they will be replaced by a `null` entry in the returned array
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns an observable that resolves to first deleted document.
    *
-   * @param ids - Document IDs to fetch
-   * @param options - Request options
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
    */
-  getDocuments<R extends Record<string, Any> = Record<string, Any>>(
-    ids: string[],
-    options?: {
-      tag?: string
-    },
-  ): Promise<(SanityDocument<R> | null)[]>
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    selection: MutationSelection,
+    options?: BaseMutationOptions,
+  ): Observable<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 the created document.
+   * Perform mutation operations against the configured dataset
+   * Returns an observable that resolves to the first mutated document.
    *
-   * @param document - Document to create
+   * @param operations - Mutation operations to execute
    * @param options - Mutation options
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
     options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
+  ): Observable<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.
+   * Perform mutation operations against the configured dataset.
+   * Returns an observable that resolves to an array of the mutated documents.
    *
-   * @param document - Document to create
+   * @param operations - Mutation operations to execute
    * @param options - Mutation options
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
     options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
+  ): Observable<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.
+   * Perform mutation operations against the configured dataset
+   * Returns an observable that resolves to a mutation result object containing the document ID of the first mutated document.
    *
-   * @param document - Document to create
+   * @param operations - Mutation operations to execute
    * @param options - Mutation options
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
     options: FirstDocumentIdMutationOptions,
-  ): Promise<SingleMutationResult>
+  ): Observable<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.
+   * Perform mutation operations against the configured dataset
+   * Returns an observable that resolves to a mutation result object containing the mutated document IDs.
    *
-   * @param document - Document to create
+   * @param operations - Mutation operations to execute
    * @param options - Mutation options
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
     options: AllDocumentIdsMutationOptions,
-  ): Promise<MultipleMutationResult>
+  ): Observable<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.
+   * Perform mutation operations against the configured dataset
+   * Returns an observable that resolves to the first mutated document.
    *
-   * @param document - Document to create
+   * @param operations - Mutation operations to execute
    * @param options - Mutation options
    */
-  create<R extends Record<string, Any> = Record<string, Any>>(
-    document: SanityDocumentStub<R>,
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
     options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
+  ): Observable<SanityDocument<R>>
   /**
-   * Create a document if no document with the same ID already exists.
-   * Returns a promise that resolves to the created document.
+   * Create a new buildable patch of operations to perform
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param documentId - Document ID to patch
+   * @param operations - Optional object of patch operations to initialize the patch instance with
+   * @returns Patch instance - call `.commit()` to perform the operations defined
    */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
+  patch(documentId: string, operations?: PatchOperations): ObservablePatch
   /**
-   * Create a document if no document with the same ID already exists.
-   * Returns a promise that resolves to an array containing the created document.
+   * Create a new buildable patch of operations to perform
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param documentIds - Array of document IDs to patch
+   * @param operations - Optional object of patch operations to initialize the patch instance with
+   * @returns Patch instance - call `.commit()` to perform the operations defined
    */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
+  patch(documentIds: string[], operations?: PatchOperations): ObservablePatch
   /**
-   * 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.
+   * Create a new buildable patch of operations to perform
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param selection - An object with `query` and optional `params`, defining which document(s) to patch
+   * @param operations - Optional object of patch operations to initialize the patch instance with
+   * @returns Patch instance - call `.commit()` to perform the operations defined
    */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentIdMutationOptions,
-  ): Promise<SingleMutationResult>
+  patch(selection: MutationSelection, operations?: PatchOperations): ObservablePatch
   /**
-   * 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.
+   * Create a new transaction of mutations
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param operations - Optional array of mutation operations to initialize the transaction instance with
    */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentIdsMutationOptions,
-  ): Promise<MultipleMutationResult>
+  transaction<R extends Record<string, Any> = Record<string, Any>>(
+    operations?: Mutation<R>[],
+  ): ObservableTransaction
   /**
-   * Create a document if no document with the same ID already exists.
-   * Returns a promise that resolves to the created document.
+   * Perform an HTTP request against the Sanity API
    *
-   * @param document - Document to create
-   * @param options - Mutation options
+   * @param options - Request options
    */
-  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
+  request<R = Any>(options: RawRequestOptions): Observable<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.
+   * Get a Sanity API URL for the URI provided
    *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
+   * @param uri - URI/path to build URL for
+   * @param canUseCdn - Whether or not to allow using the API CDN for this route
    */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
+  getUrl(uri: string, canUseCdn?: boolean): string
   /**
-   * 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.
+   * Get a Sanity API URL for the data operation and path provided
    *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
+   * @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
+   * @param path - Path to append after the operation
    */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
+  getDataUrl(operation: string, path?: string): string
+}
+
+/**
+ * @deprecated -- Use `import {ObservableSanityClient} from '@sanity/client'` instead
+ * @public
+ */
+export declare class ObservableSanityStegaClient extends ObservableSanityClient {}
+
+/** @public */
+export declare class ObservableTransaction extends BaseTransaction {
+  private [clientSymbol_6]?
+  constructor(operations?: Mutation[], client?: ObservableSanityClient, transactionId?: string)
   /**
-   * 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.
+   * Clones the transaction
+   */
+  clone(): ObservableTransaction
+  /**
+   * Commit the transaction, returning an observable that produces the first mutated document
    *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: FirstDocumentIdMutationOptions,
-  ): Promise<SingleMutationResult>
+  commit<R extends Record<string, Any>>(
+    options: TransactionFirstDocumentMutationOptions,
+  ): Observable<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 created document ID.
+   * Commit the transaction, returning an observable that produces an array of the mutated documents
    *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options: AllDocumentIdsMutationOptions,
-  ): Promise<MultipleMutationResult>
+  commit<R extends Record<string, Any>>(
+    options: TransactionAllDocumentsMutationOptions,
+  ): Observable<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.
+   * Commit the transaction, returning an observable that produces a mutation result object
    *
-   * @param document - Document to either create or replace
-   * @param options - Mutation options
+   * @param options - Options for the mutation operation
    */
-  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
-    document: IdentifiedSanityDocumentStub<R>,
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
+  commit(options: TransactionFirstDocumentIdMutationOptions): Observable<SingleMutationResult>
   /**
-   * Deletes a document with the given document ID.
-   * Returns a promise that resolves to the deleted document.
+   * Commit the transaction, returning an observable that produces a mutation result object
    *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * @param options - Options for the mutation operation
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
+  commit(options: TransactionAllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
   /**
-   * Deletes a document with the given document ID.
-   * Returns a promise that resolves to an array containing the deleted document.
+   * Commit the transaction, returning an observable that produces a mutation result object
    *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * @param options - Options for the mutation operation
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
+  commit(options?: BaseMutationOptions): Observable<MultipleMutationResult>
   /**
-   * Deletes a document with the given document ID.
-   * Returns a promise that resolves to a mutation result object containing the deleted document ID.
+   * 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 id - Document ID to delete
-   * @param options - Options for the mutation
+   * @param documentId - Document ID to perform the patch operation on
+   * @param patchOps - Operations to perform, or a builder function
    */
-  delete(id: string, options: FirstDocumentIdMutationOptions): Promise<SingleMutationResult>
+  patch(documentId: string, patchOps?: ObservablePatchBuilder | PatchOperations): this
   /**
-   * Deletes a document with the given document ID.
-   * Returns a promise that resolves to a mutation result object containing the deleted document ID.
+   * Adds the given patch instance to the transaction.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
    *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * @param patch - ObservablePatch to execute
    */
-  delete(id: string, options: AllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
+  patch(patch: ObservablePatch): this
+}
+
+/** @public */
+export declare class ObservableUsersClient {
+  private [clientSymbol_4]
+  private [httpRequestSymbol_4]
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
   /**
-   * Deletes a document with the given document ID.
-   * Returns a promise that resolves to the deleted document.
+   * Fetch a user by user ID
    *
-   * @param id - Document ID to delete
-   * @param options - Options for the mutation
+   * @param id - User ID of the user to fetch. If `me` is provided, a minimal response including the users role is returned.
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    id: string,
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
+  getById<T extends 'me' | string>(
+    id: T,
+  ): Observable<T extends 'me' ? CurrentSanityUser : SanityUser>
+}
+
+/** @public */
+export declare class Patch extends BasePatch {
+  private [clientSymbol_5]?
+  constructor(selection: PatchSelection, operations?: PatchOperations, client?: SanityClient)
   /**
-   * Deletes one or more documents matching the given query or document ID.
-   * Returns a promise that resolves to first deleted document.
+   * Clones the patch
+   */
+  clone(): Patch
+  /**
+   * Commit the patch, returning a promise that resolves to the first patched document
    *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * @param options - Options for the mutation operation
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
+  commit<R extends Record<string, Any> = Record<string, Any>>(
     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.
+   * Commit the patch, returning a promise that resolves to an array of the mutated documents
    *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * @param options - Options for the mutation operation
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
+  commit<R extends Record<string, Any> = Record<string, Any>>(
     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.
+   * Commit the patch, returning a promise that resolves to a mutation result object
    *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * @param options - Options for the mutation operation
    */
-  delete(
-    selection: MutationSelection,
-    options: FirstDocumentIdMutationOptions,
-  ): Promise<SingleMutationResult>
+  commit(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.
+   * Commit the patch, returning a promise that resolves to a mutation result object
    *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * @param options - Options for the mutation operation
    */
-  delete(
-    selection: MutationSelection,
-    options: AllDocumentIdsMutationOptions,
-  ): Promise<MultipleMutationResult>
+  commit(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.
+   * Commit the patch, returning a promise that resolves to the first patched document
    *
-   * @param selection - An object with either an `id` or `query` key defining what to delete
-   * @param options - Options for the mutation
+   * @param options - Options for the mutation operation
    */
-  delete<R extends Record<string, Any> = Record<string, Any>>(
-    selection: MutationSelection,
+  commit<R extends Record<string, Any> = Record<string, Any>>(
     options?: BaseMutationOptions,
   ): Promise<SanityDocument<R>>
+}
+
+/** @public */
+export declare type PatchBuilder = (patch: Patch) => Patch
+
+/** @internal */
+export declare type PatchMutationOperation = PatchOperations & MutationSelection
+
+/** @internal */
+export declare interface PatchOperations {
+  set?: {
+    [key: string]: Any
+  }
+  setIfMissing?: {
+    [key: string]: Any
+  }
+  diffMatchPatch?: {
+    [key: string]: Any
+  }
+  unset?: string[]
+  inc?: {
+    [key: string]: number
+  }
+  dec?: {
+    [key: string]: number
+  }
+  insert?: InsertPatch
+  ifRevisionID?: string
+}
+
+/** @internal */
+export declare type PatchSelection = string | string[] | MutationSelection
+
+/** @public */
+declare interface ProgressEvent_2 {
+  type: 'progress'
+  stage: 'upload' | 'download'
+  percent: number
+  total?: number
+  loaded?: number
+  lengthComputable: boolean
+}
+export {ProgressEvent_2 as ProgressEvent}
+
+/** @internal */
+export declare class ProjectsClient {
+  private [clientSymbol_3]
+  private [httpRequestSymbol_3]
+  constructor(client: SanityClient, httpRequest: HttpRequest)
   /**
-   * Perform mutation operations against the configured dataset
-   * Returns a promise that resolves to the first mutated document.
-   *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * Perform mutation operations against the configured dataset.
-   * Returns a promise that resolves to an array of the mutated documents.
-   *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
-    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.
-   *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
-    options: FirstDocumentIdMutationOptions,
-  ): Promise<SingleMutationResult>
-  /**
-   * Perform mutation operations against the configured dataset
-   * Returns a promise that resolves to a mutation result object containing the mutated document IDs.
-   *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any>>(
-    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.
-   *
-   * @param operations - Mutation operations to execute
-   * @param options - Mutation options
-   */
-  mutate<R extends Record<string, Any> = Record<string, Any>>(
-    operations: Mutation<R>[] | Patch | Transaction,
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
-  /**
-   * Create a new buildable patch of operations to perform
-   *
-   * @param documentId - Document ID to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
-   */
-  patch(documentId: string, operations?: PatchOperations): Patch
-  /**
-   * Create a new buildable patch of operations to perform
-   *
-   * @param documentIds - Array of document IDs to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
-   */
-  patch(documentIds: string[], operations?: PatchOperations): Patch
-  /**
-   * Create a new buildable patch of operations to perform
-   *
-   * @param selection - An object with `query` and optional `params`, defining which document(s) to patch
-   * @param operations - Optional object of patch operations to initialize the patch instance with
-   * @returns Patch instance - call `.commit()` to perform the operations defined
-   */
-  patch(selection: MutationSelection, operations?: PatchOperations): Patch
-  /**
-   * Create a new transaction of mutations
-   *
-   * @param operations - Optional array of mutation operations to initialize the transaction instance with
-   */
-  transaction<R extends Record<string, Any> = Record<string, Any>>(
-    operations?: Mutation<R>[],
-  ): Transaction
-  /**
-   * Perform a request against the Sanity API
-   * NOTE: Only use this for Sanity API endpoints, not for your own APIs!
-   *
-   * @param options - Request options
-   * @returns Promise resolving to the response body
-   */
-  request<R = Any>(options: RawRequestOptions): Promise<R>
-  /**
-   * Perform an HTTP request a `/data` sub-endpoint
-   * NOTE: Considered internal, thus marked as deprecated. Use `request` instead.
-   *
-   * @deprecated - Use `request()` or your own HTTP library instead
-   * @param endpoint - Endpoint to hit (mutate, query etc)
-   * @param body - Request body
-   * @param options - Request options
-   * @internal
-   */
-  dataRequest(endpoint: string, body: unknown, options?: BaseMutationOptions): Promise<Any>
-  /**
-   * Get a Sanity API URL for the URI provided
+   * Fetch a list of projects the authenticated user has access to.
    *
-   * @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 list request
+   * @param options.includeMembers - Whether to include members in the response (default: true)
    */
-  getUrl(uri: string, canUseCdn?: boolean): string
+  list(options?: {includeMembers?: true}): Promise<SanityProject[]>
+  list(options?: {includeMembers?: false}): Promise<Omit<SanityProject, 'members'>[]>
   /**
-   * Get a Sanity API URL for the data operation and path provided
+   * Fetch a project by project ID
    *
-   * @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
-   * @param path - Path to append after the operation
+   * @param projectId - ID of the project to fetch
    */
-  getDataUrl(operation: string, path?: string): string
+  getById(projectId: string): Promise<SanityProject>
+}
+
+/** @public */
+export declare type QueryOptions = FilteredResponseQueryOptions | UnfilteredResponseQueryOptions
+
+/** @public */
+export declare type QueryParams = {
+  [key: string]: 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 - Optional listener options
- * @public
+ * It's easy to accidentally set query options such as `filterResponse`, `cache` and `next` as the second parameter in `client.fetch`,
+ * as that is a wide type used to set GROQ query paramaters and it accepts anything that can serialize to JSON.
+ * This type is used to prevent that, and will cause a type error if you try to pass a query option as the second parameter.
+ * If this type is `never`, it means `_QueryParamsLikelyByMistake` is missing keys from `QueryOptions`.
+ * @internal
  */
-export declare function _listen<R extends Record<string, Any> = Record<string, Any>>(
-  this:
-    | INTERNAL_DO_NOT_USE_DIRECTLY_SanityClient
-    | INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient,
-  query: string,
-  params?: QueryParams,
-): Observable<MutationEvent_2<R>>
+export declare type QueryParamsLikelyByMistake =
+  Required<_QueryParamsLikelyByMistake> extends Record<keyof QueryOptions, Any>
+    ? _QueryParamsLikelyByMistake
+    : never
 
 /**
- * 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 - Optional listener options
+ * Verify this type has all the same keys as QueryOptions before exporting
+ * @internal
+ */
+export declare type _QueryParamsLikelyByMistake = {
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  body?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  cache?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  filterResponse?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  headers?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  method?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  next?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  perspective?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  query?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  resultSourceMap?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  signal?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  stega?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  tag?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  timeout?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  token?: Any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  useCdn?: Any
+}
+
+/**
+ * Transform a QueryParams generic type to a valid parameter type for `client.fetch
  * @public
  */
-export declare function _listen<R extends Record<string, Any> = Record<string, Any>>(
-  this:
-    | INTERNAL_DO_NOT_USE_DIRECTLY_SanityClient
-    | INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient,
-  query: string,
-  params?: QueryParams,
-  options?: ListenOptions,
-): Observable<ListenEvent<R>>
+export declare type QueryParamsParameter<QueryParamsParameterType> =
+  QueryParamsParameterType extends QueryParams
+    ? QueryParamsParameterType
+    : QueryParamsParameterType extends Record<string, never>
+      ? Record<string, never>
+      : QueryParamsParameterType extends undefined
+        ? undefined | Record<string, never>
+        : never
 
-/** @public */
-export declare type ListenEvent<R extends Record<string, Any>> =
-  | MutationEvent_2<R>
-  | ChannelErrorEvent
-  | DisconnectEvent
-  | ReconnectEvent
-  | WelcomeEvent
+/**
+ * It's easy to accidentally set query options such as `filterResponse`, `cache` and `next` as the second parameter in `client.fetch`,
+ * as that is a wide type used to set GROQ query paramaters and it accepts anything that can serialize to JSON.
+ * This type is used to prevent that, and will cause a type error if you try to pass a query option as the second parameter.
+ * @internal
+ */
+export declare type QueryParamsWithoutQueryOptions = {
+  [K in keyof _QueryParamsLikelyByMistake]: never
+} & QueryParams
 
 /** @public */
-export declare type ListenEventName =
-  /** A mutation was performed */
-  | 'mutation'
-  /** The listener has been (re)established */
-  | 'welcome'
-  /** The listener has been disconnected, and a reconnect attempt is scheduled */
-  | 'reconnect'
+export declare interface RawQueryResponse<R> {
+  query: string
+  ms: number
+  result: R
+  resultSourceMap?: ContentSourceMap
+}
 
-/** @public */
-export declare interface ListenOptions {
-  /**
-   * Whether or not to include the resulting document in addition to the mutations performed.
-   * If you do not need the actual document, set this to `false` to reduce bandwidth usage.
-   * The result will be available on the `.result` property of the events.
-   * @defaultValue `true`
-   */
-  includeResult?: boolean
-  /**
-   * Whether or not to include the document as it looked before the mutation event.
-   * The previous revision will be available on the `.previous` property of the events,
-   * and may be `null` in the case of a new document.
-   * @defaultValue `false`
-   */
-  includePreviousRevision?: boolean
-  /**
-   * Whether events should be sent as soon as a transaction has been committed (`transaction`, default),
-   * or only after they are available for queries (query). Note that this is on a best-effort basis,
-   * and listeners with `query` may in certain cases (notably with deferred transactions) receive events
-   * that are not yet visible to queries.
-   *
-   * @defaultValue `'transaction'`
-   */
-  visibility?: 'transaction' | 'query'
-  /**
-   * Array of event names to include in the observable. By default, only mutation events are included.
-   *
-   * @defaultValue `['mutation']`
-   */
-  events?: ListenEventName[]
-  /**
-   * Format of "effects", eg the resulting changes of a mutation.
-   * Currently only `mendoza` is supported, and (if set) will include `apply` and `revert` arrays
-   * in the mutation events under the `effects` property.
-   *
-   * See {@link https://github.com/sanity-io/mendoza | The mendoza docs} for more info
-   *
-   * @defaultValue `undefined`
-   */
-  effectFormat?: 'mendoza'
-  /**
-   * Optional request tag for the listener. Use to identify the request in logs.
-   *
-   * @defaultValue `undefined`
-   */
+/** @internal */
+export declare interface RawRequestOptions {
+  url?: string
+  uri?: string
+  method?: string
+  token?: string
+  json?: boolean
   tag?: string
+  useGlobalApi?: boolean
+  withCredentials?: boolean
+  query?: {
+    [key: string]: string | string[]
+  }
+  headers?: {
+    [key: string]: string
+  }
+  timeout?: number
+  proxy?: string
+  body?: Any
+  maxRedirects?: number
+}
+
+/**
+ * The listener has been disconnected, and a reconnect attempt is scheduled.
+ *
+ * @public
+ */
+export declare type ReconnectEvent = {
+  type: 'reconnect'
 }
 
 /** @public */
-export declare type Logger =
-  | typeof console
-  | Partial<
-      Pick<typeof console, 'debug' | 'error' | 'groupCollapsed' | 'groupEnd' | 'log' | 'table'>
-    >
+export declare const requester: Requester
+
+/**
+ * Options for the native `fetch` feature, used by the Next.js app-router
+ * @public
+ */
+export declare interface RequestFetchOptions<T = 'next'> {
+  cache?: RequestInit['cache']
+  next?: T extends keyof RequestInit ? RequestInit[T] : never
+}
 
 /** @internal */
-export declare interface MultipleMutationResult {
-  transactionId: string
-  documentIds: string[]
-  results: {
-    id: string
-    operation: MutationOperation
-  }[]
+export declare interface RequestObservableOptions extends Omit<RequestOptions, 'url'> {
+  url?: string
+  uri?: string
+  canUseCdn?: boolean
+  useCdn?: boolean
+  tag?: string
+  resultSourceMap?: boolean | 'withKeyArraySelector'
+  perspective?: ClientPerspective
 }
 
 /** @public */
-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
-    }
+export declare interface RequestOptions {
+  timeout?: number
+  token?: string
+  tag?: string
+  headers?: Record<string, string>
+  method?: string
+  query?: Any
+  body?: Any
+  signal?: AbortSignal
+}
 
-/** @internal */
-export declare interface MutationError {
-  error: {
-    type: 'mutationError'
-    description: string
-    items?: MutationErrorItem[]
-  }
+/** @alpha */
+export declare type ResolveStudioUrl = (
+  sourceDocument: ContentSourceMapDocuments[number],
+) => StudioUrl
+
+/** @public */
+export declare interface ResponseEvent<T = unknown> {
+  type: 'response'
+  body: T
+  url: string
+  method: string
+  statusCode: number
+  statusMessage?: string
+  headers: Record<string, string>
+}
+
+/** @public */
+export declare interface ResponseQueryOptions extends RequestOptions {
+  perspective?: ClientPerspective
+  resultSourceMap?: boolean | 'withKeyArraySelector'
+  useCdn?: boolean
+  stega?: boolean | StegaConfig
+  cache?: 'next' extends keyof RequestInit ? RequestInit['cache'] : never
+  next?: ('next' extends keyof RequestInit ? RequestInit : never)['next']
 }
 
 /** @internal */
-export declare interface MutationErrorItem {
-  error: {
-    type: string
-    description: string
-    value?: unknown
-  }
+export declare interface SanityAssetDocument extends SanityDocument {
+  url: string
+  path: string
+  size: number
+  assetId: string
+  mimeType: string
+  sha1hash: string
+  extension: string
+  uploadId?: string
+  originalFilename?: string
 }
 
-/**
- * A mutation was performed. Note that when updating multiple documents in a transaction,
- * each document affected will get a separate mutation event.
- *
- * @public
- */
-declare type MutationEvent_2<R extends Record<string, Any> = Record<string, Any>> = {
-  type: 'mutation'
-  /**
-   * The ID of the document that was affected
-   */
-  documentId: string
-  /**
-   * A unique ID for this event
-   */
-  eventId: string
-  /**
-   * The user ID of the user that performed the mutation
-   */
-  identity: string
-  /**
-   * An array of mutations that were performed. Note that this can differ slightly from the
-   * mutations sent to the server, as the server may perform some mutations automatically.
-   */
-  mutations: Mutation[]
-  /**
-   * The revision ID of the document before the mutation was performed
-   */
-  previousRev?: string
-  /**
-   * The revision ID of the document after the mutation was performed
-   */
-  resultRev?: string
-  /**
-   * The document as it looked after the mutation was performed. This is only included if
-   * the listener was configured with `includeResult: true`.
-   */
-  result?: SanityDocument<R>
-  /**
-   * The document as it looked before the mutation was performed. This is only included if
-   * the listener was configured with `includePreviousRevision: true`.
-   */
-  previous?: SanityDocument<R> | null
+/** @public */
+export declare class SanityClient {
+  assets: AssetsClient
+  datasets: DatasetsClient
+  projects: ProjectsClient
+  users: UsersClient
   /**
-   * The effects of the mutation, if the listener was configured with `effectFormat: 'mendoza'`.
-   * Object with `apply` and `revert` arrays, see {@link https://github.com/sanity-io/mendoza}.
+   * Observable version of the Sanity client, with the same configuration as the promise-based one
    */
-  effects?: {
-    apply: unknown[]
-    revert: unknown[]
-  }
+  observable: ObservableSanityClient
   /**
-   * A timestamp for when the mutation was performed
+   * Private properties
    */
-  timestamp: string
+  private [clientConfigSymbol]
+  private [httpRequestSymbol_5]
   /**
-   * The transaction ID for the mutation
+   * Instance properties
    */
-  transactionId: string
+  listen: typeof _listen
+  constructor(httpRequest: HttpRequest, config?: ClientConfig)
   /**
-   * The type of transition the document went through.
-   *
-   * - `update` means the document was previously part of the subscribed set of documents,
-   *   and still is.
-   * - `appear` means the document was not previously part of the subscribed set of documents,
-   *   but is now. This can happen both on create or if updating to a state where it now matches
-   *   the filter provided to the listener.
-   * - `disappear` means the document was previously part of the subscribed set of documents,
-   *   but is no longer. This can happen both on delete or if updating to a state where it no
-   *   longer matches the filter provided to the listener.
+   * Clone the client - returns a new instance
    */
-  transition: 'update' | 'appear' | 'disappear'
+  clone(): SanityClient
   /**
-   * Whether the change that triggered this event is visible to queries (query) or only to
-   * subsequent transactions (transaction). The listener client can specify a preferred visibility
-   * through the `visibility` parameter on the listener, but this is only on a best-effort basis,
-   * and may yet not be accurate.
+   * Returns the current client configuration
    */
-  visibility: 'query' | 'transaction'
+  config(): InitializedClientConfig
   /**
-   * The total number of events that will be sent for this transaction.
-   * Note that this may differ from the amount of _documents_ affected by the transaction, as this
-   * number only includes the documents that matches the given filter.
-   *
-   * This can be useful if you need to perform changes to all matched documents atomically,
-   * eg you would wait for `transactionTotalEvents` events with the same `transactionId` before
-   * applying the changes locally.
+   * Reconfigure the client. Note that this _mutates_ the current client.
    */
-  transactionTotalEvents: number
+  config(newConfig?: Partial<ClientConfig>): this
   /**
-   * The index of this event within the transaction. Note that events may be delivered out of order,
-   * and that the index is zero-based.
-   */
-  transactionCurrentEvent: number
-}
-export {MutationEvent_2 as MutationEvent}
-
-/** @internal */
-export declare type MutationOperation = 'create' | 'delete' | 'update' | 'none'
-
-/** @internal */
-export declare type MutationSelection =
-  | {
-      query: string
-      params?: QueryParams
-    }
-  | {
-      id: string | string[]
-    }
-
-/** @internal */
-export declare class ObservableAssetsClient {
-  #private
-  constructor(client: INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient, httpRequest: HttpRequest)
+   * Clone the client with a new (partial) configuration.
+   *
+   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
+   */
+  withConfig(newConfig?: Partial<ClientConfig>): SanityClient
   /**
-   * Uploads a file asset to the configured dataset
+   * Perform a GROQ-query against the configured dataset.
    *
-   * @param assetType - Asset type (file)
-   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
-   * @param options - Options to use for the upload
+   * @param query - GROQ-query to perform
    */
-  upload(
-    assetType: 'file',
-    body: UploadBody,
-    options?: UploadClientConfig,
-  ): Observable<
-    HttpRequestEvent<{
-      document: SanityAssetDocument
-    }>
-  >
+  fetch<R = Any, Q extends never | undefined | Record<string, never> = never>(
+    query: string,
+  ): Promise<R>
   /**
-   * Uploads an image asset to the configured dataset
+   * Perform a GROQ-query against the configured dataset.
    *
-   * @param assetType - Asset type (image)
-   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
-   * @param options - Options to use for the upload
+   * @param query - GROQ-query to perform
+   * @param params - Optional query parameters
+   * @param options - Optional request options
    */
-  upload(
-    assetType: 'image',
-    body: UploadBody,
-    options?: UploadClientConfig,
-  ): Observable<
-    HttpRequestEvent<{
-      document: SanityImageAssetDocument
-    }>
-  >
+  fetch<R = Any, Q = QueryParamsWithoutQueryOptions>(
+    query: string,
+    params: QueryParamsParameter<Q>,
+    options?: FilteredResponseQueryOptions,
+  ): Promise<R>
   /**
-   * Uploads a file or an image asset to the configured dataset
+   * Perform a GROQ-query against 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
+   * @param query - GROQ-query to perform
+   * @param params - Optional query parameters
+   * @param options - Request options
    */
-  upload(
-    assetType: 'file' | 'image',
-    body: UploadBody,
-    options?: UploadClientConfig,
-  ): Observable<
-    HttpRequestEvent<{
-      document: SanityAssetDocument | SanityImageAssetDocument
-    }>
-  >
-}
-
-/** @internal */
-export declare class ObservableDatasetsClient {
-  #private
-  constructor(client: INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient, httpRequest: HttpRequest)
+  fetch<R = Any, Q = QueryParamsWithoutQueryOptions>(
+    query: string,
+    params: QueryParamsParameter<Q>,
+    options: UnfilteredResponseQueryOptions,
+  ): Promise<RawQueryResponse<R>>
   /**
-   * Create a new dataset with the given name
+   * You're passing in query parameters to a GROQ query that looks like query options.
+   * This is likely a mistake, you can either:
+   * a) replace the second argument with an empty object, and move the options to the third argument
+   * ```diff
+   * -client.fetch(query, {cache: 'no-store'})
+   * +client.fetch(query, {}, {cache: 'no-store'})
+   * ```
+   * b) add a generic type parameter that allows the query parameters to be passed in to silence the error
+   * @deprecated not actually deprecated, marking it as deprecated makes this error easier to spot
+   */
+  fetch<R = Any>(
+    query: string,
+    params: QueryParamsLikelyByMistake & QueryParams,
+    options?: QueryOptions,
+  ): unknown
+  /**
+   * Fetch a single document with the given ID.
    *
-   * @param name - Name of the dataset to create
-   * @param options - Options for the dataset
+   * @param id - Document ID to fetch
+   * @param options - Request options
    */
-  create(
-    name: string,
+  getDocument<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
     options?: {
-      aclMode?: DatasetAclMode
+      tag?: string
     },
-  ): Observable<DatasetResponse>
+  ): Promise<SanityDocument<R> | undefined>
   /**
-   * Edit a dataset with the given name
+   * Fetch multiple documents in one request.
+   * Should be used sparingly - performing a query is usually a better option.
+   * The order/position of documents is preserved based on the original array of IDs.
+   * If any of the documents are missing, they will be replaced by a `null` entry in the returned array
    *
-   * @param name - Name of the dataset to edit
-   * @param options - New options for the dataset
+   * @param ids - Document IDs to fetch
+   * @param options - Request options
    */
-  edit(
-    name: string,
+  getDocuments<R extends Record<string, Any> = Record<string, Any>>(
+    ids: string[],
     options?: {
-      aclMode?: DatasetAclMode
+      tag?: string
     },
-  ): Observable<DatasetResponse>
+  ): Promise<(SanityDocument<R> | null)[]>
   /**
-   * Delete a dataset with the given name
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns a promise that resolves to the created document.
    *
-   * @param name - Name of the dataset to delete
+   * @param document - Document to create
+   * @param options - Mutation options
    */
-  delete(name: string): Observable<{
-    deleted: true
-  }>
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options: FirstDocumentMutationOptions,
+  ): Promise<SanityDocument<R>>
   /**
-   * Fetch a list of datasets for the configured project
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns a promise that resolves to an array containing the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
    */
-  list(): Observable<DatasetsResponse>
-}
-
-/** @public */
-export declare class ObservablePatch extends BasePatch {
-  #private
-  constructor(
-    selection: PatchSelection,
-    operations?: PatchOperations,
-    client?: INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient,
-  )
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options: AllDocumentsMutationOptions,
+  ): Promise<SanityDocument<R>[]>
   /**
-   * Clones the patch
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
    */
-  clone(): ObservablePatch
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options: FirstDocumentIdMutationOptions,
+  ): Promise<SingleMutationResult>
   /**
-   * Commit the patch, returning an observable that produces the first patched document
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
    *
-   * @param options - Options for the mutation operation
+   * @param document - Document to create
+   * @param options - Mutation options
    */
-  commit<R extends Record<string, Any> = Record<string, Any>>(
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options: AllDocumentIdsMutationOptions,
+  ): Promise<MultipleMutationResult>
+  /**
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns a promise that resolves to the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options?: BaseMutationOptions,
+  ): Promise<SanityDocument<R>>
+  /**
+   * Create a document if no document with the same ID already exists.
+   * Returns a promise that resolves to the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
     options: FirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
+  ): Promise<SanityDocument<R>>
   /**
-   * Commit the patch, returning an observable that produces an array of the mutated documents
+   * Create a document if no document with the same ID already exists.
+   * Returns a promise that resolves to an array containing the created document.
    *
-   * @param options - Options for the mutation operation
+   * @param document - Document to create
+   * @param options - Mutation options
    */
-  commit<R extends Record<string, Any> = Record<string, Any>>(
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
     options: AllDocumentsMutationOptions,
-  ): Observable<SanityDocument<R>[]>
+  ): Promise<SanityDocument<R>[]>
   /**
-   * Commit the patch, returning an observable that produces a mutation result object
+   * Create a document if no document with the same ID already exists.
+   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
    *
-   * @param options - Options for the mutation operation
+   * @param document - Document to create
+   * @param options - Mutation options
    */
-  commit(options: FirstDocumentIdMutationOptions): Observable<SingleMutationResult>
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentIdMutationOptions,
+  ): Promise<SingleMutationResult>
   /**
-   * Commit the patch, returning an observable that produces a mutation result object
+   * Create a document if no document with the same ID already exists.
+   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
    *
-   * @param options - Options for the mutation operation
+   * @param document - Document to create
+   * @param options - Mutation options
    */
-  commit(options: AllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentIdsMutationOptions,
+  ): Promise<MultipleMutationResult>
   /**
-   * Commit the patch, returning an observable that produces the first patched document
+   * Create a document if no document with the same ID already exists.
+   * Returns a promise that resolves to the created document.
    *
-   * @param options - Options for the mutation operation
+   * @param document - Document to create
+   * @param options - Mutation options
    */
-  commit<R extends Record<string, Any> = Record<string, Any>>(
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
     options?: BaseMutationOptions,
-  ): Observable<SanityDocument<R>>
-}
-
-/** @public */
-export declare type ObservablePatchBuilder = (patch: ObservablePatch) => ObservablePatch
-
-/** @internal */
-export declare class ObservableProjectsClient {
-  #private
-  constructor(client: INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient, httpRequest: HttpRequest)
+  ): Promise<SanityDocument<R>>
   /**
-   * Fetch a list of projects the authenticated user has access to.
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns a promise that resolves to the created document.
    *
-   * @param options - Options for the list request
-   * @param options.includeMembers - Whether to include members in the response (default: true)
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
    */
-  list(options?: {includeMembers?: true}): Observable<SanityProject[]>
-  list(options?: {includeMembers?: false}): Observable<Omit<SanityProject, 'members'>[]>
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentMutationOptions,
+  ): Promise<SanityDocument<R>>
   /**
-   * Fetch a project by project ID
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns a promise that resolves to an array containing the created document.
    *
-   * @param projectId - ID of the project to fetch
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
    */
-  getById(projectId: string): Observable<SanityProject>
-}
-
-/**
- * @deprecated -- Use `import type {ObservableSanityClient} from '@sanity/client'` instead
- * @public
- */
-export declare type ObservableSanityClient = never
-
-/** @public */
-export declare class ObservableSanityStegaClient extends INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient {
-  #private
-  private stegaConfig
-  constructor(httpRequest: HttpRequest, config?: ClientStegaConfig)
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentsMutationOptions,
+  ): Promise<SanityDocument<R>[]>
+  /**
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
+   */
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentIdMutationOptions,
+  ): Promise<SingleMutationResult>
   /**
-   * Clone the client - returns a new instance
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns a promise that resolves to a mutation result object containing the created document ID.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
    */
-  clone(): ObservableSanityStegaClient
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentIdsMutationOptions,
+  ): Promise<MultipleMutationResult>
   /**
-   * Returns the current client configuration
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns a promise that resolves to the created document.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
    */
-  config(): InitializedClientStegaConfig
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options?: BaseMutationOptions,
+  ): Promise<SanityDocument<R>>
   /**
-   * Reconfigure the client. Note that this _mutates_ the current client.
+   * Deletes a document with the given document ID.
+   * Returns a promise that resolves to the deleted document.
+   *
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
    */
-  config(newConfig?: Partial<ClientStegaConfig>): this
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options: FirstDocumentMutationOptions,
+  ): Promise<SanityDocument<R>>
   /**
-   * Clone the client with a new (partial) configuration.
+   * Deletes a document with the given document ID.
+   * Returns a promise that resolves to an array containing the deleted document.
    *
-   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
    */
-  withConfig(newConfig?: Partial<ClientConfig>): ObservableSanityStegaClient
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options: AllDocumentsMutationOptions,
+  ): Promise<SanityDocument<R>[]>
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Deletes a document with the given document ID.
+   * Returns a promise that resolves to a mutation result object containing the deleted document ID.
    *
-   * @param query - GROQ-query to perform
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
    */
-  fetch<R = Any>(query: string): Observable<R>
+  delete(id: string, options: FirstDocumentIdMutationOptions): Promise<SingleMutationResult>
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Deletes a document with the given document ID.
+   * Returns a promise that resolves to a mutation result object containing the deleted document ID.
    *
-   * @param query - GROQ-query to perform
-   * @param params - Query parameters
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
    */
-  fetch<R = Any, Q = QueryParams>(query: string, params: Q): Observable<R>
+  delete(id: string, options: AllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Deletes a document with the given document ID.
+   * Returns a promise that resolves to the deleted document.
    *
-   * @param query - GROQ-query to perform
-   * @param params - Query parameters
-   * @param options - Request options
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
    */
-  fetch<R = Any, Q = QueryParams>(
-    query: string,
-    params: Q | undefined,
-    options: FilteredResponseQueryOptions,
-  ): Observable<R>
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options?: BaseMutationOptions,
+  ): Promise<SanityDocument<R>>
   /**
-   * Perform a GROQ-query against the configured dataset.
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns a promise that resolves to first deleted document.
    *
-   * @param query - GROQ-query to perform
-   * @param params - Query parameters
-   * @param options - Request options
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
    */
-  fetch<R = Any, Q = QueryParams>(
-    query: string,
-    params: Q | undefined,
-    options: UnfilteredResponseQueryOptions,
-  ): Observable<RawQueryResponse<R>>
-}
-
-/** @public */
-export declare class ObservableTransaction extends BaseTransaction {
-  #private
-  constructor(
-    operations?: Mutation[],
-    client?: INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient,
-    transactionId?: string,
-  )
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    selection: MutationSelection,
+    options: FirstDocumentMutationOptions,
+  ): Promise<SanityDocument<R>>
   /**
-   * Clones the transaction
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns a promise that resolves to an array containing the deleted documents.
+   *
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
    */
-  clone(): ObservableTransaction
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    selection: MutationSelection,
+    options: AllDocumentsMutationOptions,
+  ): Promise<SanityDocument<R>[]>
   /**
-   * Commit the transaction, returning an observable that produces the first mutated document
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns a promise that resolves to a mutation result object containing the ID of the first deleted document.
    *
-   * @param options - Options for the mutation operation
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
    */
-  commit<R extends Record<string, Any>>(
-    options: TransactionFirstDocumentMutationOptions,
-  ): Observable<SanityDocument<R>>
+  delete(
+    selection: MutationSelection,
+    options: FirstDocumentIdMutationOptions,
+  ): Promise<SingleMutationResult>
   /**
-   * Commit the transaction, returning an observable that produces an array of the mutated documents
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns a promise that resolves to a mutation result object containing the document IDs that were deleted.
    *
-   * @param options - Options for the mutation operation
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
    */
-  commit<R extends Record<string, Any>>(
-    options: TransactionAllDocumentsMutationOptions,
-  ): Observable<SanityDocument<R>[]>
+  delete(
+    selection: MutationSelection,
+    options: AllDocumentIdsMutationOptions,
+  ): Promise<MultipleMutationResult>
   /**
-   * Commit the transaction, returning an observable that produces a mutation result object
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns a promise that resolves to first deleted document.
    *
-   * @param options - Options for the mutation operation
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
    */
-  commit(options: TransactionFirstDocumentIdMutationOptions): Observable<SingleMutationResult>
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    selection: MutationSelection,
+    options?: BaseMutationOptions,
+  ): Promise<SanityDocument<R>>
   /**
-   * Commit the transaction, returning an observable that produces a mutation result object
+   * Perform mutation operations against the configured dataset
+   * Returns a promise that resolves to the first mutated document.
    *
-   * @param options - Options for the mutation operation
+   * @param operations - Mutation operations to execute
+   * @param options - Mutation options
    */
-  commit(options: TransactionAllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | Patch | Transaction,
+    options: FirstDocumentMutationOptions,
+  ): Promise<SanityDocument<R>>
   /**
-   * Commit the transaction, returning an observable that produces a mutation result object
+   * Perform mutation operations against the configured dataset.
+   * Returns a promise that resolves to an array of the mutated documents.
    *
-   * @param options - Options for the mutation operation
+   * @param operations - Mutation operations to execute
+   * @param options - Mutation options
    */
-  commit(options?: BaseMutationOptions): Observable<MultipleMutationResult>
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | Patch | Transaction,
+    options: AllDocumentsMutationOptions,
+  ): Promise<SanityDocument<R>[]>
   /**
-   * 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()`
+   * 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.
    *
-   * @param documentId - Document ID to perform the patch operation on
-   * @param patchOps - Operations to perform, or a builder function
+   * @param operations - Mutation operations to execute
+   * @param options - Mutation options
    */
-  patch(documentId: string, patchOps?: ObservablePatchBuilder | PatchOperations): this
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | Patch | Transaction,
+    options: FirstDocumentIdMutationOptions,
+  ): Promise<SingleMutationResult>
   /**
-   * Adds the given patch instance to the transaction.
-   * The operation is added to the current transaction, ready to be commited by `commit()`
+   * Perform mutation operations against the configured dataset
+   * Returns a promise that resolves to a mutation result object containing the mutated document IDs.
    *
-   * @param patch - ObservablePatch to execute
+   * @param operations - Mutation operations to execute
+   * @param options - Mutation options
    */
-  patch(patch: ObservablePatch): this
-}
-
-/** @public */
-export declare class ObservableUsersClient {
-  #private
-  constructor(client: INTERNAL_DO_NOT_USE_DIRECTLY_ObservableSanityClient, httpRequest: HttpRequest)
+  mutate<R extends Record<string, Any>>(
+    operations: Mutation<R>[] | Patch | Transaction,
+    options: AllDocumentIdsMutationOptions,
+  ): Promise<MultipleMutationResult>
   /**
-   * Fetch a user by user ID
+   * Perform mutation operations against the configured dataset
+   * Returns a promise that resolves to the first mutated document.
    *
-   * @param id - User ID of the user to fetch. If `me` is provided, a minimal response including the users role is returned.
+   * @param operations - Mutation operations to execute
+   * @param options - Mutation options
    */
-  getById<T extends 'me' | string>(
-    id: T,
-  ): Observable<T extends 'me' ? CurrentSanityUser : SanityUser>
-}
-
-/** @public */
-export declare class Patch extends BasePatch {
-  #private
-  constructor(
-    selection: PatchSelection,
-    operations?: PatchOperations,
-    client?: INTERNAL_DO_NOT_USE_DIRECTLY_SanityClient,
-  )
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | Patch | Transaction,
+    options?: BaseMutationOptions,
+  ): Promise<SanityDocument<R>>
   /**
-   * Clones the patch
+   * Create a new buildable patch of operations to perform
+   *
+   * @param documentId - Document ID to patch
+   * @param operations - Optional object of patch operations to initialize the patch instance with
+   * @returns Patch instance - call `.commit()` to perform the operations defined
    */
-  clone(): Patch
+  patch(documentId: string, operations?: PatchOperations): Patch
   /**
-   * Commit the patch, returning a promise that resolves to the first patched document
+   * Create a new buildable patch of operations to perform
    *
-   * @param options - Options for the mutation operation
+   * @param documentIds - Array of document IDs to patch
+   * @param operations - Optional object of patch operations to initialize the patch instance with
+   * @returns Patch instance - call `.commit()` to perform the operations defined
    */
-  commit<R extends Record<string, Any> = Record<string, Any>>(
-    options: FirstDocumentMutationOptions,
-  ): Promise<SanityDocument<R>>
+  patch(documentIds: string[], operations?: PatchOperations): Patch
   /**
-   * Commit the patch, returning a promise that resolves to an array of the mutated documents
+   * Create a new buildable patch of operations to perform
    *
-   * @param options - Options for the mutation operation
+   * @param selection - An object with `query` and optional `params`, defining which document(s) to patch
+   * @param operations - Optional object of patch operations to initialize the patch instance with
+   * @returns Patch instance - call `.commit()` to perform the operations defined
    */
-  commit<R extends Record<string, Any> = Record<string, Any>>(
-    options: AllDocumentsMutationOptions,
-  ): Promise<SanityDocument<R>[]>
+  patch(selection: MutationSelection, operations?: PatchOperations): Patch
   /**
-   * Commit the patch, returning a promise that resolves to a mutation result object
+   * Create a new transaction of mutations
    *
-   * @param options - Options for the mutation operation
+   * @param operations - Optional array of mutation operations to initialize the transaction instance with
    */
-  commit(options: FirstDocumentIdMutationOptions): Promise<SingleMutationResult>
+  transaction<R extends Record<string, Any> = Record<string, Any>>(
+    operations?: Mutation<R>[],
+  ): Transaction
   /**
-   * Commit the patch, returning a promise that resolves to a mutation result object
+   * Perform a request against the Sanity API
+   * NOTE: Only use this for Sanity API endpoints, not for your own APIs!
    *
-   * @param options - Options for the mutation operation
+   * @param options - Request options
+   * @returns Promise resolving to the response body
    */
-  commit(options: AllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
+  request<R = Any>(options: RawRequestOptions): Promise<R>
   /**
-   * Commit the patch, returning a promise that resolves to the first patched document
+   * Perform an HTTP request a `/data` sub-endpoint
+   * NOTE: Considered internal, thus marked as deprecated. Use `request` instead.
    *
-   * @param options - Options for the mutation operation
+   * @deprecated - Use `request()` or your own HTTP library instead
+   * @param endpoint - Endpoint to hit (mutate, query etc)
+   * @param body - Request body
+   * @param options - Request options
+   * @internal
    */
-  commit<R extends Record<string, Any> = Record<string, Any>>(
-    options?: BaseMutationOptions,
-  ): Promise<SanityDocument<R>>
-}
-
-/** @public */
-export declare type PatchBuilder = (patch: Patch) => Patch
-
-/** @internal */
-export declare type PatchMutationOperation = PatchOperations & MutationSelection
-
-/** @internal */
-export declare interface PatchOperations {
-  set?: {
-    [key: string]: Any
-  }
-  setIfMissing?: {
-    [key: string]: Any
-  }
-  diffMatchPatch?: {
-    [key: string]: Any
-  }
-  unset?: string[]
-  inc?: {
-    [key: string]: number
-  }
-  dec?: {
-    [key: string]: number
-  }
-  insert?: InsertPatch
-  ifRevisionID?: string
-}
-
-/** @internal */
-export declare type PatchSelection = string | string[] | MutationSelection
-
-/** @public */
-declare interface ProgressEvent_2 {
-  type: 'progress'
-  stage: 'upload' | 'download'
-  percent: number
-  total?: number
-  loaded?: number
-  lengthComputable: boolean
-}
-export {ProgressEvent_2 as ProgressEvent}
-
-/** @internal */
-export declare class ProjectsClient {
-  #private
-  constructor(client: INTERNAL_DO_NOT_USE_DIRECTLY_SanityClient, httpRequest: HttpRequest)
+  dataRequest(endpoint: string, body: unknown, options?: BaseMutationOptions): Promise<Any>
   /**
-   * Fetch a list of projects the authenticated user has access to.
+   * Get a Sanity API URL for the URI provided
    *
-   * @param options - Options for the list request
-   * @param options.includeMembers - Whether to include members in the response (default: true)
+   * @param uri - URI/path to build URL for
+   * @param canUseCdn - Whether or not to allow using the API CDN for this route
    */
-  list(options?: {includeMembers?: true}): Promise<SanityProject[]>
-  list(options?: {includeMembers?: false}): Promise<Omit<SanityProject, 'members'>[]>
+  getUrl(uri: string, canUseCdn?: boolean): string
   /**
-   * Fetch a project by project ID
+   * Get a Sanity API URL for the data operation and path provided
    *
-   * @param projectId - ID of the project to fetch
+   * @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
+   * @param path - Path to append after the operation
    */
-  getById(projectId: string): Promise<SanityProject>
-}
-
-/** @public */
-export declare type QueryParams = {
-  [key: string]: Any
-}
-
-/** @public */
-export declare interface RawQueryResponse<R> {
-  query: string
-  ms: number
-  result: R
-  resultSourceMap?: ContentSourceMap
-}
-
-/** @internal */
-export declare interface RawRequestOptions {
-  url?: string
-  uri?: string
-  method?: string
-  token?: string
-  json?: boolean
-  tag?: string
-  useGlobalApi?: boolean
-  withCredentials?: boolean
-  query?: {
-    [key: string]: string | string[]
-  }
-  headers?: {
-    [key: string]: string
-  }
-  timeout?: number
-  proxy?: string
-  body?: Any
-  maxRedirects?: number
-}
-
-/**
- * The listener has been disconnected, and a reconnect attempt is scheduled.
- *
- * @public
- */
-export declare type ReconnectEvent = {
-  type: 'reconnect'
-}
-
-/** @public */
-export declare const requester: Requester
-
-/**
- * Options for the native `fetch` feature, used by the Next.js app-router
- * @public
- */
-export declare interface RequestFetchOptions<T = 'next'> {
-  cache?: RequestInit['cache']
-  next?: T extends keyof RequestInit ? RequestInit[T] : never
-}
-
-/** @internal */
-export declare interface RequestObservableOptions extends Omit<RequestOptions, 'url'> {
-  url?: string
-  uri?: string
-  canUseCdn?: boolean
-  useCdn?: boolean
-  tag?: string
-  resultSourceMap?: boolean | 'withKeyArraySelector'
-  perspective?: ClientPerspective
-}
-
-/** @public */
-export declare interface RequestOptions {
-  timeout?: number
-  token?: string
-  tag?: string
-  headers?: Record<string, string>
-  method?: string
-  query?: Any
-  body?: Any
-  signal?: AbortSignal
-}
-
-/** @alpha */
-export declare type ResolveStudioUrl = (
-  sourceDocument: ContentSourceMapDocuments[number],
-) => StudioUrl
-
-/** @public */
-export declare interface ResponseEvent<T = unknown> {
-  type: 'response'
-  body: T
-  url: string
-  method: string
-  statusCode: number
-  statusMessage?: string
-  headers: Record<string, string>
-}
-
-/** @public */
-export declare interface ResponseQueryOptions<T = 'next'> extends RequestOptions {
-  perspective?: ClientPerspective
-  resultSourceMap?: boolean | 'withKeyArraySelector'
-  cache?: RequestInit['cache']
-  next?: T extends keyof RequestInit ? RequestInit[T] : never
-  useCdn?: boolean
-}
-
-/** @internal */
-export declare interface SanityAssetDocument extends SanityDocument {
-  url: string
-  path: string
-  size: number
-  assetId: string
-  mimeType: string
-  sha1hash: string
-  extension: string
-  uploadId?: string
-  originalFilename?: string
+  getDataUrl(operation: string, path?: string): string
 }
 
-/**
- * @deprecated -- Use `import type {SanityClient} from '@sanity/client'` instead
- * @public
- */
-export declare type SanityClient = never
-
 /** @internal */
 export declare type SanityDocument<T extends Record<string, Any> = Record<string, Any>> = {
   [P in keyof T]: T[P]
@@ -2552,71 +2619,11 @@ export declare interface SanityReference {
   _ref: string
 }
 
-/** @public */
-export declare class SanityStegaClient extends INTERNAL_DO_NOT_USE_DIRECTLY_SanityClient {
-  #private
-  /**
-   * Observable version of the Sanity client, with the same configuration as the promise-based one
-   */
-  observable: ObservableSanityStegaClient
-  private stegaConfig
-  constructor(httpRequest: HttpRequest, config?: ClientStegaConfig)
-  /**
-   * Clone the client - returns a new instance
-   */
-  clone(): SanityStegaClient
-  /**
-   * Returns the current client configuration
-   */
-  config(): InitializedClientStegaConfig
-  /**
-   * Reconfigure the client. Note that this _mutates_ the current client.
-   */
-  config(newConfig?: Partial<ClientStegaConfig>): this
-  /**
-   * Clone the client with a new (partial) configuration.
-   *
-   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
-   */
-  withConfig(newConfig?: Partial<ClientStegaConfig>): SanityStegaClient
-  /**
-   * 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.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   */
-  fetch<R = Any, Q = QueryParams>(query: string, params: Q): Promise<R>
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Request options
-   */
-  fetch<R = Any, Q = QueryParams>(
-    query: string,
-    params: Q | undefined,
-    options: FilteredResponseQueryOptions,
-  ): Promise<R>
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Request options
-   */
-  fetch<R = Any, Q = QueryParams>(
-    query: string,
-    params: Q | undefined,
-    options: UnfilteredResponseQueryOptions,
-  ): Promise<RawQueryResponse<R>>
-}
+/**
+ * @deprecated -- Use `import {SanityClient} from '@sanity/client'` instead
+ * @public
+ */
+export declare class SanityStegaClient extends SanityClient {}
 
 /** @internal */
 export declare interface SanityUser {
@@ -2678,7 +2685,7 @@ export declare interface StegaConfig {
 }
 
 /** @public */
-export declare type StegaConfigRequiredKeys = Extract<keyof StegaConfig, 'enabled' | 'filter'>
+export declare type StegaConfigRequiredKeys = Extract<keyof StegaConfig, 'enabled'>
 
 /**
  * Uses `@vercel/stega` to embed edit info JSON into strings in your query result.
@@ -2711,12 +2718,8 @@ export declare type StudioUrl = StudioBaseUrl | StudioBaseRoute
 
 /** @public */
 export declare class Transaction extends BaseTransaction {
-  #private
-  constructor(
-    operations?: Mutation[],
-    client?: INTERNAL_DO_NOT_USE_DIRECTLY_SanityClient,
-    transactionId?: string,
-  )
+  private [clientSymbol_6]?
+  constructor(operations?: Mutation[], client?: SanityClient, transactionId?: string)
   /**
    * Clones the transaction
    */
@@ -2804,7 +2807,7 @@ export declare type TransactionMutationOptions =
   | TransactionAllDocumentIdsMutationOptions
 
 /** @public */
-export declare type UnfilteredResponseQueryOptions = ResponseQueryOptions & {
+export declare interface UnfilteredResponseQueryOptions extends ResponseQueryOptions {
   filterResponse: false
 }
 
@@ -2878,8 +2881,9 @@ export declare interface UploadClientConfig {
 
 /** @public */
 export declare class UsersClient {
-  #private
-  constructor(client: INTERNAL_DO_NOT_USE_DIRECTLY_SanityClient, httpRequest: HttpRequest)
+  private [clientSymbol_4]
+  private [httpRequestSymbol_4]
+  constructor(client: SanityClient, httpRequest: HttpRequest)
   /**
    * Fetch a user by user ID
    *
@@ -2906,11 +2910,3 @@ export declare type WelcomeEvent = {
 }
 
 export {}
-
-declare module '../types' {
-  /** @public */
-  interface ResponseQueryOptions<T = 'next'> extends RequestOptions {
-    stega?: boolean | StegaConfig
-  }
-}
-//# sourceMappingURL=types.d.ts.map