@sanity/sdk-react 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/index.d.ts

@@ -1,7 +1,4816 @@
+import {ActionsResult} from '@sanity/sdk'
+import {ApplyDocumentActionsOptions} from '@sanity/sdk'
+import {AuthProvider} from '@sanity/sdk'
+import {AuthState} from '@sanity/sdk'
+import {CanvasResource} from '@sanity/message-protocol'
+import {ClientOptions} from '@sanity/sdk'
+import {CurrentUser} from '@sanity/sdk'
+import {DocumentAction} from '@sanity/sdk'
+import {DocumentEvent} from '@sanity/sdk'
+import {DocumentHandle} from '@sanity/sdk'
+import {DocumentPermissionsResult} from '@sanity/sdk'
+import {FallbackProps} from 'react-error-boundary'
+import {FrameMessage} from '@sanity/sdk'
+import {JsonMatch} from '@sanity/sdk'
+import {JsonMatchPath} from '@sanity/sdk'
+import {MediaResource} from '@sanity/message-protocol'
+import {Observable} from 'rxjs'
+import {PreviewValue} from '@sanity/sdk'
+import {QueryOptions} from '@sanity/sdk'
+import {ReactElement} from 'react'
+import {ReactNode} from 'react'
+import {Requester} from 'get-it'
+import {ResourceId} from '@sanity/sdk'
+import {ResourceType} from '@sanity/sdk'
+import {SanityConfig} from '@sanity/sdk'
+import {SanityDocument} from '@sanity/types'
+import {SanityInstance} from '@sanity/sdk'
+import {SanityProject as SanityProject_2} from '@sanity/sdk'
+import {SanityUser as SanityUser_2} from '@sanity/sdk'
+import {SortOrderingItem} from '@sanity/types'
+import {StudioResource} from '@sanity/message-protocol'
+import {ValidProjection} from '@sanity/sdk'
+import {WindowMessage} from '@sanity/sdk'
+
+/** @public */
+declare type Action =
+  | CreateAction
+  | ReplaceDraftAction
+  | EditAction
+  | DeleteAction
+  | DiscardAction
+  | PublishAction
+  | UnpublishAction
+
+/** @internal */
+declare type AllDocumentIdsMutationOptions = BaseMutationOptions & {
+  returnFirst: false
+  returnDocuments: false
+}
+
+/** @internal */
+declare type AllDocumentsMutationOptions = BaseMutationOptions & {
+  returnFirst: false
+  returnDocuments?: true
+}
+
+/**
+ * Used to tag types that is set to `any` as a temporary measure, but should be replaced with proper typings in the future
+ * @internal
+ */
+declare type Any = any
+
+/** @public */
+declare type AssetMetadataType =
+  | 'location'
+  | 'exif'
+  | 'image'
+  | 'palette'
+  | 'lqip'
+  | 'blurhash'
+  | 'none'
+
+/** @internal */
+declare class AssetsClient {
+  #private
+  constructor(client: SanityClient, httpRequest: HttpRequest)
+  /**
+   * Uploads a file asset to the configured dataset
+   *
+   * @param assetType - Asset type (file)
+   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
+   * @param options - Options to use for the upload
+   */
+  upload(
+    assetType: 'file',
+    body: UploadBody,
+    options?: UploadClientConfig,
+  ): Promise<SanityAssetDocument>
+  /**
+   * Uploads an image asset to the configured dataset
+   *
+   * @param assetType - Asset type (image)
+   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
+   * @param options - Options to use for the upload
+   */
+  upload(
+    assetType: 'image',
+    body: UploadBody,
+    options?: UploadClientConfig,
+  ): Promise<SanityImageAssetDocument>
+  /**
+   * Uploads a file or an image asset to the configured dataset
+   *
+   * @param assetType - Asset type (file/image)
+   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
+   * @param options - Options to use for the upload
+   */
+  upload(
+    assetType: 'file' | 'image',
+    body: UploadBody,
+    options?: UploadClientConfig,
+  ): Promise<SanityAssetDocument | SanityImageAssetDocument>
+}
+
+/** @internal */
+declare type AttributeSet = {
+  [key: string]: Any
+}
+
+/**
+ * A component that handles authentication flow and error boundaries for a
+ * protected section of the application.
+ *
+ * @remarks
+ * This component manages different authentication states and renders the
+ * appropriate components based on that state.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <AuthBoundary header={<MyLogo />}>
+ *       <ProtectedContent />
+ *     </AuthBoundary>
+ *   )
+ * }
+ * ```
+ *
+ * @internal
+ */
+export declare function AuthBoundary({
+  LoginErrorComponent,
+  ...props
+}: AuthBoundaryProps): React.ReactNode
+
+/**
+ * @internal
+ */
+declare interface AuthBoundaryProps extends LoginLayoutProps {
+  /**
+   * Custom component to render the login screen.
+   * Receives all login layout props. Defaults to {@link Login}.
+   */
+  LoginComponent?: React.ComponentType<LoginLayoutProps>
+  /**
+   * Custom component to render during OAuth callback processing.
+   * Receives all login layout props. Defaults to {@link LoginCallback}.
+   */
+  CallbackComponent?: React.ComponentType<LoginLayoutProps>
+  /**
+   * Custom component to render when authentication errors occur.
+   * Receives login layout props and error boundary props. Defaults to
+   * {@link LoginError}
+   */
+  LoginErrorComponent?: React.ComponentType<LoginErrorProps>
+}
+
+/** @internal */
+declare type BaseActionOptions = RequestOptions & {
+  transactionId?: string
+  skipCrossDatasetReferenceValidation?: boolean
+  dryRun?: boolean
+}
+
+/** @internal */
+declare type BaseMutationOptions = RequestOptions & {
+  visibility?: 'sync' | 'async' | 'deferred'
+  returnDocuments?: boolean
+  returnFirst?: boolean
+  dryRun?: boolean
+  autoGenerateArrayKeys?: boolean
+  skipCrossDatasetReferenceValidation?: boolean
+  transactionId?: string
+}
+
+/** @internal */
+declare class BasePatch {
+  protected selection: PatchSelection
+  protected operations: PatchOperations
+  constructor(selection: PatchSelection, operations?: PatchOperations)
+  /**
+   * Sets the given attributes to the document. Does NOT merge objects.
+   * The operation is added to the current patch, ready to be commited by `commit()`
+   *
+   * @param attrs - Attributes to set. To set a deep attribute, use JSONMatch, eg: \{"nested.prop": "value"\}
+   */
+  set(attrs: AttributeSet): this
+  /**
+   * Sets the given attributes to the document if they are not currently set. Does NOT merge objects.
+   * The operation is added to the current patch, ready to be commited by `commit()`
+   *
+   * @param attrs - Attributes to set. To set a deep attribute, use JSONMatch, eg: \{"nested.prop": "value"\}
+   */
+  setIfMissing(attrs: AttributeSet): this
+  /**
+   * Performs a "diff-match-patch" operation on the string attributes provided.
+   * The operation is added to the current patch, ready to be commited by `commit()`
+   *
+   * @param attrs - Attributes to perform operation on. To set a deep attribute, use JSONMatch, eg: \{"nested.prop": "dmp"\}
+   */
+  diffMatchPatch(attrs: AttributeSet): this
+  /**
+   * Unsets the attribute paths provided.
+   * The operation is added to the current patch, ready to be commited by `commit()`
+   *
+   * @param attrs - Attribute paths to unset.
+   */
+  unset(attrs: string[]): this
+  /**
+   * Increment a numeric value. Each entry in the argument is either an attribute or a JSON path. The value may be a positive or negative integer or floating-point value. The operation will fail if target value is not a numeric value, or doesn't exist.
+   *
+   * @param attrs - Object of attribute paths to increment, values representing the number to increment by.
+   */
+  inc(attrs: {[key: string]: number}): this
+  /**
+   * Decrement a numeric value. Each entry in the argument is either an attribute or a JSON path. The value may be a positive or negative integer or floating-point value. The operation will fail if target value is not a numeric value, or doesn't exist.
+   *
+   * @param attrs - Object of attribute paths to decrement, values representing the number to decrement by.
+   */
+  dec(attrs: {[key: string]: number}): this
+  /**
+   * Provides methods for modifying arrays, by inserting, appending and replacing elements via a JSONPath expression.
+   *
+   * @param at - Location to insert at, relative to the given selector, or 'replace' the matched path
+   * @param selector - JSONPath expression, eg `comments[-1]` or `blocks[_key=="abc123"]`
+   * @param items - Array of items to insert/replace
+   */
+  insert(at: 'before' | 'after' | 'replace', selector: string, items: Any[]): this
+  /**
+   * Append the given items to the array at the given JSONPath
+   *
+   * @param selector - Attribute/path to append to, eg `comments` or `person.hobbies`
+   * @param items - Array of items to append to the array
+   */
+  append(selector: string, items: Any[]): this
+  /**
+   * Prepend the given items to the array at the given JSONPath
+   *
+   * @param selector - Attribute/path to prepend to, eg `comments` or `person.hobbies`
+   * @param items - Array of items to prepend to the array
+   */
+  prepend(selector: string, items: Any[]): this
+  /**
+   * Change the contents of an array by removing existing elements and/or adding new elements.
+   *
+   * @param selector - Attribute or JSONPath expression for array
+   * @param start - Index at which to start changing the array (with origin 0). If greater than the length of the array, actual starting index will be set to the length of the array. If negative, will begin that many elements from the end of the array (with origin -1) and will be set to 0 if absolute value is greater than the length of the array.x
+   * @param deleteCount - An integer indicating the number of old array elements to remove.
+   * @param items - The elements to add to the array, beginning at the start index. If you don't specify any elements, splice() will only remove elements from the array.
+   */
+  splice(selector: string, start: number, deleteCount?: number, items?: Any[]): this
+  /**
+   * Adds a revision clause, preventing the document from being patched if the `_rev` property does not match the given value
+   *
+   * @param rev - Revision to lock the patch to
+   */
+  ifRevisionId(rev: string): this
+  /**
+   * Return a plain JSON representation of the patch
+   */
+  serialize(): PatchMutationOperation
+  /**
+   * Return a plain JSON representation of the patch
+   */
+  toJSON(): PatchMutationOperation
+  /**
+   * Clears the patch of all operations
+   */
+  reset(): this
+  protected _assign(op: keyof PatchOperations, props: Any, merge?: boolean): this
+  protected _set(op: keyof PatchOperations, props: Any): this
+}
+
+/** @internal */
+declare class BaseTransaction {
+  protected operations: Mutation[]
+  protected trxId?: string
+  constructor(operations?: Mutation[], transactionId?: string)
+  /**
+   * Creates a new Sanity document. If `_id` is provided and already exists, the mutation will fail. If no `_id` is given, one will automatically be generated by the database.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param doc - Document to create. Requires a `_type` property.
+   */
+  create<R extends Record<string, Any> = Record<string, Any>>(doc: SanityDocumentStub<R>): this
+  /**
+   * Creates a new Sanity document. If a document with the same `_id` already exists, the create operation will be ignored.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param doc - Document to create if it does not already exist. Requires `_id` and `_type` properties.
+   */
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    doc: IdentifiedSanityDocumentStub<R>,
+  ): this
+  /**
+   * Creates a new Sanity document, or replaces an existing one if the same `_id` is already used.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param doc - Document to create or replace. Requires `_id` and `_type` properties.
+   */
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    doc: IdentifiedSanityDocumentStub<R>,
+  ): this
+  /**
+   * Deletes the document with the given document ID
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param documentId - Document ID to delete
+   */
+  delete(documentId: string): this
+  /**
+   * Gets the current transaction ID, if any
+   */
+  transactionId(): string | undefined
+  /**
+   * Set the ID of this transaction.
+   *
+   * @param id - Transaction ID
+   */
+  transactionId(id: string): this
+  /**
+   * Return a plain JSON representation of the transaction
+   */
+  serialize(): Mutation[]
+  /**
+   * Return a plain JSON representation of the transaction
+   */
+  toJSON(): Mutation[]
+  /**
+   * Clears the transaction of all operations
+   */
+  reset(): this
+  protected _add(mut: Mutation): this
+}
+
+/**
+ * An error occurred. This is different from a network-level error (which will be emitted as 'error').
+ * Possible causes are things such as malformed filters, non-existant datasets or similar.
+ *
+ * @public
+ */
+declare type ChannelErrorEvent = {
+  type: 'channelError'
+  message: string
+}
+
+/** @public */
+declare interface ClientConfig {
+  projectId?: string
+  dataset?: string
+  /** @defaultValue true */
+  useCdn?: boolean
+  token?: string
+  /**
+   * What perspective to use for the client. See {@link https://www.sanity.io/docs/perspectives|perspective documentation}
+   * @remarks
+   * As of API version `v2025-02-19`, the default perspective has changed from `raw` to `published`. {@link https://www.sanity.io/changelog/676aaa9d-2da6-44fb-abe5-580f28047c10|Changelog}
+   * @defaultValue 'published'
+   */
+  perspective?: ClientPerspective
+  apiHost?: string
+  /**
+     @remarks
+     * As of API version `v2025-02-19`, the default perspective has changed from `raw` to `published`. {@link https://www.sanity.io/changelog/676aaa9d-2da6-44fb-abe5-580f28047c10|Changelog}
+     */
+  apiVersion?: string
+  proxy?: string
+  /**
+   * Optional request tag prefix for all request tags
+   */
+  requestTagPrefix?: string
+  ignoreBrowserTokenWarning?: boolean
+  withCredentials?: boolean
+  allowReconfigure?: boolean
+  timeout?: number
+  /** Number of retries for requests. Defaults to 5. */
+  maxRetries?: number
+  /**
+   * The amount of time, in milliseconds, to wait before retrying, given an attemptNumber (starting at 0).
+   *
+   * Defaults to exponential back-off, starting at 100ms, doubling for each attempt, together with random
+   * jitter between 0 and 100 milliseconds. More specifically the following algorithm is used:
+   *
+   *   Delay = 100 * 2^attemptNumber + randomNumberBetween0and100
+   */
+  retryDelay?: (attemptNumber: number) => number
+  /**
+   * @deprecated Don't use
+   */
+  useProjectHostname?: boolean
+  /**
+   * @deprecated Don't use
+   */
+  requester?: Requester
+  /**
+   * Adds a `resultSourceMap` key to the API response, with the type `ContentSourceMap`
+   */
+  resultSourceMap?: boolean | 'withKeyArraySelector'
+  /**
+   *@deprecated set `cache` and `next` options on `client.fetch` instead
+   */
+  fetch?:
+    | {
+        cache?: ResponseQueryOptions['cache']
+        next?: ResponseQueryOptions['next']
+      }
+    | boolean
+  /**
+   * Options for how, if enabled, Content Source Maps are encoded into query results using steganography
+   */
+  stega?: StegaConfig | boolean
+}
+
+/** @public */
+declare type ClientPerspective =
+  | DeprecatedPreviewDrafts
+  | 'published'
+  | 'drafts'
+  | 'raw'
+  | StackablePerspective[]
+
+/** @public */
+declare type ClientReturn<
+  GroqString extends string,
+  Fallback = Any,
+> = GroqString extends keyof SanityQueries ? SanityQueries[GroqString] : Fallback
+
+/**
+ * @public
+ */
+export declare type ComlinkStatus = 'idle' | 'handshaking' | 'connected' | 'disconnected'
+
+/** @public */
+declare interface ContentSourceMap {
+  mappings: ContentSourceMapMappings
+  documents: ContentSourceMapDocuments_2
+  paths: ContentSourceMapPaths
+}
+
+/** @public */
+declare interface ContentSourceMapDocument extends ContentSourceMapDocumentBase {
+  _projectId?: undefined
+  _dataset?: undefined
+}
+
+/** @public */
+declare interface ContentSourceMapDocument_2 extends ContentSourceMapDocumentBase_2 {
+  _projectId?: undefined
+  _dataset?: undefined
+}
+
+/** @public */
+declare interface ContentSourceMapDocumentBase {
+  _id: string
+  _type: string
+}
+
+/** @public */
+declare interface ContentSourceMapDocumentBase_2 {
+  _id: string
+  _type: string
+}
+
+/** @public */
+declare type ContentSourceMapDocuments = (
+  | ContentSourceMapDocument
+  | ContentSourceMapRemoteDocument
+)[]
+
+/** @public */
+declare type ContentSourceMapDocuments_2 = (
+  | ContentSourceMapDocument_2
+  | ContentSourceMapRemoteDocument_2
+)[]
+
+/**
+ * DocumentValueSource is a path to a value within a document
+ * @public
+ */
+declare interface ContentSourceMapDocumentValueSource {
+  type: 'documentValue'
+  document: number
+  path: number
+}
+
+/**
+ * When a value is not from a source, its a literal
+ * @public
+ */
+declare interface ContentSourceMapLiteralSource {
+  type: 'literal'
+}
+
+/** @public */
+declare type ContentSourceMapMapping = ContentSourceMapValueMapping
+
+/** @public */
+declare type ContentSourceMapMappings = Record<string, ContentSourceMapMapping>
+
+/** @alpha */
+declare type ContentSourceMapParsedPath = (
+  | string
+  | number
+  | ContentSourceMapParsedPathKeyedSegment
+)[]
+
+/** @alpha */
+declare type ContentSourceMapParsedPathKeyedSegment = {
+  _key: string
+  _index: number
+}
+
+/** @public */
+declare type ContentSourceMapPaths = string[]
+
+/** @public */
+declare interface ContentSourceMapRemoteDocument extends ContentSourceMapDocumentBase {
+  _projectId: string
+  _dataset: string
+}
+
+/** @public */
+declare interface ContentSourceMapRemoteDocument_2 extends ContentSourceMapDocumentBase_2 {
+  _projectId: string
+  _dataset: string
+}
+
+/** @public */
+declare type ContentSourceMapSource =
+  | ContentSourceMapDocumentValueSource
+  | ContentSourceMapLiteralSource
+  | ContentSourceMapUnknownSource
+
+/**
+ * When a field source is unknown
+ * @public
+ */
+declare interface ContentSourceMapUnknownSource {
+  type: 'unknown'
+}
+
+/**
+ * ValueMapping is a mapping when for value that is from a single source value
+ * It may refer to a field within a document or a literal value
+ * @public
+ */
+declare interface ContentSourceMapValueMapping {
+  type: 'value'
+  source: ContentSourceMapSource
+}
+
+/**
+ * Creates a new draft document. The published version of the document must not already exist.
+ * If the draft version of the document already exists the action will fail by default, but
+ * this can be adjusted to instead leave the existing document in place.
+ *
+ * @public
+ */
+declare type CreateAction = {
+  actionType: 'sanity.action.document.create'
+  /**
+   * ID of the published document to create a draft for.
+   */
+  publishedId: string
+  /**
+   * Document to create. Requires a `_type` property.
+   */
+  attributes: IdentifiedSanityDocumentStub
+  /**
+   * ifExists controls what to do if the draft already exists
+   */
+  ifExists: 'fail' | 'ignore'
+}
+
+/** @public */
+declare interface CurrentSanityUser {
+  id: string
+  name: string
+  email: string
+  profileImage: string | null
+  role: string
+}
+
+export {CurrentUser}
+
+/** @public */
+declare type DatasetAclMode = 'public' | 'private' | 'custom'
+
+/** @public */
+declare type DatasetResponse = {
+  datasetName: string
+  aclMode: DatasetAclMode
+}
+
+/** @internal */
+declare class DatasetsClient {
+  #private
+  constructor(client: SanityClient, httpRequest: HttpRequest)
+  /**
+   * Create a new dataset with the given name
+   *
+   * @param name - Name of the dataset to create
+   * @param options - Options for the dataset
+   */
+  create(
+    name: string,
+    options?: {
+      aclMode?: DatasetAclMode
+    },
+  ): Promise<DatasetResponse>
+  /**
+   * Edit a dataset with the given name
+   *
+   * @param name - Name of the dataset to edit
+   * @param options - New options for the dataset
+   */
+  edit(
+    name: string,
+    options?: {
+      aclMode?: DatasetAclMode
+    },
+  ): Promise<DatasetResponse>
+  /**
+   * Delete a dataset with the given name
+   *
+   * @param name - Name of the dataset to delete
+   */
+  delete(name: string): Promise<{
+    deleted: true
+  }>
+  /**
+   * Fetch a list of datasets for the configured project
+   */
+  list(): Promise<DatasetsResponse>
+}
+
+/** @public */
+export declare type DatasetsResponse = {
+  name: string
+  aclMode: DatasetAclMode
+  createdAt: string
+  createdByUserId: string
+  addonFor: string | null
+  datasetProfile: string
+  features: string[]
+  tags: string[]
+}[]
+
+/**
+ * Deletes the published version of a document and optionally some (likely all known) draft versions.
+ * If any draft version exists that is not specified for deletion this is an error.
+ * If the purge flag is set then the document history is also deleted.
+ *
+ * @public
+ */
+declare type DeleteAction = {
+  actionType: 'sanity.action.document.delete'
+  /**
+   * Published document ID to delete
+   */
+  publishedId: string
+  /**
+   * Draft document ID to delete
+   */
+  includeDrafts: string[]
+  /**
+   * Delete document history
+   */
+  purge?: boolean
+}
+
+/**
+ * @deprecated use 'drafts' instead
+ */
+declare type DeprecatedPreviewDrafts = 'previewDrafts'
+
+/**
+ * Delete the draft version of a document.
+ * It is an error if it does not exist. If the purge flag is set, the document history is also deleted.
+ *
+ * @public
+ */
+declare type DiscardAction = {
+  actionType: 'sanity.action.document.discard'
+  /**
+   * Draft document ID to delete
+   */
+  draftId: string
+  /**
+   * Delete document history
+   */
+  purge?: boolean
+}
+
+/**
+ * The listener has been told to explicitly disconnect and not reconnect.
+ * This is a rare situation, but may occur if the API knows reconnect attempts will fail,
+ * eg in the case of a deleted dataset, a blocked project or similar events.
+ *
+ * Note that this is not treated as an error on the observable, but will complete the observable.
+ *
+ * @public
+ */
+declare type DisconnectEvent = {
+  type: 'disconnect'
+  reason: string
+}
+
+export {DocumentHandle}
+
+declare interface DocumentInteractionHistory {
+  recordEvent: (eventType: 'viewed' | 'edited' | 'created' | 'deleted') => void
+  isConnected: boolean
+}
+
+/**
+ * Configuration options for the useDocuments hook
+ *
+ * @beta
+ * @category Types
+ */
+export declare interface DocumentsOptions extends QueryOptions {
+  /**
+   * GROQ filter expression to apply to the query
+   */
+  filter?: string
+  /**
+   * Number of items to load per batch (defaults to 25)
+   */
+  batchSize?: number
+  /**
+   * Sorting configuration for the results
+   */
+  orderings?: SortOrderingItem[]
+  /**
+   * Text search query to filter results
+   */
+  search?: string
+}
+
+/**
+ * Return value from the useDocuments hook
+ *
+ * @beta
+ * @category Types
+ */
+export declare interface DocumentsResponse {
+  /**
+   * Array of document handles for the current batch
+   */
+  data: DocumentHandle[]
+  /**
+   * Whether there are more items available to load
+   */
+  hasMore: boolean
+  /**
+   * Total count of items matching the query
+   */
+  count: number
+  /**
+   * Whether a query is currently in progress
+   */
+  isPending: boolean
+  /**
+   * Function to load the next batch of results
+   */
+  loadMore: () => void
+}
+
+/**
+ * Modifies an existing draft document.
+ * It applies the given patch to the document referenced by draftId.
+ * If there is no such document then one is created using the current state of the published version and then that is updated accordingly.
+ *
+ * @public
+ */
+declare type EditAction = {
+  actionType: 'sanity.action.document.edit'
+  /**
+   * Draft document ID to edit
+   */
+  draftId: string
+  /**
+   * Published document ID to create draft from, if draft does not exist
+   */
+  publishedId: string
+  /**
+   * Patch operations to apply
+   */
+  patch: PatchOperations
+}
+
+/** @public */
+declare type FilterDefault = (props: {
+  /**
+   * The path to the value in the source document, for example if you queried for a document like this:
+   * `*[_type == "author"][0]{"slug": slug.current}`
+   * Then the `sourcePath` for `result.slug` would be `['slug', 'current']`.
+   *
+   */
+  sourcePath: ContentSourceMapParsedPath
+  /**
+   * If `sourcePath` alone isn't enough to tell you if it's safe to contain stega strings, then you can use `sourceDocument`
+   * for additional metadata.
+   * It'll always have a `_type` property, which can be used to trace it to the Studio Schema that were used initially.
+   * It also has `_id` to help you debug and look at the whole document when troubleshooting.
+   * Finally, if the document origins in a Cross Dataset Reference you'll also have `_projectId` and `_dataset` properties to help you trace it.
+   */
+  sourceDocument: ContentSourceMapDocuments[number]
+  /**
+   * If you don't colocate your Studio Schemas with your GROQ queries it might be hard to make sense of `sourcePath`,
+   * as it operates on the original shape of a document.
+   * In that case `resultPath` can be used, as it mirrors the path to the value in the result.
+   * For example in a query like this:
+   * `*[_type == "author"][0]{"slug": slug.current}`
+   * The `resultPath` for `result.slug` would be `['slug']`, while `sourcePath` will be `['slug', 'current']`.
+   */
+  resultPath: ContentSourceMapParsedPath
+  /**
+   * You can also use your own string validation logic to determine if it's safe.
+   */
+  value: string
+  /**
+     * If you want to keep the default filtering behavior, but only override it for a specific path, you can use `filterDefault` to do that.
+     * For example, here all "icon" documents in a Page Builder skips encoding:
+     * ```ts
+     {
+     filter: (props) => {
+     switch (props.sourceDocument._type) {
+     case 'icon':
+     return false
+     default:
+     return props.filterDefault(props)
+     }
+     }
+     }
+     * ```
+     */
+  filterDefault: FilterDefault
+}) => boolean
+
+/** @public */
+declare interface FilteredResponseQueryOptions extends ResponseQueryOptions {
+  filterResponse?: true
+}
+
+/** @internal */
+declare type FirstDocumentIdMutationOptions = BaseMutationOptions & {
+  returnFirst?: true
+  returnDocuments: false
+}
+
+/** @internal */
+declare type FirstDocumentMutationOptions = BaseMutationOptions & {
+  returnFirst?: true
+  returnDocuments?: true
+}
+
+/**
+ * @internal
+ */
+export declare interface FrameConnection<TFrameMessage extends FrameMessage> {
+  connect: (frameWindow: Window) => () => void
+  sendMessage: <T extends TFrameMessage['type']>(
+    ...params: Extract<
+      TFrameMessage,
+      {
+        type: T
+      }
+    >['data'] extends undefined
+      ? [type: T]
+      : [
+          type: T,
+          data: Extract<
+            TFrameMessage,
+            {
+              type: T
+            }
+          >['data'],
+        ]
+  ) => void
+}
+
+/** @public */
+declare type HttpRequest = {
+  (options: RequestOptions, requester: Requester): ReturnType<Requester>
+}
+
+/** @public */
+declare type HttpRequestEvent<T = unknown> = ResponseEvent<T> | ProgressEvent_2
+
+/** @public */
+declare type IdentifiedSanityDocumentStub<T extends Record<string, Any> = Record<string, Any>> = {
+  [P in keyof T]: T[P]
+} & {
+  _id: string
+} & SanityDocumentStub
+
+/** @public */
+declare interface InitializedClientConfig extends ClientConfig {
+  apiHost: string
+  apiVersion: string
+  useProjectHostname: boolean
+  useCdn: boolean
+  /**
+   * @deprecated Internal, don't use
+   */
+  isDefaultApi: boolean
+  /**
+   * @deprecated Internal, don't use
+   */
+  url: string
+  /**
+   * @deprecated Internal, don't use
+   */
+  cdnUrl: string
+  /**
+   * The fully initialized stega config, can be used to check if stega is enabled
+   */
+  stega: InitializedStegaConfig
+}
+
+/** @public */
+declare type InitializedStegaConfig = Omit<StegaConfig, StegaConfigRequiredKeys> &
+  Required<Pick<StegaConfig, StegaConfigRequiredKeys>>
+
+/** @internal */
+declare type InsertPatch =
+  | {
+      before: string
+      items: Any[]
+    }
+  | {
+      after: string
+      items: Any[]
+    }
+  | {
+      replace: string
+      items: Any[]
+    }
+
+/**
+ * Set up a listener that will be notified when mutations occur on documents matching the provided query/filter.
+ *
+ * @param query - GROQ-filter to listen to changes for
+ * @param params - Optional query parameters
+ * @param options - Optional listener options
+ * @public
+ */
+declare function _listen<R extends Record<string, Any> = Record<string, Any>>(
+  this: SanityClient | ObservableSanityClient,
+  query: string,
+  params?: ListenParams,
+): 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
+ */
+declare function _listen<R extends Record<string, Any> = Record<string, Any>>(
+  this: SanityClient | ObservableSanityClient,
+  query: string,
+  params?: ListenParams,
+  options?: ListenOptions,
+): Observable<ListenEvent<R>>
+
+/** @public */
+declare type ListenEvent<R extends Record<string, Any>> =
+  | MutationEvent_2<R>
+  | ChannelErrorEvent
+  | DisconnectEvent
+  | ReconnectEvent
+  | WelcomeEvent
+  | OpenEvent
+
+/** @public */
+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 */
+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 mutations that was performed.
+   * If you do not need the mutations, set this to `false` to reduce bandwidth usage.
+   * @defaultValue `true`
+   */
+  includeMutations?: 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 to include events for drafts and versions. As of API Version >= v2025-02-19, only events
+   * for published documents will be included by default (see {@link https://www.sanity.io/changelog/676aaa9d-2da6-44fb-abe5-580f28047c10|Changelog})
+   * If you need events from drafts and versions, set this to `true`.
+   * Note: Keep in mind that additional document variants may be introduced in the future, so it's
+   * recommended to respond to events in a way that's tolerant of potential future variants, e.g. by
+   * explicitly checking whether the event is for a draft or a version.
+   * @defaultValue `false`
+   */
+  includeAllVersions?: boolean
+  /**
+   * Whether events should be sent as soon as a transaction has been committed (`transaction`, default),
+   * 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`
+   */
+  tag?: string
+}
+
+/** @public */
+declare type ListenParams = {
+  [key: string]: Any
+}
+
+/**
+ * @public
+ */
+declare class LiveClient {
+  #private
+  constructor(client: SanityClient | ObservableSanityClient)
+  /**
+   * Requires `apiVersion` to be `2021-03-25` or later.
+   */
+  events({
+    includeDrafts,
+    tag: _tag,
+  }?: {
+    includeDrafts?: boolean
+    /**
+     * Optional request tag for the listener. Use to identify the request in logs.
+     *
+     * @defaultValue `undefined`
+     */
+    tag?: string
+  }): Observable<LiveEvent>
+}
+
+/** @public */
+declare type LiveEvent = LiveEventRestart | LiveEventReconnect | LiveEventMessage | LiveEventWelcome
+
+/** @public */
+declare interface LiveEventMessage {
+  type: 'message'
+  id: string
+  tags: SyncTag[]
+}
+
+/** @public */
+declare interface LiveEventReconnect {
+  type: 'reconnect'
+}
+
+/** @public */
+declare interface LiveEventRestart {
+  type: 'restart'
+  id: string
+}
+
+/** @public */
+declare interface LiveEventWelcome {
+  type: 'welcome'
+}
+
+/** @public */
+declare type Logger =
+  | typeof console
+  | Partial<
+      Pick<typeof console, 'debug' | 'error' | 'groupCollapsed' | 'groupEnd' | 'log' | 'table'>
+    >
+
+/**
+ * @alpha
+ */
+declare type LoginErrorProps = FallbackProps & LoginLayoutProps
+
+/**
+ * @alpha
+ */
+declare interface LoginLayoutProps {
+  /** Optional header content rendered at top of card */
+  header?: React.ReactNode
+  /** Optional footer content rendered below card. Defaults to an internal login footer */
+  footer?: React.ReactNode
+  /** Main content rendered in card body */
+  children?: React.ReactNode
+}
+
+declare interface ManageFavorite {
+  favorite: () => void
+  unfavorite: () => void
+  isFavorited: boolean
+  isConnected: boolean
+}
+
+/**
+ * @public
+ */
+declare type MessageData = Record<string, unknown> | undefined
+
+/**
+ * @internal
+ */
+export declare type MessageHandler<TWindowMessage extends WindowMessage> = (
+  event: TWindowMessage['data'],
+) => TWindowMessage['response'] | Promise<TWindowMessage['response']>
+
+/** @internal */
+declare interface MultipleActionResult {
+  transactionId: string
+}
+
+/** @internal */
+declare interface MultipleMutationResult {
+  transactionId: string
+  documentIds: string[]
+  results: {
+    id: string
+    operation: MutationOperation
+  }[]
+}
+
+/** @public */
+declare type Mutation<R extends Record<string, Any> = Record<string, Any>> =
+  | {
+      create: SanityDocumentStub<R>
+    }
+  | {
+      createOrReplace: IdentifiedSanityDocumentStub<R>
+    }
+  | {
+      createIfNotExists: IdentifiedSanityDocumentStub<R>
+    }
+  | {
+      delete: MutationSelection
+    }
+  | {
+      patch: PatchMutationOperation
+    }
+
+/**
+ * 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_2<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_2<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.
+   *
+   * - `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.
+   */
+  transition: 'update' | 'appear' | 'disappear'
+  /**
+   * 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.
+   *
+   * 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.
+   */
+  transactionTotalEvents: number
+  /**
+   * 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
+}
+
+/** @internal */
+declare type MutationOperation = 'create' | 'delete' | 'update' | 'none'
+
+/** @internal */
+declare type MutationSelection =
+  | {
+      query: string
+      params?: MutationSelectionQueryParams
+    }
+  | {
+      id: string | string[]
+    }
+
+/** @internal */
+declare type MutationSelectionQueryParams = {
+  [key: string]: Any
+}
+
+declare interface NavigateToStudioResult {
+  navigateToStudioDocument: () => void
+  isConnected: boolean
+}
+
+/** @internal */
+declare class ObservableAssetsClient {
+  #private
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
+  /**
+   * Uploads a file asset to the configured dataset
+   *
+   * @param assetType - Asset type (file)
+   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
+   * @param options - Options to use for the upload
+   */
+  upload(
+    assetType: 'file',
+    body: UploadBody,
+    options?: UploadClientConfig,
+  ): Observable<
+    HttpRequestEvent<{
+      document: SanityAssetDocument
+    }>
+  >
+  /**
+   * Uploads an image asset to the configured dataset
+   *
+   * @param assetType - Asset type (image)
+   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
+   * @param options - Options to use for the upload
+   */
+  upload(
+    assetType: 'image',
+    body: UploadBody,
+    options?: UploadClientConfig,
+  ): Observable<
+    HttpRequestEvent<{
+      document: SanityImageAssetDocument
+    }>
+  >
+  /**
+   * Uploads a file or an image asset to the configured dataset
+   *
+   * @param assetType - Asset type (file/image)
+   * @param body - Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
+   * @param options - Options to use for the upload
+   */
+  upload(
+    assetType: 'file' | 'image',
+    body: UploadBody,
+    options?: UploadClientConfig,
+  ): Observable<
+    HttpRequestEvent<{
+      document: SanityAssetDocument | SanityImageAssetDocument
+    }>
+  >
+}
+
+/** @internal */
+declare class ObservableDatasetsClient {
+  #private
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
+  /**
+   * Create a new dataset with the given name
+   *
+   * @param name - Name of the dataset to create
+   * @param options - Options for the dataset
+   */
+  create(
+    name: string,
+    options?: {
+      aclMode?: DatasetAclMode
+    },
+  ): Observable<DatasetResponse>
+  /**
+   * Edit a dataset with the given name
+   *
+   * @param name - Name of the dataset to edit
+   * @param options - New options for the dataset
+   */
+  edit(
+    name: string,
+    options?: {
+      aclMode?: DatasetAclMode
+    },
+  ): Observable<DatasetResponse>
+  /**
+   * Delete a dataset with the given name
+   *
+   * @param name - Name of the dataset to delete
+   */
+  delete(name: string): Observable<{
+    deleted: true
+  }>
+  /**
+   * Fetch a list of datasets for the configured project
+   */
+  list(): Observable<DatasetsResponse>
+}
+
+/** @public */
+declare class ObservablePatch extends BasePatch {
+  #private
+  constructor(
+    selection: PatchSelection,
+    operations?: PatchOperations,
+    client?: ObservableSanityClient,
+  )
+  /**
+   * Clones the patch
+   */
+  clone(): ObservablePatch
+  /**
+   * Commit the patch, returning an observable that produces the first patched document
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, Any> = Record<string, Any>>(
+    options: FirstDocumentMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Commit the patch, returning an observable that produces an array of the mutated documents
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, Any> = Record<string, Any>>(
+    options: AllDocumentsMutationOptions,
+  ): Observable<SanityDocument_2<R>[]>
+  /**
+   * Commit the patch, returning an observable that produces a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: FirstDocumentIdMutationOptions): Observable<SingleMutationResult>
+  /**
+   * Commit the patch, returning an observable that produces a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: AllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
+  /**
+   * Commit the patch, returning an observable that produces the first patched document
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, Any> = Record<string, Any>>(
+    options?: BaseMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+}
+
+/** @public */
+declare type ObservablePatchBuilder = (patch: ObservablePatch) => ObservablePatch
+
+/** @internal */
+declare class ObservableProjectsClient {
+  #private
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
+  /**
+   * Fetch a list of projects the authenticated user has access to.
+   *
+   * @param options - Options for the list request
+   * @param options.includeMembers - Whether to include members in the response (default: true)
+   */
+  list(options?: {includeMembers?: true}): Observable<SanityProject[]>
+  list(options?: {includeMembers?: false}): Observable<Omit<SanityProject, 'members'>[]>
+  /**
+   * Fetch a project by project ID
+   *
+   * @param projectId - ID of the project to fetch
+   */
+  getById(projectId: string): Observable<SanityProject>
+}
+
+/** @public */
+declare class ObservableSanityClient {
+  #private
+  assets: ObservableAssetsClient
+  datasets: ObservableDatasetsClient
+  live: LiveClient
+  projects: ObservableProjectsClient
+  users: ObservableUsersClient
+  /**
+   * Instance properties
+   */
+  listen: typeof _listen
+  constructor(httpRequest: HttpRequest, config?: ClientConfig)
+  /**
+   * Clone the client - returns a new instance
+   */
+  clone(): ObservableSanityClient
+  /**
+   * Returns the current client configuration
+   */
+  config(): InitializedClientConfig
+  /**
+   * Reconfigure the client. Note that this _mutates_ the current client.
+   */
+  config(newConfig?: Partial<ClientConfig>): this
+  /**
+   * Clone the client with a new (partial) configuration.
+   *
+   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
+   */
+  withConfig(newConfig?: Partial<ClientConfig>): ObservableSanityClient
+  /**
+   * Perform a GROQ-query against the configured dataset.
+   *
+   * @param query - GROQ-query to perform
+   */
+  fetch<
+    R = Any,
+    Q extends QueryWithoutParams = QueryWithoutParams,
+    const G extends string = string,
+  >(query: G, params?: Q | QueryWithoutParams): Observable<ClientReturn<G, R>>
+  /**
+   * Perform a GROQ-query against the configured dataset.
+   *
+   * @param query - GROQ-query to perform
+   * @param params - Optional query parameters
+   * @param options - Optional request options
+   */
+  fetch<
+    R = Any,
+    Q extends QueryWithoutParams | QueryParams = QueryParams,
+    const G extends string = string,
+  >(
+    query: G,
+    params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
+    options?: FilteredResponseQueryOptions,
+  ): Observable<ClientReturn<G, R>>
+  /**
+   * Perform a GROQ-query against the configured dataset.
+   *
+   * @param query - GROQ-query to perform
+   * @param params - Optional query parameters
+   * @param options - Request options
+   */
+  fetch<
+    R = Any,
+    Q extends QueryWithoutParams | QueryParams = QueryParams,
+    const G extends string = string,
+  >(
+    query: string,
+    params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
+    options: UnfilteredResponseQueryOptions,
+  ): Observable<RawQueryResponse<ClientReturn<G, R>>>
+  /**
+   * Perform a GROQ-query against the configured dataset.
+   *
+   * @param query - GROQ-query to perform
+   * @param params - Optional query parameters
+   * @param options - Request options
+   */
+  fetch<
+    R = Any,
+    Q extends QueryWithoutParams | QueryParams = QueryParams,
+    const G extends string = string,
+  >(
+    query: G,
+    params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
+    options: UnfilteredResponseWithoutQuery,
+  ): Observable<RawQuerylessQueryResponse<ClientReturn<G, R>>>
+  /**
+   * Fetch a single document with the given ID.
+   *
+   * @param id - Document ID to fetch
+   * @param options - Request options
+   */
+  getDocument<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options?: {
+      tag?: string
+    },
+  ): Observable<SanityDocument_2<R> | undefined>
+  /**
+   * Fetch multiple documents in one request.
+   * Should be used sparingly - performing a query is usually a better option.
+   * The order/position of documents is preserved based on the original array of IDs.
+   * If any of the documents are missing, they will be replaced by a `null` entry in the returned array
+   *
+   * @param ids - Document IDs to fetch
+   * @param options - Request options
+   */
+  getDocuments<R extends Record<string, Any> = Record<string, Any>>(
+    ids: string[],
+    options?: {
+      tag?: string
+    },
+  ): Observable<(SanityDocument_2<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_2<R>>
+  /**
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns an observable that resolves to an array containing the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options: AllDocumentsMutationOptions,
+  ): Observable<SanityDocument_2<R>[]>
+  /**
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options: FirstDocumentIdMutationOptions,
+  ): Observable<SingleMutationResult>
+  /**
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options: AllDocumentIdsMutationOptions,
+  ): Observable<MultipleMutationResult>
+  /**
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns an observable that resolves to the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options?: BaseMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Create a document if no document with the same ID already exists.
+   * Returns an observable that resolves to the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Create a document if no document with the same ID already exists.
+   * Returns an observable that resolves to an array containing the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentsMutationOptions,
+  ): Observable<SanityDocument_2<R>[]>
+  /**
+   * Create a document if no document with the same ID already exists.
+   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentIdMutationOptions,
+  ): Observable<SingleMutationResult>
+  /**
+   * Create a document if no document with the same ID already exists.
+   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentIdsMutationOptions,
+  ): Observable<MultipleMutationResult>
+  /**
+   * Create a document if no document with the same ID already exists.
+   * Returns an observable that resolves to the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options?: BaseMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns an observable that resolves to the created document.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
+   */
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns an observable that resolves to an array containing the created document.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
+   */
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentsMutationOptions,
+  ): Observable<SanityDocument_2<R>[]>
+  /**
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns an observable that resolves to a mutation result object containing the ID of the created document.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
+   */
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentIdMutationOptions,
+  ): Observable<SingleMutationResult>
+  /**
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns an observable that resolves to a mutation result object containing the created document ID.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
+   */
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentIdsMutationOptions,
+  ): Observable<MultipleMutationResult>
+  /**
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns an observable that resolves to the created document.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
+   */
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options?: BaseMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Deletes a document with the given document ID.
+   * Returns an observable that resolves to the deleted document.
+   *
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
+   */
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options: FirstDocumentMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Deletes a document with the given document ID.
+   * Returns an observable that resolves to an array containing the deleted document.
+   *
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
+   */
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options: AllDocumentsMutationOptions,
+  ): Observable<SanityDocument_2<R>[]>
+  /**
+   * Deletes a document with the given document ID.
+   * Returns an observable that resolves to a mutation result object containing the deleted document ID.
+   *
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
+   */
+  delete(id: string, options: FirstDocumentIdMutationOptions): Observable<SingleMutationResult>
+  /**
+   * Deletes a document with the given document ID.
+   * Returns an observable that resolves to a mutation result object containing the deleted document ID.
+   *
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
+   */
+  delete(id: string, options: AllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
+  /**
+   * Deletes a document with the given document ID.
+   * Returns an observable that resolves to the deleted document.
+   *
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
+   */
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options?: BaseMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns an observable that resolves to first deleted document.
+   *
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
+   */
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    selection: MutationSelection,
+    options: FirstDocumentMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns an observable that resolves to an array containing the deleted documents.
+   *
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
+   */
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    selection: MutationSelection,
+    options: AllDocumentsMutationOptions,
+  ): Observable<SanityDocument_2<R>[]>
+  /**
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns an observable that resolves to a mutation result object containing the ID of the first deleted document.
+   *
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
+   */
+  delete(
+    selection: MutationSelection,
+    options: FirstDocumentIdMutationOptions,
+  ): Observable<SingleMutationResult>
+  /**
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns an observable that resolves to a mutation result object containing the document IDs that were deleted.
+   *
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
+   */
+  delete(
+    selection: MutationSelection,
+    options: AllDocumentIdsMutationOptions,
+  ): Observable<MultipleMutationResult>
+  /**
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns an observable that resolves to first deleted document.
+   *
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
+   */
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    selection: MutationSelection,
+    options?: BaseMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Perform mutation operations against the configured dataset
+   * Returns an observable that resolves to the first mutated document.
+   *
+   * @param operations - Mutation operations to execute
+   * @param options - Mutation options
+   */
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
+    options: FirstDocumentMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Perform mutation operations against the configured dataset.
+   * Returns an observable that resolves to an array of the mutated documents.
+   *
+   * @param operations - Mutation operations to execute
+   * @param options - Mutation options
+   */
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
+    options: AllDocumentsMutationOptions,
+  ): Observable<SanityDocument_2<R>[]>
+  /**
+   * Perform mutation operations against the configured dataset
+   * Returns an observable that resolves to a mutation result object containing the document ID of the first mutated document.
+   *
+   * @param operations - Mutation operations to execute
+   * @param options - Mutation options
+   */
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
+    options: FirstDocumentIdMutationOptions,
+  ): Observable<SingleMutationResult>
+  /**
+   * Perform mutation operations against the configured dataset
+   * Returns an observable that resolves to a mutation result object containing the mutated document IDs.
+   *
+   * @param operations - Mutation operations to execute
+   * @param options - Mutation options
+   */
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
+    options: AllDocumentIdsMutationOptions,
+  ): Observable<MultipleMutationResult>
+  /**
+   * Perform mutation operations against the configured dataset
+   * Returns an observable that resolves to the first mutated document.
+   *
+   * @param operations - Mutation operations to execute
+   * @param options - Mutation options
+   */
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
+    options?: BaseMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Create a new buildable patch of operations to perform
+   *
+   * @param documentId - Document ID to patch
+   * @param operations - Optional object of patch operations to initialize the patch instance with
+   * @returns Patch instance - call `.commit()` to perform the operations defined
+   */
+  patch(documentId: string, operations?: PatchOperations): ObservablePatch
+  /**
+   * Create a new buildable patch of operations to perform
+   *
+   * @param documentIds - Array of document IDs to patch
+   * @param operations - Optional object of patch operations to initialize the patch instance with
+   * @returns Patch instance - call `.commit()` to perform the operations defined
+   */
+  patch(documentIds: string[], operations?: PatchOperations): ObservablePatch
+  /**
+   * Create a new buildable patch of operations to perform
+   *
+   * @param selection - An object with `query` and optional `params`, defining which document(s) to patch
+   * @param operations - Optional object of patch operations to initialize the patch instance with
+   * @returns Patch instance - call `.commit()` to perform the operations defined
+   */
+  patch(selection: MutationSelection, operations?: PatchOperations): ObservablePatch
+  /**
+   * Create a new transaction of mutations
+   *
+   * @param operations - Optional array of mutation operations to initialize the transaction instance with
+   */
+  transaction<R extends Record<string, Any> = Record<string, Any>>(
+    operations?: Mutation<R>[],
+  ): ObservableTransaction
+  /**
+   * Perform action operations against the configured dataset
+   *
+   * @param operations - Action operation(s) to execute
+   * @param options - Action options
+   */
+  action(
+    operations: Action | Action[],
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
+  /**
+   * Perform an HTTP request against the Sanity API
+   *
+   * @param options - Request options
+   */
+  request<R = Any>(options: RawRequestOptions): Observable<R>
+  /**
+   * Get a Sanity API URL for the URI provided
+   *
+   * @param uri - URI/path to build URL for
+   * @param canUseCdn - Whether or not to allow using the API CDN for this route
+   */
+  getUrl(uri: string, canUseCdn?: boolean): string
+  /**
+   * Get a Sanity API URL for the data operation and path provided
+   *
+   * @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
+   * @param path - Path to append after the operation
+   */
+  getDataUrl(operation: string, path?: string): string
+}
+
+/** @public */
+declare class ObservableTransaction extends BaseTransaction {
+  #private
+  constructor(operations?: Mutation[], client?: ObservableSanityClient, transactionId?: string)
+  /**
+   * Clones the transaction
+   */
+  clone(): ObservableTransaction
+  /**
+   * Commit the transaction, returning an observable that produces the first mutated document
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, Any>>(
+    options: TransactionFirstDocumentMutationOptions,
+  ): Observable<SanityDocument_2<R>>
+  /**
+   * Commit the transaction, returning an observable that produces an array of the mutated documents
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, Any>>(
+    options: TransactionAllDocumentsMutationOptions,
+  ): Observable<SanityDocument_2<R>[]>
+  /**
+   * Commit the transaction, returning an observable that produces a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: TransactionFirstDocumentIdMutationOptions): Observable<SingleMutationResult>
+  /**
+   * Commit the transaction, returning an observable that produces a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: TransactionAllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
+  /**
+   * Commit the transaction, returning an observable that produces a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options?: BaseMutationOptions): Observable<MultipleMutationResult>
+  /**
+   * Performs a patch on the given document ID. Can either be a builder function or an object of patch operations.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param documentId - Document ID to perform the patch operation on
+   * @param patchOps - Operations to perform, or a builder function
+   */
+  patch(documentId: string, patchOps?: ObservablePatchBuilder | PatchOperations): this
+  /**
+   * Adds the given patch instance to the transaction.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param patch - ObservablePatch to execute
+   */
+  patch(patch: ObservablePatch): this
+}
+
+/** @public */
+declare class ObservableUsersClient {
+  #private
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest)
+  /**
+   * Fetch a user by user ID
+   *
+   * @param id - User ID of the user to fetch. If `me` is provided, a minimal response including the users role is returned.
+   */
+  getById<T extends 'me' | string>(
+    id: T,
+  ): Observable<T extends 'me' ? CurrentSanityUser : SanityUser>
+}
+
+/**
+ * The listener connection has been established
+ * note: it's usually a better option to use the 'welcome' event
+ * @public
+ */
+declare type OpenEvent = {
+  type: 'open'
+}
+
+/**
+ * Configuration options for the usePaginatedDocuments hook
+ *
+ * @beta
+ * @category Types
+ */
+export declare interface PaginatedDocumentsOptions extends QueryOptions {
+  /**
+   * GROQ filter expression to apply to the query
+   */
+  filter?: string
+  /**
+   * Number of items to display per page (defaults to 25)
+   */
+  pageSize?: number
+  /**
+   * Sorting configuration for the results
+   */
+  orderings?: SortOrderingItem[]
+  /**
+   * Text search query to filter results
+   */
+  search?: string
+}
+
+/**
+ * Return value from the usePaginatedDocuments hook
+ *
+ * @beta
+ * @category Types
+ */
+export declare interface PaginatedDocumentsResponse {
+  /**
+   * Array of document handles for the current page
+   */
+  data: DocumentHandle[]
+  /**
+   * Whether a query is currently in progress
+   */
+  isPending: boolean
+  /**
+   * Number of items displayed per page
+   */
+  pageSize: number
+  /**
+   * Current page number (1-indexed)
+   */
+  currentPage: number
+  /**
+   * Total number of pages available
+   */
+  totalPages: number
+  /**
+   * Starting index of the current page (0-indexed)
+   */
+  startIndex: number
+  /**
+   * Ending index of the current page (exclusive, 0-indexed)
+   */
+  endIndex: number
+  /**
+   * Total count of items matching the query
+   */
+  count: number
+  /**
+   * Navigate to the first page
+   */
+  firstPage: () => void
+  /**
+   * Whether there is a first page available to navigate to
+   */
+  hasFirstPage: boolean
+  /**
+   * Navigate to the previous page
+   */
+  previousPage: () => void
+  /**
+   * Whether there is a previous page available to navigate to
+   */
+  hasPreviousPage: boolean
+  /**
+   * Navigate to the next page
+   */
+  nextPage: () => void
+  /**
+   * Whether there is a next page available to navigate to
+   */
+  hasNextPage: boolean
+  /**
+   * Navigate to the last page
+   */
+  lastPage: () => void
+  /**
+   * Whether there is a last page available to navigate to
+   */
+  hasLastPage: boolean
+  /**
+   * Navigate to a specific page number
+   * @param pageNumber - The page number to navigate to (1-indexed)
+   */
+  goToPage: (pageNumber: number) => void
+}
+
+/** @public */
+declare class Patch extends BasePatch {
+  #private
+  constructor(selection: PatchSelection, operations?: PatchOperations, client?: SanityClient)
+  /**
+   * Clones the patch
+   */
+  clone(): Patch
+  /**
+   * Commit the patch, returning a promise that resolves to the first patched document
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, Any> = Record<string, Any>>(
+    options: FirstDocumentMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+  /**
+   * Commit the patch, returning a promise that resolves to an array of the mutated documents
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, Any> = Record<string, Any>>(
+    options: AllDocumentsMutationOptions,
+  ): Promise<SanityDocument_2<R>[]>
+  /**
+   * Commit the patch, returning a promise that resolves to a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: FirstDocumentIdMutationOptions): Promise<SingleMutationResult>
+  /**
+   * Commit the patch, returning a promise that resolves to a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: AllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
+  /**
+   * Commit the patch, returning a promise that resolves to the first patched document
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, Any> = Record<string, Any>>(
+    options?: BaseMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+}
+
+/** @public */
+declare type PatchBuilder = (patch: Patch) => Patch
+
+/** @internal */
+declare type PatchMutationOperation = PatchOperations & MutationSelection
+
+/** @internal */
+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 */
+declare type PatchSelection = string | string[] | MutationSelection
+
+/** @public */
+declare interface ProgressEvent_2 {
+  type: 'progress'
+  stage: 'upload' | 'download'
+  percent: number
+  total?: number
+  loaded?: number
+  lengthComputable: boolean
+}
+
+/** @internal */
+declare class ProjectsClient {
+  #private
+  constructor(client: SanityClient, httpRequest: HttpRequest)
+  /**
+   * Fetch a list of projects the authenticated user has access to.
+   *
+   * @param options - Options for the list request
+   * @param options.includeMembers - Whether to include members in the response (default: true)
+   */
+  list(options?: {includeMembers?: true}): Promise<SanityProject[]>
+  list(options?: {includeMembers?: false}): Promise<Omit<SanityProject, 'members'>[]>
+  /**
+   * Fetch a project by project ID
+   *
+   * @param projectId - ID of the project to fetch
+   */
+  getById(projectId: string): Promise<SanityProject>
+}
+
+/**
+ * @public
+ * @category Types
+ * @interface
+ */
+export declare type ProjectWithoutMembers = Omit<SanityProject, 'members'>
+
+/**
+ * Publishes a draft document.
+ * If a published version of the document already exists this is replaced by the current draft document.
+ * In either case the draft document is deleted.
+ * The optional revision id parameters can be used for optimistic locking to ensure
+ * that the draft and/or published versions of the document have not been changed by another client.
+ *
+ * @public
+ */
+declare type PublishAction = {
+  actionType: 'sanity.action.document.publish'
+  /**
+   * Draft document ID to publish
+   */
+  draftId: string
+  /**
+   * Draft revision ID to match
+   */
+  ifDraftRevisionId?: string
+  /**
+   * Published document ID to replace
+   */
+  publishedId: string
+  /**
+   * Published revision ID to match
+   */
+  ifPublishedRevisionId?: string
+}
+
+/** @public */
+declare interface QueryParams {
+  [key: string]: any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  body?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  cache?: 'next' extends keyof RequestInit ? never : any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  filterResponse?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  headers?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  method?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  next?: 'next' extends keyof RequestInit ? never : any
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  perspective?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  query?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  resultSourceMap?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  returnQuery?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  signal?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  stega?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  tag?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  timeout?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  token?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  useCdn?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  lastLiveEventId?: never
+  /** @deprecated you're using a fetch option as a GROQ parameter, this is likely a mistake */
+  cacheMode?: never
+}
+
+/**
+ * This type can be used with `client.fetch` to indicate that the query has no GROQ parameters.
+ * @public
+ */
+declare type QueryWithoutParams = Record<string, never> | undefined
+
+/** @public */
+declare type RawQuerylessQueryResponse<R> = Omit<RawQueryResponse<R>, 'query'>
+
+/** @public */
+declare interface RawQueryResponse<R> {
+  query: string
+  ms: number
+  result: R
+  resultSourceMap?: ContentSourceMap
+  /** Requires `apiVersion` to be `2021-03-25` or later. */
+  syncTags?: SyncTag[]
+}
+
+/** @internal */
+declare interface RawRequestOptions {
+  url?: string
+  uri?: string
+  method?: string
+  token?: string
+  json?: boolean
+  tag?: string
+  useGlobalApi?: boolean
+  withCredentials?: boolean
+  query?: {
+    [key: string]: string | string[]
+  }
+  headers?: {
+    [key: string]: string
+  }
+  timeout?: number
+  proxy?: string
+  body?: Any
+  maxRedirects?: number
+  signal?: AbortSignal
+}
+
+/**
+ * This version is provided by pkg-utils at build time
+ * @internal
+ */
+export declare const REACT_SDK_VERSION: {}
+
+/**
+ * The listener has been disconnected, and a reconnect attempt is scheduled.
+ *
+ * @public
+ */
+declare type ReconnectEvent = {
+  type: 'reconnect'
+}
+
+/**
+ * Replaces an existing draft document.
+ * At least one of the draft or published versions of the document must exist.
+ *
+ * @public
+ */
+declare type ReplaceDraftAction = {
+  actionType: 'sanity.action.document.replaceDraft'
+  /**
+   * Published document ID to create draft from, if draft does not exist
+   */
+  publishedId: string
+  /**
+   * Document to create if it does not already exist. Requires `_id` and `_type` properties.
+   */
+  attributes: IdentifiedSanityDocumentStub
+}
+
+/** @public */
+declare interface RequestOptions {
+  timeout?: number
+  token?: string
+  tag?: string
+  headers?: Record<string, string>
+  method?: string
+  query?: Any
+  body?: Any
+  signal?: AbortSignal
+}
+
+/** @alpha */
+declare type ResolveStudioUrl = (sourceDocument: ContentSourceMapDocuments[number]) => StudioUrl
+
+/** @public */
+declare interface ResponseEvent<T = unknown> {
+  type: 'response'
+  body: T
+  url: string
+  method: string
+  statusCode: number
+  statusMessage?: string
+  headers: Record<string, string>
+}
+
+/** @public */
+declare interface ResponseQueryOptions extends RequestOptions {
+  perspective?: ClientPerspective
+  resultSourceMap?: boolean | 'withKeyArraySelector'
+  returnQuery?: boolean
+  useCdn?: boolean
+  stega?: boolean | StegaConfig
+  cache?: 'next' extends keyof RequestInit ? RequestInit['cache'] : never
+  next?: ('next' extends keyof RequestInit ? RequestInit : never)['next']
+  lastLiveEventId?: string | string[] | null
+  /**
+   * When set to `noStale`, APICDN will not return a cached response if the content is stale.
+   * Tradeoff between latency and freshness of content.
+   *
+   * Only to be used with live content queries and when useCdn is true.
+   */
+  cacheMode?: 'noStale'
+}
+
+/**
+ * @public
+ *
+ * The SanityApp component provides your Sanity application with access to your Sanity configuration,
+ * as well as application context and state which is used by the Sanity React hooks. Your application
+ * must be wrapped with the SanityApp component to function properly.
+ *
+ * @param props - Your Sanity configuration and the React children to render
+ * @returns Your Sanity application, integrated with your Sanity configuration and application context
+ *
+ * @example
+ * ```tsx
+ * import { SanityApp } from '@sanity/sdk-react'
+ *
+ * import MyAppRoot from './Root'
+ *
+ * // Single project configuration
+ * const mySanityConfigs = [
+ *   {
+ *     projectId: 'my-project-id',
+ *     dataset: 'production',
+ *   },
+ * ]
+ *
+ * // Or multiple project configurations
+ * const multipleConfigs = [
+ *   // Configuration for your main project. This will be used as the default project for all hooks if no resource ID override is provided.
+ *   {
+ *     projectId: 'marketing-website-project',
+ *     dataset: 'production',
+ *   },
+ *   // Configuration for a separate blog project
+ *   {
+ *     projectId: 'blog-project',
+ *     dataset: 'production',
+ *   },
+ *   // Configuration for a separate ecommerce project
+ *   {
+ *     projectId: 'ecommerce-project',
+ *     dataset: 'production',
+ *   }
+ * ]
+ *
+ * export default function MyApp() {
+ *   return (
+ *     <SanityApp sanityConfigs={mySanityConfigs}>
+ *       <MyAppRoot />
+ *     </SanityApp>
+ *   )
+ * }
+ * ```
+ */
+export declare function SanityApp({sanityConfigs, children, fallback}: SanityAppProps): ReactElement
+
+/**
+ * @public
+ */
+export declare interface SanityAppProps {
+  sanityConfigs: SanityConfig[]
+  children: React.ReactNode
+  fallback: React.ReactNode
+}
+
+/** @internal */
+declare interface SanityAssetDocument extends SanityDocument_2 {
+  url: string
+  path: string
+  size: number
+  assetId: string
+  mimeType: string
+  sha1hash: string
+  extension: string
+  uploadId?: string
+  originalFilename?: string
+}
+
+/** @public */
+declare class SanityClient {
+  #private
+  assets: AssetsClient
+  datasets: DatasetsClient
+  live: LiveClient
+  projects: ProjectsClient
+  users: UsersClient
+  /**
+   * Observable version of the Sanity client, with the same configuration as the promise-based one
+   */
+  observable: ObservableSanityClient
+  /**
+   * Instance properties
+   */
+  listen: typeof _listen
+  constructor(httpRequest: HttpRequest, config?: ClientConfig)
+  /**
+   * Clone the client - returns a new instance
+   */
+  clone(): SanityClient
+  /**
+   * Returns the current client configuration
+   */
+  config(): InitializedClientConfig
+  /**
+   * Reconfigure the client. Note that this _mutates_ the current client.
+   */
+  config(newConfig?: Partial<ClientConfig>): this
+  /**
+   * Clone the client with a new (partial) configuration.
+   *
+   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
+   */
+  withConfig(newConfig?: Partial<ClientConfig>): SanityClient
+  /**
+   * Perform a GROQ-query against the configured dataset.
+   *
+   * @param query - GROQ-query to perform
+   */
+  fetch<
+    R = Any,
+    Q extends QueryWithoutParams = QueryWithoutParams,
+    const G extends string = string,
+  >(query: G, params?: Q | QueryWithoutParams): Promise<ClientReturn<G, R>>
+  /**
+   * Perform a GROQ-query against the configured dataset.
+   *
+   * @param query - GROQ-query to perform
+   * @param params - Optional query parameters
+   * @param options - Optional request options
+   */
+  fetch<
+    R = Any,
+    Q extends QueryWithoutParams | QueryParams = QueryParams,
+    const G extends string = string,
+  >(
+    query: G,
+    params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
+    options?: FilteredResponseQueryOptions,
+  ): Promise<ClientReturn<G, R>>
+  /**
+   * Perform a GROQ-query against the configured dataset.
+   *
+   * @param query - GROQ-query to perform
+   * @param params - Optional query parameters
+   * @param options - Request options
+   */
+  fetch<
+    R = Any,
+    Q extends QueryWithoutParams | QueryParams = QueryParams,
+    const G extends string = string,
+  >(
+    query: G,
+    params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
+    options: UnfilteredResponseQueryOptions,
+  ): Promise<RawQueryResponse<ClientReturn<G, R>>>
+  /**
+   * Perform a GROQ-query against the configured dataset.
+   *
+   * @param query - GROQ-query to perform
+   * @param params - Optional query parameters
+   * @param options - Request options
+   */
+  fetch<
+    R = Any,
+    Q extends QueryWithoutParams | QueryParams = QueryParams,
+    const G extends string = string,
+  >(
+    query: G,
+    params: Q extends QueryWithoutParams ? QueryWithoutParams : Q,
+    options: UnfilteredResponseWithoutQuery,
+  ): Promise<RawQuerylessQueryResponse<ClientReturn<G, R>>>
+  /**
+   * Fetch a single document with the given ID.
+   *
+   * @param id - Document ID to fetch
+   * @param options - Request options
+   */
+  getDocument<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options?: {
+      signal?: AbortSignal
+      tag?: string
+    },
+  ): Promise<SanityDocument_2<R> | undefined>
+  /**
+   * Fetch multiple documents in one request.
+   * Should be used sparingly - performing a query is usually a better option.
+   * The order/position of documents is preserved based on the original array of IDs.
+   * If any of the documents are missing, they will be replaced by a `null` entry in the returned array
+   *
+   * @param ids - Document IDs to fetch
+   * @param options - Request options
+   */
+  getDocuments<R extends Record<string, Any> = Record<string, Any>>(
+    ids: string[],
+    options?: {
+      signal?: AbortSignal
+      tag?: string
+    },
+  ): Promise<(SanityDocument_2<R> | null)[]>
+  /**
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns a promise that resolves to the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options: FirstDocumentMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+  /**
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns a promise that resolves to an array containing the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options: AllDocumentsMutationOptions,
+  ): Promise<SanityDocument_2<R>[]>
+  /**
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options: FirstDocumentIdMutationOptions,
+  ): Promise<SingleMutationResult>
+  /**
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options: AllDocumentIdsMutationOptions,
+  ): Promise<MultipleMutationResult>
+  /**
+   * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
+   * Returns a promise that resolves to the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  create<R extends Record<string, Any> = Record<string, Any>>(
+    document: SanityDocumentStub<R>,
+    options?: BaseMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+  /**
+   * Create a document if no document with the same ID already exists.
+   * Returns a promise that resolves to the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+  /**
+   * Create a document if no document with the same ID already exists.
+   * Returns a promise that resolves to an array containing the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentsMutationOptions,
+  ): Promise<SanityDocument_2<R>[]>
+  /**
+   * Create a document if no document with the same ID already exists.
+   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentIdMutationOptions,
+  ): Promise<SingleMutationResult>
+  /**
+   * Create a document if no document with the same ID already exists.
+   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentIdsMutationOptions,
+  ): Promise<MultipleMutationResult>
+  /**
+   * Create a document if no document with the same ID already exists.
+   * Returns a promise that resolves to the created document.
+   *
+   * @param document - Document to create
+   * @param options - Mutation options
+   */
+  createIfNotExists<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options?: BaseMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+  /**
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns a promise that resolves to the created document.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
+   */
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+  /**
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns a promise that resolves to an array containing the created document.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
+   */
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentsMutationOptions,
+  ): Promise<SanityDocument_2<R>[]>
+  /**
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns a promise that resolves to a mutation result object containing the ID of the created document.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
+   */
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: FirstDocumentIdMutationOptions,
+  ): Promise<SingleMutationResult>
+  /**
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns a promise that resolves to a mutation result object containing the created document ID.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
+   */
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options: AllDocumentIdsMutationOptions,
+  ): Promise<MultipleMutationResult>
+  /**
+   * Create a document if it does not exist, or replace a document with the same document ID
+   * Returns a promise that resolves to the created document.
+   *
+   * @param document - Document to either create or replace
+   * @param options - Mutation options
+   */
+  createOrReplace<R extends Record<string, Any> = Record<string, Any>>(
+    document: IdentifiedSanityDocumentStub<R>,
+    options?: BaseMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+  /**
+   * Deletes a document with the given document ID.
+   * Returns a promise that resolves to the deleted document.
+   *
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
+   */
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options: FirstDocumentMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+  /**
+   * Deletes a document with the given document ID.
+   * Returns a promise that resolves to an array containing the deleted document.
+   *
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
+   */
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options: AllDocumentsMutationOptions,
+  ): Promise<SanityDocument_2<R>[]>
+  /**
+   * Deletes a document with the given document ID.
+   * Returns a promise that resolves to a mutation result object containing the deleted document ID.
+   *
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
+   */
+  delete(id: string, options: FirstDocumentIdMutationOptions): Promise<SingleMutationResult>
+  /**
+   * Deletes a document with the given document ID.
+   * Returns a promise that resolves to a mutation result object containing the deleted document ID.
+   *
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
+   */
+  delete(id: string, options: AllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
+  /**
+   * Deletes a document with the given document ID.
+   * Returns a promise that resolves to the deleted document.
+   *
+   * @param id - Document ID to delete
+   * @param options - Options for the mutation
+   */
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    id: string,
+    options?: BaseMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+  /**
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns a promise that resolves to first deleted document.
+   *
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
+   */
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    selection: MutationSelection,
+    options: FirstDocumentMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+  /**
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns a promise that resolves to an array containing the deleted documents.
+   *
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
+   */
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    selection: MutationSelection,
+    options: AllDocumentsMutationOptions,
+  ): Promise<SanityDocument_2<R>[]>
+  /**
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns a promise that resolves to a mutation result object containing the ID of the first deleted document.
+   *
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
+   */
+  delete(
+    selection: MutationSelection,
+    options: FirstDocumentIdMutationOptions,
+  ): Promise<SingleMutationResult>
+  /**
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns a promise that resolves to a mutation result object containing the document IDs that were deleted.
+   *
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
+   */
+  delete(
+    selection: MutationSelection,
+    options: AllDocumentIdsMutationOptions,
+  ): Promise<MultipleMutationResult>
+  /**
+   * Deletes one or more documents matching the given query or document ID.
+   * Returns a promise that resolves to first deleted document.
+   *
+   * @param selection - An object with either an `id` or `query` key defining what to delete
+   * @param options - Options for the mutation
+   */
+  delete<R extends Record<string, Any> = Record<string, Any>>(
+    selection: MutationSelection,
+    options?: BaseMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+  /**
+   * Perform mutation operations against the configured dataset
+   * Returns a promise that resolves to the first mutated document.
+   *
+   * @param operations - Mutation operations to execute
+   * @param options - Mutation options
+   */
+  mutate<R extends Record<string, Any> = Record<string, Any>>(
+    operations: Mutation<R>[] | Patch | Transaction,
+    options: FirstDocumentMutationOptions,
+  ): Promise<SanityDocument_2<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_2<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_2<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 action operations against the configured dataset
+   * Returns a promise that resolves to the transaction result
+   *
+   * @param operations - Action operation(s) to execute
+   * @param options - Action options
+   */
+  action(
+    operations: Action | Action[],
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
+  /**
+   * 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
+   *
+   * @param uri - URI/path to build URL for
+   * @param canUseCdn - Whether or not to allow using the API CDN for this route
+   */
+  getUrl(uri: string, canUseCdn?: boolean): string
+  /**
+   * Get a Sanity API URL for the data operation and path provided
+   *
+   * @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
+   * @param path - Path to append after the operation
+   */
+  getDataUrl(operation: string, path?: string): string
+}
+
+export {SanityDocument}
+
+/** @internal */
+declare type SanityDocument_2<T extends Record<string, Any> = Record<string, Any>> = {
+  [P in keyof T]: T[P]
+} & {
+  _id: string
+  _rev: string
+  _type: string
+  _createdAt: string
+  _updatedAt: string
+  /**
+   * Present when `perspective` is set to `previewDrafts`
+   */
+  _originalId?: string
+}
+
+/** @public */
+declare type SanityDocumentStub<T extends Record<string, Any> = Record<string, Any>> = {
+  [P in keyof T]: T[P]
+} & {
+  _type: string
+}
+
+/** @internal */
+declare interface SanityImageAssetDocument extends SanityAssetDocument {
+  metadata: {
+    _type: 'sanity.imageMetadata'
+    hasAlpha: boolean
+    isOpaque: boolean
+    lqip?: string
+    blurHash?: string
+    dimensions: {
+      _type: 'sanity.imageDimensions'
+      aspectRatio: number
+      height: number
+      width: number
+    }
+    palette?: {
+      _type: 'sanity.imagePalette'
+      darkMuted?: SanityImagePalette
+      darkVibrant?: SanityImagePalette
+      dominant?: SanityImagePalette
+      lightMuted?: SanityImagePalette
+      lightVibrant?: SanityImagePalette
+      muted?: SanityImagePalette
+      vibrant?: SanityImagePalette
+    }
+    image?: {
+      _type: 'sanity.imageExifTags'
+      [key: string]: Any
+    }
+    exif?: {
+      _type: 'sanity.imageExifMetadata'
+      [key: string]: Any
+    }
+  }
+}
+
+/** @internal */
+declare interface SanityImagePalette {
+  background: string
+  foreground: string
+  population: number
+  title: string
+}
+
+/** @public */
+export declare interface SanityProject {
+  id: string
+  displayName: string
+  /**
+   * @deprecated Use the `/user-applications` endpoint instead, which lists all deployed studios/applications
+   * @see https://www.sanity.io/help/studio-host-user-applications
+   */
+  studioHost: string | null
+  organizationId: string | null
+  isBlocked: boolean
+  isDisabled: boolean
+  isDisabledByUser: boolean
+  createdAt: string
+  pendingInvites?: number
+  maxRetentionDays?: number
+  members: SanityProjectMember[]
+  metadata: {
+    cliInitializedAt?: string
+    color?: string
+    /**
+     * @deprecated Use the `/user-applications` endpoint instead, which lists all deployed studios/applications
+     * @see https://www.sanity.io/help/studio-host-user-applications
+     */
+    externalStudioHost?: string
+  }
+}
+
+/** @public */
+export declare interface SanityProjectMember {
+  id: string
+  role: string
+  isRobot: boolean
+  isCurrentUser: boolean
+}
+
+/**
+ * @internal
+ *
+ * Top-level context provider that provides access to the Sanity configuration instance.
+ * This must wrap any components making use of the Sanity SDK React hooks.
+ *
+ * @remarks In most cases, SanityApp should be used rather than SanityProvider directly; SanityApp bundles both SanityProvider and an authentication layer.
+ * @param props - Sanity project and dataset configuration
+ * @returns Rendered component
+ * @example
+ * ```tsx
+ * import {createSanityInstance} from '@sanity/sdk'
+ * import {SanityProvider} from '@sanity/sdk-react'
+ *
+ * import MyAppRoot from './Root'
+ *
+ * const sanityInstance = createSanityInstance({
+ *   projectId: 'your-project-id',
+ *   dataset: 'production',
+ * })
+ *
+ * export default function MyApp() {
+ *   return (
+ *     <SanityProvider sanityInstance={sanityInstance}>
+ *       <MyAppRoot />
+ *     </SanityProvider>
+ *   )
+ * }
+ * ```
+ */
+export declare const SanityProvider: ({
+  children,
+  sanityInstances,
+}: SanityProviderProps) => ReactElement
+
+/**
+ * @internal
+ */
+export declare interface SanityProviderProps {
+  children: React.ReactNode
+  sanityInstances: SanityInstance[]
+}
+
+/** @public */
+declare interface SanityQueries {}
+
+/** @public */
+declare interface SanityUser {
+  id: string
+  projectId: string
+  displayName: string
+  familyName: string | null
+  givenName: string | null
+  middleName: string | null
+  imageUrl: string | null
+  createdAt: string
+  updatedAt: string
+  isCurrentUser: boolean
+}
+
+/**
+ * @internal
+ *
+ * Top-level context provider that provides access to the Sanity SDK.
+ */
+export declare function SDKProvider({
+  children,
+  sanityConfigs,
+  fallback,
+}: SDKProviderProps): ReactElement
+
+/**
+ * @internal
+ */
+export declare interface SDKProviderProps {
+  children: ReactNode
+  sanityConfigs: SanityConfig[]
+  fallback: ReactNode
+}
+
+/** @internal */
+declare interface SingleActionResult {
+  transactionId: string
+}
+
+/** @internal */
+declare interface SingleMutationResult {
+  transactionId: string
+  documentId: string
+  results: {
+    id: string
+    operation: MutationOperation
+  }[]
+}
+
+export {SortOrderingItem}
+
+/** @public */
+declare type StackablePerspective = ('published' | 'drafts' | string) & {}
+
+/** @public */
+declare interface StegaConfig {
+  /**
+     * Enable or disable stega encoded strings in query results
+     * ```ts
+     {
+     enabled: process.env.VERCEL_ENV !== 'production'
+     }
+     * ```
+     * @defaultValue `false`
+     */
+  enabled?: boolean
+  /**
+   * Where the Studio is hosted.
+   * If it's embedded in the app, use the base path for example `/studio`.
+   * Otherwise provide the full URL to where the Studio is hosted, for example: `https://blog.sanity.studio`.
+   *
+   */
+  studioUrl?: StudioUrl | ResolveStudioUrl
+  filter?: FilterDefault
+  /**
+   * Specify a `console.log` compatible logger to see debug logs, which keys are encoded and which are not.
+   */
+  logger?: Logger
+  /**
+   * Set to `true` to omit cross dataset reference specific data from encoded strings
+   */
+  omitCrossDatasetReferenceData?: boolean
+}
+
+/** @public */
+declare type StegaConfigRequiredKeys = Extract<keyof StegaConfig, 'enabled'>
+
+/** @alpha */
+declare type StudioBaseRoute = {
+  baseUrl: StudioBaseUrl
+  workspace?: string
+  tool?: string
+}
+
+/** @alpha */
+declare type StudioBaseUrl = `/${string}` | `${string}.sanity.studio` | `https://${string}` | string
+
+/** @alpha */
+declare type StudioUrl = StudioBaseUrl | StudioBaseRoute
+
+declare interface StudioWorkspacesResult {
+  workspacesByResourceId: WorkspacesByResourceId
+  error: string | null
+  isConnected: boolean
+}
+
+/** @public */
+declare type SyncTag = `s1:${string}`
+
+/** @public */
+declare class Transaction extends BaseTransaction {
+  #private
+  constructor(operations?: Mutation[], client?: SanityClient, transactionId?: string)
+  /**
+   * Clones the transaction
+   */
+  clone(): Transaction
+  /**
+   * Commit the transaction, returning a promise that resolves to the first mutated document
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, Any>>(
+    options: TransactionFirstDocumentMutationOptions,
+  ): Promise<SanityDocument_2<R>>
+  /**
+   * Commit the transaction, returning a promise that resolves to an array of the mutated documents
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, Any>>(
+    options: TransactionAllDocumentsMutationOptions,
+  ): Promise<SanityDocument_2<R>[]>
+  /**
+   * Commit the transaction, returning a promise that resolves to a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: TransactionFirstDocumentIdMutationOptions): Promise<SingleMutationResult>
+  /**
+   * Commit the transaction, returning a promise that resolves to a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: TransactionAllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
+  /**
+   * Commit the transaction, returning a promise that resolves to a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options?: BaseMutationOptions): Promise<MultipleMutationResult>
+  /**
+   * Performs a patch on the given document ID. Can either be a builder function or an object of patch operations.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param documentId - Document ID to perform the patch operation on
+   * @param patchOps - Operations to perform, or a builder function
+   */
+  patch(documentId: string, patchOps?: PatchBuilder | PatchOperations): this
+  /**
+   * Performs a patch on the given selection. Can either be a builder function or an object of patch operations.
+   *
+   * @param selection - An object with `query` and optional `params`, defining which document(s) to patch
+   * @param patchOps - Operations to perform, or a builder function
+   */
+  patch(patch: MutationSelection, patchOps?: PatchBuilder | PatchOperations): this
+  /**
+   * Adds the given patch instance to the transaction.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param patch - Patch to execute
+   */
+  patch(patch: Patch): this
+}
+
+/** @internal */
+declare type TransactionAllDocumentIdsMutationOptions = BaseMutationOptions & {
+  returnFirst?: false
+  returnDocuments?: false
+}
+
+/** @internal */
+declare type TransactionAllDocumentsMutationOptions = BaseMutationOptions & {
+  returnFirst?: false
+  returnDocuments: true
+}
+
+/** @internal */
+declare type TransactionFirstDocumentIdMutationOptions = BaseMutationOptions & {
+  returnFirst: true
+  returnDocuments?: false
+}
+
+/** @internal */
+declare type TransactionFirstDocumentMutationOptions = BaseMutationOptions & {
+  returnFirst: true
+  returnDocuments: true
+}
+
+/** @public */
+declare interface UnfilteredResponseQueryOptions extends ResponseQueryOptions {
+  filterResponse: false
+  /**
+   * When `filterResponse` is `false`, `returnQuery` also defaults to `true` for
+   * backwards compatibility (on the client side, not from the content lake API).
+   * Can also explicitly be set to `true`.
+   */
+  returnQuery?: true
+}
+
+/**
+ * When using `filterResponse: false`, but you do not wish to receive back the query from
+ * the content lake API.
+ *
+ * @public
+ */
+declare interface UnfilteredResponseWithoutQuery extends ResponseQueryOptions {
+  filterResponse: false
+  returnQuery: false
+}
+
+/**
+ * Retract a published document.
+ * If there is no draft version then this is created from the published version.
+ * In either case the published version is deleted.
+ *
+ * @public
+ */
+declare type UnpublishAction = {
+  actionType: 'sanity.action.document.unpublish'
+  /**
+   * Draft document ID to replace the published document with
+   */
+  draftId: string
+  /**
+   * Published document ID to delete
+   */
+  publishedId: string
+}
+
+declare type Updater<TValue> = TValue | ((nextValue: TValue) => TValue)
+
+/** @public */
+declare type UploadBody = File | Blob | Buffer | NodeJS.ReadableStream
+
+/** @public */
+declare interface UploadClientConfig {
+  /**
+   * Optional request tag for the upload
+   */
+  tag?: string
+  /**
+   * Whether or not to preserve the original filename (default: true)
+   */
+  preserveFilename?: boolean
+  /**
+   * Filename for this file (optional)
+   */
+  filename?: string
+  /**
+   * Milliseconds to wait before timing the request out
+   */
+  timeout?: number
+  /**
+   * Mime type of the file
+   */
+  contentType?: string
+  /**
+   * Array of metadata parts to extract from asset
+   */
+  extract?: AssetMetadataType[]
+  /**
+   * Optional freeform label for the asset. Generally not used.
+   */
+  label?: string
+  /**
+   * Optional title for the asset
+   */
+  title?: string
+  /**
+   * Optional description for the asset
+   */
+  description?: string
+  /**
+   * The credit to person(s) and/or organization(s) required by the supplier of the asset to be used when published
+   */
+  creditLine?: string
+  /**
+   * Source data (when the asset is from an external service)
+   */
+  source?: {
+    /**
+     * The (u)id of the asset within the source, i.e. 'i-f323r1E'
+     */
+    id: string
+    /**
+     * The name of the source, i.e. 'unsplash'
+     */
+    name: string
+    /**
+     * A url to where to find the asset, or get more info about it in the source
+     */
+    url?: string
+  }
+}
+
+/**
+ *
+ * @beta
+ *
+ * Provides a callback for applying one or more actions to a document.
+ *
+ * @category Documents
+ * @param resourceId - The resource ID of the document to apply actions to. If not provided, the document will use the default resource.
+ * @returns A function that takes one more more {@link DocumentAction}s and returns a promise that resolves to an {@link ActionsResult}.
+ * @example Publish or unpublish a document
+ * ```
+ * import { publishDocument, unpublishDocument } from '@sanity/sdk'
+ * import { useApplyDocumentActions } from '@sanity/sdk-react'
+ *
+ * const apply = useApplyDocumentActions()
+ * const myDocument = { _id: 'my-document-id', _type: 'my-document-type' }
+ *
+ * return (
+ *   <button onClick={() => apply(publishDocument(myDocument))}>Publish</button>
+ *   <button onClick={() => apply(unpublishDocument(myDocument))}>Unpublish</button>
+ * )
+ * ```
+ *
+ * @example Create and publish a new document
+ * ```
+ * import { createDocument, publishDocument } from '@sanity/sdk'
+ * import { useApplyDocumentActions } from '@sanity/sdk-react'
+ *
+ * const apply = useApplyDocumentActions()
+ *
+ * const handleCreateAndPublish = () => {
+ *   const handle = { _id: window.crypto.randomUUID(), _type: 'my-document-type' }
+ *   apply([
+ *     createDocument(handle),
+ *     publishDocument(handle),
+ *   ])
+ * }
+ *
+ * return (
+ *   <button onClick={handleCreateAndPublish}>
+ *     I’m feeling lucky
+ *   </button>
+ * )
+ * ```
+ */
+export declare function useApplyDocumentActions(
+  resourceId?: ResourceId,
+): <TDocument extends SanityDocument>(
+  action: DocumentAction<TDocument> | DocumentAction<TDocument>[],
+  options?: ApplyDocumentActionsOptions,
+) => Promise<ActionsResult<TDocument>>
+
+/**
+ * @internal
+ * A React hook that subscribes to authentication state changes.
+ *
+ * This hook provides access to the current authentication state type from the Sanity auth store.
+ * It automatically re-renders when the authentication state changes.
+ *
+ * @remarks
+ * The hook uses `useSyncExternalStore` to safely subscribe to auth state changes
+ * and ensure consistency between server and client rendering.
+ *
+ * @returns The current authentication state type
+ *
+ * @example
+ * ```tsx
+ * function AuthStatus() {
+ *   const authState = useAuthState()
+ *   return <div>Current auth state: {authState}</div>
+ * }
+ * ```
+ */
+export declare const useAuthState: () => AuthState
+
+/**
+ * Hook to get the currently logged in user
+ * @internal
+ * @returns The current user or null if not authenticated
+ */
+export declare const useAuthToken: () => string | null
+
+/**
+ * A React hook that provides a client that subscribes to changes in your application,
+ * such as user authentication changes.
+ *
+ * @remarks
+ * The hook uses `useSyncExternalStore` to safely subscribe to changes
+ * and ensure consistency between server and client rendering.
+ *
+ * @category Platform
+ * @returns A Sanity client
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const client = useClient({apiVersion: '2024-11-12'})
+ *   const [document, setDocument] = useState(null)
+ *   useEffect(async () => {
+ *     const doc = client.fetch('*[_id == "myDocumentId"]')
+ *     setDocument(doc)
+ *   }, [])
+ *  return <div>{JSON.stringify(document) ?? 'Loading...'}</div>
+ * }
+ * ```
+ *
+ * @public
+ * @function
+ */
+export declare const useClient: (e: ClientOptions) => SanityClient
+
+declare type UseCurrentUser = {
+  /**
+   * @public
+   *
+   * Provides the currently authenticated user’s profile information.
+   *
+   * @category Users
+   * @returns The current user data
+   *
+   * @example Rendering a basic user profile
+   * ```
+   * const user = useCurrentUser()
+   *
+   * return (
+   *   <figure>
+   *     <img src={user?.profileImage} alt=`Profile image for ${user?.name}` />
+   *     <h2>{user?.name}</h2>
+   *   </figure>
+   * )
+   * ```
+   */
+  (): CurrentUser | null
+}
+
+/**
+ * @public
+ * @function
+ * @TODO This should not return null — users of a custom app will always be authenticated via Core
+ */
+export declare const useCurrentUser: UseCurrentUser
+
+/**
+ * @remarks
+ * A React hook that retrieves the dashboard organization ID that is currently selected in the Sanity Dashboard.
+ *
+ * @example
+ * ```tsx
+ * function DashboardComponent() {
+ *   const orgId = useDashboardOrganizationId()
+ *
+ *   if (!orgId) return null
+ *
+ *   return <div>Organization ID: {String(orgId)}</div>
+ * }
+ * ```
+ *
+ * @returns The dashboard organization ID (string | undefined)
+ * @public
+ */
+export declare function useDashboardOrganizationId(): string | undefined
+
+declare type UseDatasets = {
+  /**
+   *
+   * Returns metadata for each dataset the current user has access to.
+   *
+   * @category Datasets
+   * @returns The metadata for your the datasets
+   *
+   * @example
+   * ```tsx
+   * const datasets = useDatasets()
+   *
+   * return (
+   *   <select>
+   *     {datasets.map((dataset) => (
+   *       <option key={dataset.name}>{dataset.name}</option>
+   *     ))}
+   *   </select>
+   * )
+   * ```
+   *
+   */
+  (): DatasetsResponse
+}
+
+/**
+ * @public
+ * @function
+ */
+export declare const useDatasets: UseDatasets
+
+/**
+ * @beta
+ *
+ * ## useDocument(doc, path)
+ * Read and subscribe to nested values in a document
+ * @category Documents
+ * @param doc - The document to read state from. If you pass a `DocumentHandle` with a `resourceId` in the DocumentResourceId format (`document:projectId.dataset:documentId`)
+ * the document will be read from the specified Sanity project and dataset that is included in the handle. If no `resourceId` is provided, the default project and dataset from your `SanityApp` configuration will be used.
+ * @param path - The path to the nested value to read from
+ * @returns The value at the specified path
+ * @example
+ * ```tsx
+ * import {type DocumentHandle, useDocument} from '@sanity/sdk-react'
+ *
+ * function OrderLink({documentHandle}: {documentHandle: DocumentHandle}) {
+ *   const title = useDocument(documentHandle, 'title')
+ *   const id = useDocument(documentHandle, '_id')
+ *
+ *   return (
+ *     <a href=`/order/${id}`>Order {title} today!</a>
+ *   )
+ * }
+ * ```
+ *
+ */
+export declare function useDocument<
+  TDocument extends SanityDocument,
+  TPath extends JsonMatchPath<TDocument>,
+>(doc: DocumentHandle<TDocument>, path: TPath): JsonMatch<TDocument, TPath> | undefined
+
+/**
+ * @beta
+ * ## useDocument(doc)
+ * Read and subscribe to an entire document
+ * @param doc - The document to read state from
+ * @returns The document state as an object
+ * @example
+ * ```tsx
+ * import {type SanityDocument, type DocumentHandle, useDocument} from '@sanity/sdk-react'
+ *
+ * interface Book extends SanityDocument {
+ *   title: string
+ *   author: string
+ *   summary: string
+ * }
+ *
+ * function DocumentView({documentHandle}: {documentHandle: DocumentHandle}) {
+ *   const book = useDocument<Book>(documentHandle)
+ *
+ *   return (
+ *     <article>
+ *       <h1>{book?.title}</h1>
+ *       <address>By {book?.author}</address>
+ *
+ *       <h2>Summary</h2>
+ *       {book?.summary}
+ *
+ *       <h2>Order</h2>
+ *       <a href=`/order/${book._id}`>Order {book?.title} today!</a>
+ *     </article>
+ *   )
+ * }
+ * ```
+ *
+ */
+export declare function useDocument<TDocument extends SanityDocument>(
+  doc: DocumentHandle<TDocument>,
+): TDocument | null
+
+/**
+ *
+ * @beta
+ *
+ * Subscribes an event handler to events in your application’s document store, such as document
+ * creation, deletion, and updates.
+ *
+ * @category Documents
+ * @param handler - The event handler to register.
+ * @param doc - The document to subscribe to events for. If you pass a `DocumentHandle` with a `resourceId` (in the format of `document:projectId.dataset:documentId`)
+ * the document will be read from the specified Sanity project and dataset that is included in the handle. If no `resourceId` is provided, the default project and dataset from your `SanityApp` configuration will be used.
+ * @example
+ * ```
+ * import {useDocumentEvent} from '@sanity/sdk-react'
+ * import {type DocumentEvent} from '@sanity/sdk'
+ *
+ * useDocumentEvent((event) => {
+ *   if (event.type === DocumentEvent.DocumentDeletedEvent) {
+ *     alert(`Document with ID ${event.documentId} deleted!`)
+ *   } else {
+ *     console.log(event)
+ *   }
+ * })
+ * ```
+ */
+export declare function useDocumentEvent(
+  handler: (documentEvent: DocumentEvent) => void,
+  doc: DocumentHandle,
+): void
+
+/**
+ *
+ * @beta
+ *
+ * Check if the current user has the specified permissions for the given document actions.
+ *
+ * @category Permissions
+ * @param actions - One more more calls to a particular document action function for a given document
+ * @returns An object that specifies whether the action is allowed; if the action is not allowed, an explanatory message and list of reasons is also provided.
+ *
+ * @example Checking for permission to publish a document
+ * ```ts
+ * import {useDocumentPermissions, useApplyDocumentActions} from '@sanity/sdk-react'
+ * import {publishDocument} from '@sanity/sdk'
+ *
+ * export function PublishButton({doc}: {doc: DocumentHandle}) {
+ *   const publishPermissions = useDocumentPermissions(publishDocument(doc))
+ *   const applyAction = useApplyDocumentActions()
+ *
+ *   return (
+ *     <>
+ *       <button
+ *         disabled={!publishPermissions.allowed}
+ *         onClick={() => applyAction(publishDocument(doc))}
+ *         popoverTarget={`${publishPermissions.allowed ? undefined : 'publishButtonPopover'}`}
+ *       >
+ *         Publish
+ *       </button>
+ *       {!publishPermissions.allowed && (
+ *         <div popover id="publishButtonPopover">
+ *           {publishPermissions.message}
+ *         </div>
+ *       )}
+ *     </>
+ *   )
+ * }
+ * ```
+ */
+export declare function useDocumentPermissions(
+  actions: DocumentAction | DocumentAction[],
+): DocumentPermissionsResult
+
+/**
+ * Retrieves batches of {@link DocumentHandle}s, narrowed by optional filters, text searches, and custom ordering,
+ * with infinite scrolling support. The number of document handles returned per batch is customizable,
+ * and additional batches can be loaded using the supplied `loadMore` function.
+ *
+ * @beta
+ * @category Documents
+ * @param options - Configuration options for the infinite list
+ * @returns An object containing the list of document handles, the loading state, the total count of retrieved document handles, and a function to load more
+ * @example
+ * ```tsx
+ * const {data, hasMore, isPending, loadMore} = useDocuments({
+ *   filter: '_type == "post"',
+ *   search: searchTerm,
+ *   batchSize: 10,
+ *   orderings: [{field: '_createdAt', direction: 'desc'}]
+ * })
+ *
+ * return (
+ *   <div>
+ *     Total documents: {count}
+ *     <ol>
+ *       {data.map((doc) => (
+ *         <li key={doc._id}>
+ *           <MyDocumentComponent doc={doc} />
+ *         </li>
+ *       ))}
+ *     </ol>
+ *     {hasMore && <button onClick={loadMore}>Load More</button>}
+ *   </div>
+ * )
+ * ```
+ *
+ */
+export declare function useDocuments({
+  batchSize,
+  params,
+  search,
+  filter,
+  orderings,
+  ...options
+}: DocumentsOptions): DocumentsResponse
+
+declare type UseDocumentSyncStatus = {
+  /**
+   * Exposes the document’s sync status between local and remote document states.
+   *
+   * @category Documents
+   * @param doc - The document handle to get sync status for. If you pass a `DocumentHandle` with a `resourceId` (in the format of `document:projectId.dataset:documentId`)
+   * the document will be read from the specified Sanity project and dataset that is included in the handle. If no `resourceId` is provided, the default project and dataset from your `SanityApp` configuration will be used.
+   * @returns `true` if local changes are synced with remote, `false` if the changes are not synced, and `undefined` if the document is not found
+   * @example Disable a Save button when there are no changes to sync
+   * ```
+   * const myDocumentHandle = { _id: 'documentId', _type: 'documentType', resourceId: 'document:projectId:dataset:documentId' }
+   * const documentSynced = useDocumentSyncStatus(myDocumentHandle)
+   *
+   * return (
+   *   <button disabled={documentSynced}>
+   *     Save Changes
+   *   </button>
+   * )
+   * ```
+   */
+  (doc: DocumentHandle): boolean | undefined
+}
+
+/**
+ * @beta
+ * @function
+ */
+export declare const useDocumentSyncStatus: UseDocumentSyncStatus
+
+/**
+ *
+ * @beta
+ *
+ * ## useEditDocument(doc, path)
+ * Edit a nested value within a document
+ *
+ * @category Documents
+ * @param doc - The document to be edited; either as a document handle or the document’s ID a string
+ * @param path - The path to the nested value to be edited
+ * @returns A function to update the nested value. Accepts either a new value, or an updater function that exposes the previous value and returns a new value.
+ * @example Update a document’s name by providing the new value directly
+ * ```
+ * const handle = { _id: 'documentId', _type: 'documentType' }
+ * const name = useDocument(handle, 'name')
+ * const editName = useEditDocument(handle, 'name')
+ *
+ * function handleNameChange(event: React.ChangeEvent<HTMLInputElement>) {
+ *   editName(event.target.value)
+ * }
+ *
+ * return (
+ *   <input type='text' value={name} onChange={handleNameChange} />
+ * )
+ * ```
+ *
+ * @example Update a count on a document by providing an updater function
+ * ```
+ * const handle = { _id: 'documentId', _type: 'documentType' }
+ * const count = useDocument(handle, 'count')
+ * const editCount = useEditDocument(handle, 'count')
+ *
+ * function incrementCount() {
+ *   editCount(previousCount => previousCount + 1)
+ * }
+ *
+ * return (
+ *   <>
+ *     <button onClick={incrementCount}>
+ *       Increment
+ *     </button>
+ *     Current count: {count}
+ *   </>
+ * )
+ * ```
+ */
+export declare function useEditDocument<
+  TDocument extends SanityDocument,
+  TPath extends JsonMatchPath<TDocument>,
+>(
+  doc: DocumentHandle<TDocument>,
+  path: TPath,
+): (nextValue: Updater<JsonMatch<TDocument, TPath>>) => Promise<ActionsResult<TDocument>>
+
+/**
+ *
+ * @beta
+ *
+ * ## useEditDocument(doc)
+ * Edit an entire document
+ * @param doc - The document to be edited; either as a document handle or the document’s ID a string. If you pass a `DocumentHandle` with a `resourceId` (in the format of `document:projectId.dataset:documentId`)
+ * the document will be read from the specified Sanity project and dataset that is included in the handle. If no `resourceId` is provided, the default project and dataset from your `SanityApp` configuration will be used.
+ * @returns A function to update the document state. Accepts either a new document state, or an updater function that exposes the previous document state and returns the new document state.
+ * @example
+ * ```
+ * const myDocumentHandle = { _id: 'documentId', _type: 'documentType' }
+ *
+ * const myDocument = useDocument(myDocumentHandle)
+ * const { title, price } = myDocument
+ *
+ * const editMyDocument = useEditDocument(myDocumentHandle)
+ *
+ * function handleFieldChange(e: React.ChangeEvent<HTMLInputElement>) {
+ *   const {name, value} = e.currentTarget
+ *   // Use an updater function to update the document state based on the previous state
+ *   editMyDocument(previousDocument => ({
+ *     ...previousDocument,
+ *     [name]: value
+ *   }))
+ * }
+ *
+ * function handleSaleChange(e: React.ChangeEvent<HTMLInputElement>) {
+ *   const { checked } = e.currentTarget
+ *   if (checked) {
+ *     // Use an updater function to add a new salePrice field;
+ *     // set it at a 20% discount off the normal price
+ *     editMyDocument(previousDocument => ({
+ *       ...previousDocument,
+ *       salePrice: previousDocument.price * 0.8,
+ *     }))
+ *   } else {
+ *     // Get the document state without the salePrice field
+ *     const { salePrice, ...rest } = myDocument
+ *     // Update the document state to remove the salePrice field
+ *     editMyDocument(rest)
+ *   }
+ * }
+ *
+ * return (
+ *   <>
+ *     <form onSubmit={e => e.preventDefault()}>
+ *       <input name='title' type='text' value={title} onChange={handleFieldChange} />
+ *       <input name='price' type='number' value={price} onChange={handleFieldChange} />
+ *       <input
+ *         name='salePrice'
+ *         type='checkbox'
+ *         checked={Object(myDocument).hasOwnProperty('salePrice')}
+ *         onChange={handleSaleChange}
+ *       />
+ *     </form>
+ *     <pre><code>
+ *       {JSON.stringify(myDocument, null, 2)}
+ *     </code></pre>
+ *   </>
+ * )
+ * ```
+ */
+export declare function useEditDocument<TDocument extends SanityDocument>(
+  doc: DocumentHandle<TDocument>,
+): (nextValue: Updater<TDocument>) => Promise<ActionsResult<TDocument>>
+
+/**
+ * @internal
+ */
+export declare function useFrameConnection<
+  TFrameMessage extends FrameMessage,
+  TWindowMessage extends WindowMessage,
+>(options: UseFrameConnectionOptions<TWindowMessage>): FrameConnection<TFrameMessage>
+
+/**
+ * @internal
+ */
+export declare interface UseFrameConnectionOptions<TWindowMessage extends WindowMessage> {
+  name: string
+  connectTo: string
+  targetOrigin: string
+  onMessage?: {
+    [K in TWindowMessage['type']]: (
+      data: Extract<
+        TWindowMessage,
+        {
+          type: K
+        }
+      >['data'],
+    ) => void
+  }
+  heartbeat?: boolean
+  onStatus?: (status: ComlinkStatus) => void
+}
+
+/**
+ * @internal
+ * A React hook that returns a function for handling authentication callbacks.
+ *
+ * @remarks
+ * This hook provides access to the authentication store's callback handler,
+ * which processes auth redirects by extracting the session ID and fetching the
+ * authentication token. If fetching the long-lived token is successful,
+ * `handleAuthCallback` will return a Promise that resolves a new location that
+ * removes the short-lived token from the URL. Use this in combination with
+ * `history.replaceState` or your own router's `replace` function to update the
+ * current location without triggering a reload.
+ *
+ * @example
+ * ```tsx
+ * function AuthCallback() {
+ *   const handleAuthCallback = useHandleAuthCallback()
+ *   const router = useRouter() // Example router
+ *
+ *   useEffect(() => {
+ *     async function processCallback() {
+ *       // Handle the callback and get the cleaned URL
+ *       const newUrl = await handleAuthCallback(window.location.href)
+ *
+ *       if (newUrl) {
+ *         // Replace URL without triggering navigation
+ *         router.replace(newUrl, {shallow: true})
+ *       }
+ *     }
+ *
+ *     processCallback().catch(console.error)
+ *   }, [handleAuthCallback, router])
+ *
+ *   return <div>Completing login...</div>
+ * }
+ * ```
+ *
+ * @returns A callback handler function that processes OAuth redirects
+ * @public
+ */
+export declare const useHandleAuthCallback: () => (
+  locationHref?: string | undefined,
+) => Promise<string | false>
+
+/**
+ * @internal
+ * A React hook that retrieves the available authentication provider URLs for login.
+ *
+ * @remarks
+ * This hook fetches the login URLs from the Sanity auth store when the component mounts.
+ * Each provider object contains information about an authentication method, including its URL.
+ * The hook will suspend if the login URLs have not yet loaded.
+ *
+ * @example
+ * ```tsx
+ * // LoginProviders component that uses the hook
+ * function LoginProviders() {
+ *   const providers = useLoginUrls()
+ *
+ *   return (
+ *     <div>
+ *       {providers.map((provider) => (
+ *         <a key={provider.name} href={provider.url}>
+ *           Login with {provider.title}
+ *         </a>
+ *       ))}
+ *     </div>
+ *   )
+ * }
+ *
+ * // Parent component with Suspense boundary
+ * function LoginPage() {
+ *   return (
+ *     <Suspense fallback={<div>Loading authentication providers...</div>}>
+ *       <LoginProviders />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
+ *
+ * @returns An array of {@link AuthProvider} objects containing login URLs and provider information
+ * @public
+ */
+export declare function useLoginUrls(): AuthProvider[]
+
+/**
+ * Hook to log out of the current session
+ * @internal
+ * @returns A function to log out of the current session
+ */
+export declare const useLogOut: () => () => Promise<void>
+
+/**
+ * @beta
+ *
+ * ## useManageFavorite
+ * This hook provides functionality to add and remove documents from favorites,
+ * and tracks the current favorite status of the document.
+ * @category Dashboard Communication
+ * @param documentHandle - The document handle containing document ID and type, like `{_id: '123', _type: 'book'}`
+ * @returns An object containing:
+ * - `favorite` - Function to add document to favorites
+ * - `unfavorite` - Function to remove document from favorites
+ * - `isFavorited` - Boolean indicating if document is currently favorited
+ * - `isConnected` - Boolean indicating if connection to Dashboard UI is established
+ *
+ * @example
+ * ```tsx
+ * function MyDocumentAction(props: DocumentActionProps) {
+ *   const {documentId, documentType} = props
+ *   const {favorite, unfavorite, isFavorited, isConnected} = useManageFavorite({
+ *     documentId,
+ *     documentType
+ *   })
+ *
+ *   return (
+ *     <Button
+ *       disabled={!isConnected}
+ *       onClick={() => isFavorited ? unfavorite() : favorite()}
+ *       text={isFavorited ? 'Remove from favorites' : 'Add to favorites'}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+export declare function useManageFavorite({
+  documentId,
+  documentType,
+  resourceId,
+  resourceType,
+}: UseManageFavoriteProps): ManageFavorite
+
+declare interface UseManageFavoriteProps {
+  documentId: string
+  documentType: string
+  resourceId?: string
+  resourceType: StudioResource['type'] | MediaResource['type'] | CanvasResource['type']
+}
+
+/**
+ * @public
+ * Hook that provides a function to navigate to a studio document.
+ * Currently, requires a document handle with a resourceId.
+ * That resourceId is currently formatted like: `document:projectId.dataset:documentId`
+ * If the hook you used to retrieve the document handle doesn't provide a resourceId like this,
+ * you can construct it according to the above format with the document handle's _id.
+ *
+ * This will only work if you have deployed a studio with a workspace
+ * with this projectId / dataset combination.
+ * It may be able to take a custom URL in the future.
+ *
+ * This will likely change in the future.
+ * @param documentHandle - The document handle containing document ID, type, and resource ID
+ * @returns An object containing:
+ * - navigateToStudioDocument - Function that when called will navigate to the studio document
+ * - isConnected - Boolean indicating if connection to Dashboard is established
+ *
+ * @example
+ * ```ts
+ * import {navigateToStudioDocument, type DocumentHandle} from '@sanity/sdk'
+ *
+ * function MyComponent({documentHandle}: {documentHandle: DocumentHandle}) {
+ *   const {navigateToStudioDocument, isConnected} = useNavigateToStudioDocument(documentHandle)
+ *
+ *   return (
+ *     <button onClick={navigateToStudioDocument} disabled={!isConnected}>
+ *       Navigate to Studio Document
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export declare function useNavigateToStudioDocument(
+  documentHandle: DocumentHandle,
+): NavigateToStudioResult
+
+/**
+ * Retrieves pages of {@link DocumentHandle}s, narrowed by optional filters, text searches, and custom ordering,
+ * with support for traditional paginated interfaces. The number of document handles returned per page is customizable,
+ * while page navigation is handled via the included navigation functions.
+ *
+ * @beta
+ * @category Documents
+ * @param options - Configuration options for the paginated list
+ * @returns An object containing the current page of document handles, the loading and pagination state, and navigation functions
+ * @example
+ * ```tsx
+ * const {
+ *   data,
+ *   isPending,
+ *   currentPage,
+ *   totalPages,
+ *   nextPage,
+ *   previousPage,
+ *   hasNextPage,
+ *   hasPreviousPage
+ * } = usePaginatedDocuments({
+ *   filter: '_type == "post"',
+ *   search: searchTerm,
+ *   pageSize: 10,
+ *   orderings: [{field: '_createdAt', direction: 'desc'}]
+ * })
+ *
+ * return (
+ *   <>
+ *     <table>
+ *       {data.map(doc => (
+ *         <MyTableRowComponent key={doc._id} doc={doc} />
+ *       ))}
+ *     </table>
+ *     <>
+ *       {hasPreviousPage && <button onClick={previousPage}>Previous</button>}
+ *       {currentPage} / {totalPages}
+ *       {hasNextPage && <button onClick={nextPage}>Next</button>}
+ *     </>
+ *   </>
+ * )
+ * ```
+ *
+ */
+export declare function usePaginatedDocuments({
+  filter,
+  pageSize,
+  params,
+  orderings,
+  search,
+  ...options
+}?: PaginatedDocumentsOptions): PaginatedDocumentsResponse
+
+/**
+ * @beta
+ *
+ * Returns the preview values of a document (specified via a `DocumentHandle`),
+ * including the document’s `title`, `subtitle`, `media`, and `status`. These values are live and will update in realtime.
+ * To reduce unnecessary network requests for resolving the preview values, an optional `ref` can be passed to the hook so that preview
+ * resolution will only occur if the `ref` is intersecting the current viewport.
+ *
+ * @category Documents
+ * @param options - The document handle for the document you want to resolve preview values for, and an optional ref
+ * @returns The preview values for the given document and a boolean to indicate whether the resolution is pending
+ *
+ * @example Combining with useDocuments to render a collection of document previews
+ * ```
+ * // PreviewComponent.jsx
+ * export default function PreviewComponent({ document }) {
+ *   const { data: { title, subtitle, media }, isPending } = usePreview({ document })
+ *   return (
+ *     <article style={{ opacity: isPending ? 0.5 : 1}}>
+ *       {media?.type === 'image-asset' ? <img src={media.url} alt='' /> : ''}
+ *       <h2>{title}</h2>
+ *       <p>{subtitle}</p>
+ *     </article>
+ *   )
+ * }
+ *
+ * // DocumentList.jsx
+ * const { data } = useDocuments({ filter: '_type == "movie"' })
+ * return (
+ *   <div>
+ *     <h1>Movies</h1>
+ *     <ul>
+ *       {data.map(movie => (
+ *         <li key={movie._id}>
+ *           <Suspense fallback='Loading…'>
+ *             <PreviewComponent document={movie} />
+ *           </Suspense>
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   </div>
+ * )
+ * ```
+ */
+export declare function usePreview({
+  document: {_id, _type},
+  ref,
+}: UsePreviewOptions): UsePreviewResults
+
+/**
+ * @beta
+ * @category Types
+ */
+export declare interface UsePreviewOptions {
+  document: DocumentHandle
+  ref?: React.RefObject<unknown>
+}
+
+/**
+ * @beta
+ * @category Types
+ */
+export declare interface UsePreviewResults {
+  /** The results of resolving the document’s preview values */
+  data: PreviewValue
+  /** True when preview values are being refreshed */
+  isPending: boolean
+}
+
+declare type UseProject = {
+  /**
+   *
+   * Returns metadata for a given project
+   *
+   * @category Projects
+   * @param projectId - The ID of the project to retrieve metadata for
+   * @returns The metadata for the project
+   * @example
+   * ```tsx
+   *  function ProjectMetadata({ projectId }: { projectId: string }) {
+   *    const project = useProject(projectId)
+   *
+   *    return (
+   *      <figure style={{ backgroundColor: project.metadata.color || 'lavender'}}>
+   *        <h1>{project.displayName}</h1>
+   *      </figure>
+   *    )
+   *  }
+   * ```
+   */
+  (projectId: string): SanityProject_2
+}
+
+/**
+ * @public
+ * @function
+ */
+export declare const useProject: UseProject
+
+/**
+ * @beta
+ *
+ * Returns the projection values of a document (specified via a `DocumentHandle`),
+ * based on the provided projection string. These values are live and will update in realtime.
+ * To reduce unnecessary network requests for resolving the projection values, an optional `ref` can be passed to the hook so that projection
+ * resolution will only occur if the `ref` is intersecting the current viewport.
+ *
+ * @category Documents
+ * @param options - The document handle for the document you want to project values from, the projection string, and an optional ref
+ * @returns The projection values for the given document and a boolean to indicate whether the resolution is pending
+ *
+ * @example Using a projection to render a preview of document
+ * ```
+ * // ProjectionComponent.jsx
+ * export default function ProjectionComponent({ document }) {
+ *   const ref = useRef(null)
+ *   const { results: { title, coverImage, authors }, isPending } = useProjection({
+ *     document,
+ *     ref,
+ *     projection: `{
+ *       title,
+ *       'coverImage': cover.asset->url,
+ *       'authors': array::join(authors[]->{'name': firstName + ' ' + lastName + ' '}.name, ', ')
+ *     }`,
+ *   })
+ *
+ *   return (
+ *     <article ref={ref} style={{ opacity: isPending ? 0.5 : 1}}>
+ *       <h2>{title}</h2>
+ *       <img src={coverImage} alt={title} />
+ *       <p>{authors}</p>
+ *     </article>
+ *   )
+ * }
+ * ```
+ *
+ * @example Combining with useDocuments to render a collection with specific fields
+ * ```
+ * // DocumentList.jsx
+ * const { data } = useDocuments({ filter: '_type == "article"' })
+ * return (
+ *   <div>
+ *     <h1>Books</h1>
+ *     <ul>
+ *       {data.map(book => (
+ *         <li key={book._id}>
+ *           <Suspense fallback='Loading…'>
+ *             <ProjectionComponent
+ *               document={book}
+ *             />
+ *           </Suspense>
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   </div>
+ * )
+ * ```
+ */
+export declare function useProjection<TResult extends object>({
+  document: {_id, _type},
+  projection,
+  ref,
+}: UseProjectionOptions): UseProjectionResults<TResult>
+
+/**
+ * @public
+ * @category Types
+ */
+export declare interface UseProjectionOptions {
+  document: DocumentHandle
+  projection: ValidProjection
+  ref?: React.RefObject<unknown>
+}
+
 /**
- * An example function that will be removed.
  * @public
+ * @category Types
  */
-export declare function main(): void
+export declare interface UseProjectionResults<TResult extends object> {
+  data: TResult
+  isPending: boolean
+}
+
+declare type UseProjects = {
+  /**
+   *
+   * Returns metadata for each project you have access to.
+   *
+   * @category Projects
+   * @returns An array of metadata (minus the projects’ members) for each project
+   * @example
+   * ```tsx
+   * const projects = useProjects()
+   *
+   * return (
+   *   <select>
+   *     {projects.map((project) => (
+   *       <option key={project.id}>{project.displayName}</option>
+   *     ))}
+   *   </select>
+   * )
+   * ```
+   */
+  (): ProjectWithoutMembers[]
+}
+
+/**
+ * @public
+ * @function
+ */
+export declare const useProjects: UseProjects
+
+/**
+ * Executes GROQ queries against a Sanity dataset.
+ *
+ * This hook provides a convenient way to fetch and subscribe to real-time updates
+ * for your Sanity content. Changes made to the dataset’s content will trigger
+ * automatic updates.
+ *
+ * @remarks
+ * The returned `isPending` flag indicates when a React transition is in progress,
+ * which can be used to show loading states for query changes.
+ *
+ * @beta
+ * @category GROQ
+ * @param query - GROQ query string to execute
+ * @param options - Optional configuration for the query
+ * @returns Object containing the query result and a pending state flag
+ *
+ * @example Basic usage
+ * ```tsx
+ * const {data, isPending} = useQuery<Movie[]>('*[_type == "movie"]')
+ * ```
+ *
+ * @example Using parameters
+ * ```tsx
+ * // With parameters
+ * const {data} = useQuery<Movie>('*[_type == "movie" && _id == $id][0]', {
+ *   params: { id: 'movie-123' }
+ * })
+ * ```
+ *
+ * @example With a loading state for transitions
+ * ```tsx
+ * const {data, isPending} = useQuery<Movie[]>('*[_type == "movie"]')
+ * return (
+ *   <div>
+ *     {isPending && <div>Updating...</div>}
+ *     <ul>
+ *       {data.map(movie => <li key={movie._id}>{movie.title}</li>)}
+ *     </ul>
+ *   </div>
+ * )
+ * ```
+ *
+ */
+export declare function useQuery<T>(
+  query: string,
+  options?: QueryOptions,
+): {
+  data: T
+  isPending: boolean
+}
+
+/**
+ * @public
+ * Hook for managing document interaction history in Sanity Studio.
+ * This hook provides functionality to record document interactions.
+ * @category History
+ * @param documentHandle - The document handle containing document ID and type, like `{_id: '123', _type: 'book'}`
+ * @returns An object containing:
+ * - `recordEvent` - Function to record document interactions
+ * - `isConnected` - Boolean indicating if connection to Studio is established
+ *
+ * @example
+ * ```tsx
+ * function MyDocumentAction(props: DocumentActionProps) {
+ *   const {documentId, documentType, resourceType, resourceId} = props
+ *   const {recordEvent, isConnected} = useRecordDocumentHistoryEvent({
+ *     documentId,
+ *     documentType,
+ *     resourceType,
+ *     resourceId,
+ *   })
+ *
+ *   return (
+ *     <Button
+ *       disabled={!isConnected}
+ *       onClick={() => recordEvent('viewed')}
+ *       text={'Viewed'}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+export declare function useRecordDocumentHistoryEvent({
+  documentId,
+  documentType,
+  resourceType,
+  resourceId,
+}: UseRecordDocumentHistoryEventProps): DocumentInteractionHistory
+
+/**
+ * @public
+ */
+declare interface UseRecordDocumentHistoryEventProps {
+  documentId: string
+  documentType: string
+  resourceType: StudioResource['type'] | MediaResource['type'] | CanvasResource['type']
+  resourceId?: string
+}
+
+/** @public */
+declare class UsersClient {
+  #private
+  constructor(client: SanityClient, httpRequest: HttpRequest)
+  /**
+   * Fetch a user by user ID
+   *
+   * @param id - User ID of the user to fetch. If `me` is provided, a minimal response including the users role is returned.
+   */
+  getById<T extends 'me' | string>(id: T): Promise<T extends 'me' ? CurrentSanityUser : SanityUser>
+}
+
+/**
+ * `useSanityInstance` returns the current Sanity instance from the application context.
+ * This must be called from within a `SanityProvider` component.
+ * @internal
+ *
+ * @param resourceId - The resourceId of the Sanity instance to return (optional)
+ * @returns The current Sanity instance
+ * @example
+ * ```tsx
+ * const instance = useSanityInstance('abc123.production')
+ * ```
+ */
+export declare const useSanityInstance: (resourceId?: string) => SanityInstance
+
+/**
+ * Hook that fetches studio workspaces and organizes them by projectId:dataset
+ * @internal
+ */
+export declare function useStudioWorkspacesByResourceId(): StudioWorkspacesResult
+
+/**
+ *
+ * @public
+ *
+ * Retrieves the users for a given resource (either a project or an organization).
+ *
+ * @category Users
+ * @param params - The resource type and its ID, and the limit of users to fetch
+ * @returns A list of users, a boolean indicating whether there are more users to fetch, and a function to load more users
+ *
+ * @example
+ * ```
+ * const { users, hasMore, loadMore } = useUsers({
+ *   resourceType: 'organization',
+ *   resourceId: 'my-org-id',
+ *   limit: 10,
+ * })
+ *
+ * return (
+ *   <div>
+ *     {users.map(user => (
+ *       <figure key={user.sanityUserId}>
+ *         <img src={user.profile.imageUrl} alt='' />
+ *         <figcaption>{user.profile.displayName}</figcaption>
+ *         <address>{user.profile.email}</address>
+ *       </figure>
+ *     ))}
+ *     {hasMore && <button onClick={loadMore}>Load More</button>}
+ *   </div>
+ * )
+ * ```
+ */
+export declare function useUsers(params: UseUsersParams): UseUsersResult
+
+/**
+ * @public
+ * @category Types
+ */
+export declare interface UseUsersParams {
+  /**
+   * The type of resource to fetch users for.
+   */
+  resourceType: ResourceType
+  /**
+   * The ID of the resource to fetch users for.
+   */
+  resourceId: string
+  /**
+   * The limit of users to fetch.
+   */
+  limit?: number
+}
+
+/**
+ * @public
+ * @category Types
+ */
+export declare interface UseUsersResult {
+  /**
+   * The users fetched.
+   */
+  users: SanityUser_2[]
+  /**
+   * Whether there are more users to fetch.
+   */
+  hasMore: boolean
+  /**
+   * Load more users.
+   */
+  loadMore: () => void
+}
+
+/**
+ * @internal
+ * Hook to wrap a Comlink node in a React hook.
+ * Our store functionality takes care of the lifecycle of the node,
+ * as well as sharing a single node between invocations if they share the same name.
+ *
+ * Generally not to be used directly, but to be used as a dependency of
+ * Comlink-powered hooks like `useManageFavorite`.
+ */
+export declare function useWindowConnection<
+  TWindowMessage extends WindowMessage,
+  TFrameMessage extends FrameMessage,
+>({
+  name,
+  connectTo,
+  onMessage,
+  onStatus,
+}: UseWindowConnectionOptions<TFrameMessage>): WindowConnection<TWindowMessage>
+
+/**
+ * @internal
+ */
+export declare interface UseWindowConnectionOptions<TMessage extends FrameMessage> {
+  name: string
+  connectTo: string
+  onMessage?: Record<TMessage['type'], WindowMessageHandler<TMessage>>
+  onStatus?: (status: ComlinkStatus) => void
+}
+
+/**
+ * The listener has been established, and will start receiving events.
+ * Note that this is also emitted upon _reconnection_.
+ *
+ * @public
+ */
+declare type WelcomeEvent = {
+  type: 'welcome'
+  listenerName: string
+}
+
+/**
+ * @internal
+ */
+export declare interface WindowConnection<TMessage extends WindowMessage> {
+  sendMessage: <TType extends TMessage['type']>(
+    type: TType,
+    data?: Extract<
+      TMessage,
+      {
+        type: TType
+      }
+    >['data'],
+  ) => void
+  fetch: <TResponse>(
+    type: string,
+    data?: MessageData,
+    options?: {
+      signal?: AbortSignal
+      suppressWarnings?: boolean
+      responseTimeout?: number
+    },
+  ) => Promise<TResponse>
+}
+
+/**
+ * @internal
+ */
+export declare type WindowMessageHandler<TFrameMessage extends FrameMessage> = (
+  event: TFrameMessage['data'],
+) => TFrameMessage['response']
+
+declare interface Workspace {
+  name: string
+  title: string
+  basePath: string
+  dataset: string
+  userApplicationId: string
+  url: string
+  _ref: string
+}
+
+declare interface WorkspacesByResourceId {
+  [key: string]: Workspace[]
+}
 
 export {}