@sanity/sdk 3.0.0-rc.1 → 3.0.0

package/dist/authStore-C0o1NOxW.d.ts

@@ -0,0 +1,3165 @@
+import { b as AuthConfig, c as DocumentTypeHandle, d as ProjectHandle, f as ReleaseHandle, i as DatasetHandle, o as DocumentHandle, s as DocumentResource, t as SanityInstance, u as PerspectiveHandle, x as AuthProvider } from "./createSanityInstance-DUI1bGIg.js";
+import { ClientConfig, ClientPerspective, DatasetsResponse, ListenEvent, MultipleMutationResult, ReleaseDocument, ReleaseDocument as ReleaseDocument$1, ResponseQueryOptions, SanityClient, SanityDocument, SanityProject } from "@sanity/client";
+import { Observable, Subject } from "rxjs";
+import { CurrentUser, CurrentUser as CurrentUser$1, Mutation, PatchOperations, Path, PortableTextBlock, Role, SanityDocument as SanityDocument$1, SanityDocument as SanityDocument$3, SanityDocumentLike } from "@sanity/types";
+import "zustand/middleware";
+import { getIndexForKey as getIndexForKey$1, getPathDepth, joinPaths, jsonMatch as jsonMatch$1, slicePath as slicePath$1, stringifyPath as stringifyPath$1 } from "@sanity/json-match";
+import { PatchMutation } from "@sanity/mutate/_unstable_store";
+import { SanityDocument as SanityDocument$2, SanityProjectionResult, SanityQueryResult } from "groq";
+import { ExprNode } from "groq-js";
+import { CanvasResource, MediaResource, StudioResource } from "@sanity/message-protocol";
+/**
+ * Represents a reactive store state container with multiple access patterns
+ */
+interface StoreState<TState> {
+  /**
+   * Gets the current state value
+   *
+   * @remarks
+   * This is a direct synchronous accessor that doesn't trigger subscriptions
+   */
+  get: () => TState;
+  /**
+   * Updates the store state
+   * @param name - Action name for devtools tracking
+   * @param updatedState - New state value or updater function
+   *
+   * @remarks
+   * When providing a partial object, previous top-level keys not included in
+   * the update will be preserved.
+   */
+  set: (name: string, updatedState: Partial<TState> | ((s: TState) => Partial<TState>)) => void;
+  /**
+   * Observable stream of state changes
+   * @remarks
+   * - Emits immediately with current state on subscription
+   * - Shares underlying subscription between observers
+   * - Only emits when state reference changes
+   * - Completes when store is disposed
+   */
+  observable: Observable<TState>;
+}
+/**
+ * Context object provided to store initialization functions
+ */
+interface StoreContext<TState, TKey = unknown> {
+  /**
+   * Sanity instance associated with this store
+   *
+   * @remarks
+   * Provides access to the Sanity configuration and instance lifecycle methods
+   */
+  instance: SanityInstance;
+  /**
+   * Reactive store state management utilities
+   *
+   * @remarks
+   * Contains methods for getting/setting state and observing changes
+   */
+  state: StoreState<TState>;
+  /**
+   * The key used to instantiate the store.
+   */
+  key: TKey;
+}
+/**
+ * Defines a store action that operates on a specific state type
+ */
+type StoreAction<TState, TParams extends unknown[], TReturn, TKey = unknown> = (context: StoreContext<TState, TKey>, ...params: TParams) => TReturn;
+/**
+ * Represents a store action that has been bound to a specific store instance
+ */
+type BoundStoreAction<_TState, TParams extends unknown[], TReturn> = (instance: SanityInstance, ...params: TParams) => TReturn;
+/**
+ * Represents a reactive state source that provides synchronized access to store data
+ *
+ * @remarks
+ * Designed to work with React's useSyncExternalStore hook. Provides three ways to access data:
+ * 1. `getCurrent()` for synchronous current value access
+ * 2. `subscribe()` for imperative change notifications
+ * 3. `observable` for reactive stream access
+ *
+ * @public
+ */
+interface StateSource<T> {
+  /**
+   * Subscribes to state changes with optional callback
+   * @param onStoreChanged - Called whenever relevant state changes occur
+   * @returns Unsubscribe function to clean up the subscription
+   */
+  subscribe: (onStoreChanged?: () => void) => () => void;
+  /**
+   * Gets the current derived state value
+   *
+   * @remarks
+   * Safe to call without subscription. Will always return the latest value
+   * based on the current store state and selector parameters.
+   */
+  getCurrent: () => T;
+  /**
+   * Observable stream of state values
+   *
+   * @remarks
+   * Shares a single underlying subscription between all observers. Emits:
+   * - Immediately with current value on subscription
+   * - On every relevant state change
+   * - Errors if selector throws
+   */
+  observable: Observable<T>;
+}
+/**
+ * Context passed to selectors when deriving state
+ *
+ * @remarks
+ * Provides access to both the current state value and the Sanity instance,
+ * allowing selectors to use configuration values when computing derived state.
+ * The context is memoized for each state object and instance combination
+ * to optimize performance and prevent unnecessary recalculations.
+ *
+ * @example
+ * ```ts
+ * // Using both state and instance in a selector (psuedo example)
+ * const getUserByProjectId = createStateSourceAction(
+ *   ({ state, instance }: SelectorContext<UsersState>, options?: ProjectHandle) => {
+ *     const allUsers = state.users
+ *     const projectId = options?.projectId ?? instance.config.projectId
+ *     return allUsers.filter(user => user.projectId === projectId)
+ *   }
+ * )
+ * ```
+ */
+interface SelectorContext<TState> {
+  /**
+   * The current state object from the store
+   */
+  state: TState;
+  /**
+   * The Sanity instance associated with this state
+   */
+  instance: SanityInstance;
+}
+/**
+ * Function type for selecting derived state from store state and parameters
+ * @public
+ */
+type Selector<TState, TParams extends unknown[], TReturn> = (context: SelectorContext<TState>, ...params: TParams) => TReturn;
+/**
+ * Identifies cached data for invalidation, matched across the whole store.
+ * A fetcher declares the tags each of its entries carries (via
+ * {@link FetcherDefinition.tags}); a mutation declares the tags it invalidates
+ * (via {@link MutationDefinition.invalidates}).
+ *
+ * When invalidating,`{type: 'organization'}` matches every entry carrying any `organization` tag;
+ * `{type: 'organization', id: 'abc'}` matches only entries carrying that exact pair.
+ * List entries carry a `{type, id: 'LIST'}` sentinel plus one tag per item, so a
+ * "create" mutation can refetch lists without touching unrelated detail entries.
+ *
+ * @internal
+ */
+interface CacheTag {
+  type: string;
+  /** Specific id, or the `'LIST'` sentinel for list entries */
+  id?: string | number;
+}
+/**
+ * The reactive value of one cache entry, as exposed by
+ * {@link Fetcher.getState}. React hooks consume this envelope directly.
+ * Discriminated on `status`, so narrowing gives correctly-typed `data`:
+ * `'success'` is the only arm carrying data, and a background failure while
+ * data still renders surfaces on the `'success'` arm's `error`.
+ *
+ * `isFetching` is common to all arms: a fetch for this entry is in flight
+ * (initial load, revalidation, or poll).
+ *
+ * @internal
+ */
+type FetcherSnapshot<TData> = {
+  /** No data yet — initial fetch in flight or not started */
+  status: 'pending';
+  data: undefined;
+  error: undefined;
+  isFetching: boolean;
+  dataUpdatedAt: undefined;
+} | {
+  /** Data available — possibly stale, possibly revalidating */
+  status: 'success';
+  data: TData;
+  /** Most recent background-fetch failure, cleared by the next successful fetch */
+  error: unknown;
+  isFetching: boolean;
+  /** Epoch ms of the fetch that produced `data` */
+  dataUpdatedAt: number;
+} | {
+  /** The last fetch failed and no data exists to serve */
+  status: 'error';
+  data: undefined;
+  error: unknown;
+  isFetching: boolean;
+  dataUpdatedAt: undefined;
+};
+/**
+ * A typed description of one cached, parameterised read of an API response —
+ * here is a single cache per {@link SanityInstance}; every definition registers
+ * into it and its `name` namespaces its keys. A list and a detail read are two
+ * definitions over the one cache, not two caches.
+ *
+ * Entry lifecycle: fresh → stale → collected. Fresh entries are served from
+ * cache with no fetch; stale entries are served immediately and revalidated in
+ * the background (stale-while-revalidate); collected entries are removed once
+ * their `gcTime` elapses after the last unsubscribe, so the next subscriber
+ * suspends.
+ *
+ * @internal
+ */
+interface FetcherDefinition<TParams extends unknown[], TData> {
+  /** Namespaces this fetcher's keys in the shared cache; used for devtools and request-tag derivation */
+  name: string;
+  /**
+   * Fetches the data once. Return an observable that emits the result and
+   * completes.
+   */
+  fetch: (instance: SanityInstance) => (...params: TParams) => Observable<TData>;
+  /** Converts params into the cache key that identifies an entry (unique within `name`) */
+  getKey: (instance: SanityInstance, ...params: TParams) => string;
+  /**
+   * Cache tags each entry carries, for cache-wide invalidation. A static array,
+   * or a function of the fetched data when tags depend on the response (e.g. one
+   * tag per list item).
+   */
+  tags?: CacheTag[] | ((data: TData, ...params: TParams) => CacheTag[]);
+  /**
+   * How long fetched data is fresh, in ms. Fresh entries never refetch;
+   * stale entries serve cached data and revalidate in the background.
+   * @defaultValue 30_000
+   */
+  staleTime?: number;
+  /**
+   * How long an entry survives after its last unsubscribe before it is garbage
+   * collected, in ms. The clock starts at the last unsubscribe — entries with
+   * active subscribers are never collected.
+   * @defaultValue 300_000
+   */
+  gcTime?: number;
+  /**
+   * Refetch on this interval (ms) while the entry has at least one subscriber,
+   * independent of staleness. Ticks are skipped while `document.hidden`. Off by default.
+   */
+  refetchInterval?: number;
+  /**
+   * Consulted once, when an entry is being created and no cached data exists for
+   * it. Return data pulled from another fetcher in the same cache — read via its
+   * ordinary `getState(instance, ...).getCurrent()`, e.g. a detail entry pulling
+   * its item out of the cached list — to skip or soften the initial fetch.
+   * `dataUpdatedAt` must be when the source data was fetched, not "now": staleness
+   * is measured from it. Return `undefined` to fetch as normal.
+   */
+  initialData?: (instance: SanityInstance, ...params: TParams) => {
+    data: TData;
+    dataUpdatedAt: number;
+  } | undefined;
+}
+/**
+ * A typed handle over the shared fetcher cache, returned by
+ * {@link defineFetcher}. It is a view onto the entries under its definition's
+ * `name`, not a cache of its own.
+ *
+ * @internal
+ */
+interface Fetcher<TParams extends unknown[], TData> {
+  /** Reactive envelope for one entry. Subscribing triggers fetching per staleness rules. */
+  getState: (instance: SanityInstance, ...params: TParams) => StateSource<FetcherSnapshot<TData>>;
+  /**
+   * Resolves with the entry's first available data — the promise a suspending
+   * component throws. Rejects if the initial fetch fails.
+   */
+  resolveState: (instance: SanityInstance, ...params: TParams) => Promise<TData>;
+  /**
+   * Marks the entry stale. If it has active subscribers it refetches immediately;
+   * otherwise it refetches on next subscribe.
+   */
+  invalidate: (instance: SanityInstance, ...params: TParams) => void;
+  /** {@link Fetcher.invalidate} for every entry under this fetcher's `name`. */
+  invalidateAll: (instance: SanityInstance) => void;
+  /**
+   * Imperative fetch, bypassing staleness. Dedupes against an in-flight fetch.
+   * Resolves with the entry's data as held by the cache once the fetch settles.
+   */
+  refetch: (instance: SanityInstance, ...params: TParams) => Promise<TData>;
+  /**
+   * Writes an entry's data directly. Returns an undo handle — inside a
+   * mutation's `onMutate` these writes are recorded and rolled back automatically
+   * on failure.
+   */
+  setData: (instance: SanityInstance, params: TParams, updater: TData | ((current: TData | undefined) => TData)) => {
+    undo: () => void;
+  };
+}
+/**
+ * Writes an entry's data in any fetcher. Passed to {@link MutationDefinition}
+ * callbacks — mutations are the only holders of arbitrary write access; read
+ * fetchers pull their data (see {@link FetcherDefinition.initialData}). Inside
+ * `onMutate`, every write is recorded and undone automatically if the mutation
+ * fails.
+ *
+ * @internal
+ */
+type CacheWriter = <TParams extends unknown[], TData>(fetcher: Fetcher<TParams, TData>, params: TParams, updater: TData | ((current: TData | undefined) => TData)) => void;
+/**
+ * Resolves when the mutation settles on the server. `invalidated` tracks the
+ * background reconciliation — the refetches triggered by
+ * {@link MutationDefinition.invalidates} — for the rare caller that must wait for
+ * full reconvergence rather than server settlement.
+ *
+ * @internal
+ */
+interface MutationResult<TResult> {
+  /** The server response */
+  data: TResult;
+  /** Settles when the refetches of matched active entries complete */
+  invalidated: Promise<void>;
+}
+/**
+ * Defines a mutation with optimistic cache updates. Lifecycle:
+ *
+ * 1. `onMutate` applies optimistic writes synchronously — the UI updates before
+ *    the request leaves. Each entry carries a version counter that increments on
+ *    every write. An optimistic write bumps the counter, so a revalidation already
+ *    in flight lands "out of date" and is discarded rather than clobbering the
+ *    optimistic write.
+ * 2. The request runs. On failure, recorded writes are rolled back automatically
+ *    — the cache is restored exactly, so failure ends the lifecycle here.
+ * 3. On success, `onSuccess` may write the server response into the cache directly.
+ * 4. On success, `invalidates` tags mark matching entries across the cache
+ *    stale (active entries refetch), so the cache reconverges on server truth
+ *    even if the optimistic shape was wrong.
+ *
+ * @internal
+ */
+interface MutationDefinition<TInput, TResult> {
+  /** Unique mutation name, used for devtools and request-tag derivation */
+  name: string;
+  /** Creates the observable that performs the server mutation */
+  mutationFn: (instance: SanityInstance) => (input: TInput) => Observable<TResult>;
+  /** Optimistic cache writes, applied synchronously before the request */
+  onMutate?: (write: CacheWriter, input: TInput) => void;
+  /** Reconcile the cache with the server response, avoiding a refetch round-trip */
+  onSuccess?: (write: CacheWriter, result: TResult, input: TInput) => void;
+  /**
+   * Cache tags to invalidate on success. Failure invalidates nothing: recorded
+   * optimistic writes roll back to the exact pre-mutation cache, and any
+   * server-side ambiguity (e.g. timeout after commit) heals via `staleTime`.
+   * A static array, or a function of the result/input.
+   */
+  invalidates?: CacheTag[] | ((result: TResult, input: TInput) => CacheTag[]);
+}
+/**
+ * Registers a fetcher definition against the shared cache and returns its typed
+ * handle.
+ *
+ * @internal
+ */
+declare function defineFetcher<TParams extends unknown[], TData>(definition: FetcherDefinition<TParams, TData>): Fetcher<TParams, TData>;
+/**
+ * Creates a bound mutation from its definition. The returned action resolves at
+ * server settlement — not after invalidation refetches, which run as background
+ * reconciliation (see {@link MutationResult.invalidated}).
+ *
+ * @internal
+ */
+declare function defineMutation<TInput, TResult>(definition: MutationDefinition<TInput, TResult>): (instance: SanityInstance, input: TInput) => Promise<MutationResult<TResult>>;
+/**
+ * The resource types the Access API can scope a permission check to.
+ *
+ * @see https://www.sanity.io/docs/http-reference/access-api
+ * @public
+ */
+type AccessResourceType = 'organization' | 'project' | 'media-library' | 'canvas' | 'dashboard' | 'view';
+/**
+ * Fetcher checking whether the current user holds the given permissions on a
+ * resource (`GET /access/:resourceType/:resourceId/user-permissions/me/check`),
+ * on the shared fetcher cache. Resolves to a map of each requested permission
+ * to whether the user has it. The key sorts the permission list, so permission
+ * order doesn't create distinct cache entries.
+ *
+ * @see https://www.sanity.io/docs/http-reference/access-api
+ * @internal
+ */
+declare const checkPermissions: Fetcher<[resourceType: AccessResourceType, resourceId: string, permissions: string[]], Record<string, boolean>>;
+/**
+ * A response field that the API embeds only when its `include` token was
+ * requested. Given the full set of tokens `All`, the token `Key` this field
+ * maps to, and the tokens actually `Requested`, it resolves to:
+ *
+ * - `unknown` (field absent) when nothing — or nothing matching `Key` — was requested
+ * - `Field` (present, as declared) when a literal request list contains `Key`
+ * - `Partial<Field>` (optional) when `Requested` is the wide `All` union, i.e.
+ *   an `include` array whose members aren't known at the type level
+ *
+ * Absent arms return `unknown` so they vanish under intersection. Mirrors the
+ * `boolean extends Flag` trick the organization/project types use, but for an
+ * include-token union rather than a boolean flag.
+ *
+ * @internal
+ */
+type Included<All extends string, Key extends All, Requested extends All, Field> = [All] extends [Requested] ? Partial<Field> : [Key] extends [Requested] ? Field : unknown;
+/**
+ * Whether the requested include tokens intersect a given set — used to decide
+ * whether a parent field (e.g. an application's `activeDeployment`) is present,
+ * when requesting any of several tokens forces it in.
+ *
+ * @internal
+ */
+type IncludesAny<Requested extends string, Set extends string> = [Requested & Set] extends [never] ? false : true;
+/**
+ * Related data the Applications API can embed in a response. `interfaces`,
+ * `workspaces` and `access` are children of the active deployment and are
+ * embedded under {@link Application.activeDeployment}; `config.studio` and
+ * `config.mfManifest` are embedded under {@link Application.config}.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+type ApplicationInclude = 'interfaces' | 'workspaces' | 'access' | 'config.studio' | 'config.mfManifest' | 'activeDeployment';
+/**
+ * An interface exposed by a deployment, embedded when `interfaces` is included.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface ApplicationInterface {
+  id: string;
+  type: 'app' | 'worker' | 'asset_source' | 'panel';
+  name: string;
+  title: string;
+  version: string;
+  /** Module federation module ID; resolved from the host mf-manifest at runtime */
+  moduleId: string;
+  metadata: {
+    group?: string;
+    priority?: number;
+  } | null;
+}
+/**
+ * A studio workspace of a deployment, embedded when `workspaces` is included.
+ * Studio applications only.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface ApplicationWorkspace {
+  id: string;
+  name: string;
+  title: string | null;
+  subtitle: string | null;
+  projectId: string;
+  dataset: string;
+  schemaDescriptorId: string | null;
+  basePath: string | null;
+  /** Sanitized SVG icon markup */
+  icon: string | null;
+}
+/**
+ * A resource an application accesses, embedded when `access` is included.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface ApplicationAccess {
+  id: string;
+  resourceType: 'datasets' | 'canvases' | 'dashboards' | 'media-libraries';
+  resourceId: string;
+}
+/**
+ * Studio configuration, embedded under `config` when `config.studio` is included.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface ApplicationStudioConfig {
+  projectId: string;
+  /** Release channel (`next`, `stable`, `latest`) or a pinned semver; null if unset */
+  autoUpdatingVersion: string | null;
+}
+/**
+ * The active deployment as embedded under {@link Application.activeDeployment}.
+ * Its `interfaces`, `workspaces` and `access` children are each present only
+ * when the matching {@link ApplicationInclude} token was requested. `workspaces`
+ * is omitted (not `null`) for non-studio applications even when requested.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+type ApplicationDeployment<Include extends ApplicationInclude = never> = {
+  id: string;
+  applicationId: string;
+  size: number | null;
+  version: string | null;
+  isAutoUpdating: boolean | null;
+  isActiveDeployment: boolean;
+  deployedBy: string | null;
+  createdAt: string;
+  updatedAt: string;
+} & Included<ApplicationInclude, 'interfaces', Include, {
+  interfaces: ApplicationInterface[];
+}> & Included<ApplicationInclude, 'workspaces', Include, {
+  workspaces?: ApplicationWorkspace[];
+}> & Included<ApplicationInclude, 'access', Include, {
+  access: ApplicationAccess[];
+}>;
+/**
+ * The always-present fields of an org-owned application returned by the
+ * Applications API (`/applications`), before any {@link ApplicationInclude}.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface ApplicationBase {
+  id: string;
+  type: 'studio' | 'coreApp';
+  title: string;
+  /** Stable, immutable identity, distinct from the mutable `slug` address. */
+  name: string;
+  /** Qualified, globally-unique handle: `sanity/<name>` for singletons, `<organizationId>/<name>` otherwise. */
+  reference: string;
+  icon: string | null;
+  isSingleton: boolean;
+  visibility: 'default' | 'unlisted' | 'disabled';
+  slug: string | null;
+  externalUrl: string | null;
+  organizationId: string;
+  createdAt: string;
+  updatedAt: string;
+}
+type DeploymentToken = 'activeDeployment' | 'interfaces' | 'workspaces' | 'access';
+type ApplicationConfigShape<Include extends ApplicationInclude> = Included<ApplicationInclude, 'config.studio', Include, {
+  config: {
+    studio: ApplicationStudioConfig;
+  };
+}> & Included<ApplicationInclude, 'config.mfManifest', Include, {
+  config: {
+    mfManifest: unknown;
+  };
+}>;
+type ApplicationDeploymentShape<Include extends ApplicationInclude> = [ApplicationInclude] extends [Include] ? {
+  activeDeployment?: ApplicationDeployment<Include> | null;
+} : IncludesAny<Include, DeploymentToken> extends true ? {
+  activeDeployment: ApplicationDeployment<Include> | null;
+} : unknown;
+/**
+ * An org-owned application as returned by the Applications API
+ * (`/applications`). `config` and `activeDeployment` (with its
+ * `interfaces`/`workspaces`/`access` children) are present only when the
+ * corresponding {@link ApplicationInclude} tokens were requested.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+type Application<Include extends ApplicationInclude = never> = ApplicationBase & ApplicationConfigShape<Include> & ApplicationDeploymentShape<Include>;
+/**
+ * Options for listing an organization's applications.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface ApplicationsOptions<Include extends ApplicationInclude = ApplicationInclude> {
+  organizationId: string;
+  /** Filter by application type */
+  type?: string;
+  include?: Include[];
+  /** Page size (1-100, default 50), or `'none'` to disable pagination */
+  limit?: number | 'none';
+  /** Cursor from a previous response's `nextCursor` */
+  cursor?: string;
+}
+/**
+ * The cursor-paginated envelope returned by `GET /applications`.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface ApplicationsResponse<Include extends ApplicationInclude = never> {
+  nextCursor: string | null;
+  data: Application<Include>[];
+}
+/**
+ * Fetcher for an organization's applications (`GET /applications`), on the
+ * shared fetcher cache.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+declare const applications: Fetcher<[options: ApplicationsOptions<ApplicationInclude>], ApplicationsResponse<ApplicationInclude>>;
+/**
+ * Fetcher for a single application (`GET /applications/:id`), on the shared
+ * fetcher cache. No pre-seeding from {@link applications}: its list keys
+ * include the organization, which this fetcher's params can't reconstruct.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+declare const application: Fetcher<[applicationId: string, options?: {
+  include?: ApplicationInclude[];
+} | undefined], Application<ApplicationInclude>>;
+/**
+ * Confirmation returned by the API's soft-delete endpoints.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+interface DeletedResult {
+  deleted: boolean;
+}
+/**
+ * Dashboard visibility for an application.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+type ApplicationVisibility = ApplicationBase['visibility'];
+/**
+ * Mutable properties of an application (`PATCH /applications/:id`) — the
+ * writable subset of {@link ApplicationBase}, each optional, keyed by id.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+type UpdateApplicationInput = {
+  applicationId: string;
+} & Partial<Pick<ApplicationBase, 'title' | 'icon' | 'visibility'>>;
+/**
+ * Mutation to update an application (`PATCH /applications/:id`). Invalidates the
+ * updated application and the list so active entries reconverge on server truth.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+declare const updateApplication: (instance: SanityInstance, input: UpdateApplicationInput) => Promise<MutationResult<ApplicationBase>>;
+/**
+ * Input for {@link deleteApplication}.
+ *
+ * @internal
+ */
+interface DeleteApplicationInput {
+  applicationId: string;
+}
+/**
+ * Mutation to soft-delete an application (`DELETE /applications/:id`).
+ * Invalidates the deleted application and the list.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+declare const deleteApplication: (instance: SanityInstance, input: DeleteApplicationInput) => Promise<MutationResult<DeletedResult>>;
+/**
+ * Represents the various states the authentication type can be in.
+ *
+ * @public
+ */
+declare enum AuthStateType {
+  LOGGED_IN = "logged-in",
+  LOGGING_IN = "logging-in",
+  ERROR = "error",
+  LOGGED_OUT = "logged-out"
+}
+/**
+ * Error message returned by the organization verification
+ * @public
+ */
+interface OrgVerificationResult {
+  error: string | null;
+}
+/**
+ * Creates an observable that emits the organization verification state for a given instance.
+ * It combines the dashboard organization ID (from auth context) with the
+ * project's actual organization ID (fetched via the project fetcher) and compares them.
+ * @public
+ */
+declare function observeOrganizationVerificationState(instance: SanityInstance, projectIds: string[]): Observable<OrgVerificationResult>;
+/**
+ * @public
+ */
+declare const handleAuthCallback: BoundStoreAction<AuthStoreState, [locationHref?: string | undefined], Promise<string | false>>;
+/**
+ * @public
+ */
+declare const logout: BoundStoreAction<AuthStoreState, [], Promise<void>>;
+type AllowedClientConfigKey = 'useCdn' | 'token' | 'perspective' | 'apiHost' | 'proxy' | 'withCredentials' | 'timeout' | 'maxRetries' | 'dataset' | 'projectId' | 'requestTagPrefix' | 'useProjectHostname';
+/**
+ * States tracked by the client store
+ * @public
+ */
+interface ClientStoreState {
+  token: string | null;
+  clients: { [TKey in string]?: SanityClient; };
+  authMethod?: 'localstorage' | 'cookie';
+}
+/**
+ * Options used when retrieving a client instance from the client store.
+ *
+ * This interface extends the base {@link ClientConfig} and adds:
+ *
+ * - **apiVersion:** A required string indicating the API version for the client.
+ * - **scope:** An optional flag to choose between the project-specific client
+ *   ('project') and the global client ('global'). When set to `'global'`, the
+ *   global client is used.
+ *
+ * These options are utilized by `getClient` and `getClientState` to configure and
+ * return appropriate client instances that automatically handle authentication
+ * updates and configuration changes.
+ *
+ * @public
+ */
+interface ClientOptions extends Pick<ClientConfig, AllowedClientConfigKey> {
+  /**
+   * An optional flag to choose between the default client (typically project-level)
+   * and the global client ('global'). When set to `'global'`, the global client
+   * is used.
+   */
+  scope?: 'default' | 'global';
+  /**
+   * A required string indicating the API version for the client.
+   */
+  apiVersion: string;
+  /**
+   * @internal
+   * The SDK resource to use for the client -- this will get transformed into a ClientConfig resource.
+   */
+  resource?: DocumentResource;
+}
+/**
+ * Retrieves a Sanity client instance configured with the provided options.
+ *
+ * This function returns a client instance configured for the project or as a
+ * global client based on the options provided. It ensures efficient reuse of
+ * client instances by returning the same instance for the same options.
+ * For automatic handling of authentication token updates, consider using
+ * `getClientState`.
+ *
+ * @public
+ */
+declare const getClient: BoundStoreAction<ClientStoreState, [options: ClientOptions], SanityClient>;
+/**
+ * Returns a state source for the Sanity client instance.
+ *
+ * This function provides a subscribable state source that emits updated client
+ * instances whenever relevant configurations change (such as authentication tokens).
+ * Use this when you need to react to client configuration changes in your application.
+ *
+ * @public
+ */
+declare const getClientState: BoundStoreAction<ClientStoreState, [options: ClientOptions], StateSource<SanityClient>>;
+/**
+ * Whether a thread is still being discussed or has been closed out.
+ * @beta
+ */
+type CommentStatus = 'open' | 'resolved';
+/**
+ * The body of a comment, as Portable Text.
+ *
+ * Mentions appear here as inline objects of type `mention` carrying a `userId`.
+ * The SDK stores and returns them untouched, so a mention written in the Studio
+ * survives a round trip, but there is no API for composing one yet.
+ * @beta
+ */
+type CommentMessage = PortableTextBlock[] | null;
+/**
+ * One block touched by a text selection, and that block's text with the
+ * selection boundaries marked.
+ *
+ * `text` is the block's *entire* plain text with two private-use sentinel
+ * characters (U+F000 and U+F001) inserted where the selection starts and ends.
+ * Storing marked-up text rather than character offsets is what lets a highlight
+ * survive edits elsewhere in the same block.
+ * @beta
+ */
+interface CommentTextSelectionItem {
+  _key: string;
+  text: string;
+}
+/**
+ * A comment anchored to a run of text inside a Portable Text field.
+ *
+ * The SDK passes this through untouched. Resolving it back to a position in a
+ * live editor needs the editor's current value, so that lives in
+ * `@portabletext/plugin-sdk-value` rather than here.
+ * @beta
+ */
+interface CommentTextSelection {
+  type: 'text';
+  value: CommentTextSelectionItem[];
+}
+/**
+ * An emoji reaction on a comment.
+ *
+ * Read only for now: a reaction added in the Studio shows up here, but there is
+ * no action for adding or removing one.
+ * @beta
+ */
+interface CommentReaction {
+  shortName: string;
+  userId: string;
+  addedAt: string;
+}
+/**
+ * Why a comment is not yet on the server.
+ *
+ * Local only, never written. Present on a comment whose create request failed,
+ * so an app can offer a retry.
+ * @beta
+ */
+type CommentLocalState = {
+  type: 'createError';
+  error: Error;
+} | {
+  type: 'createRetrying';
+};
+/**
+ * A single comment.
+ *
+ * Deliberately not the stored document. Comments are moving from per-dataset
+ * addon datasets to an organization-level store, and the two disagree on the
+ * document type, on how the commented document is referenced, and on where the
+ * author is recorded. Everything here reads the same on both sides, so an app
+ * written against this survives the move.
+ *
+ * Threads are flat: every comment in a thread shares a `threadId`, the thread's
+ * first comment has no `parentCommentId`, and replies carry that first comment's
+ * `id`. Use {@link CommentThread} to work with them grouped.
+ *
+ * @beta
+ */
+interface Comment {
+  id: string;
+  createdAt: string;
+  /**
+   * Who wrote it.
+   *
+   * Absent when the server carries the author instead of the document. The
+   * Studio's comments dataset stores it on the document, so it is present on
+   * everything written today, but an agent-authored comment records
+   * attribution elsewhere. Render a fallback rather than assuming a user id.
+   */
+  authorId?: string;
+  message: CommentMessage;
+  threadId: string;
+  /** Absent on the comment that starts a thread. */
+  parentCommentId?: string;
+  status: CommentStatus;
+  /** Set once the message has been rewritten. */
+  lastEditedAt?: string;
+  /** The document the thread hangs on, always the published id. */
+  documentId: string;
+  documentType: string;
+  /** The field the thread hangs off, for example `title`. */
+  fieldPath: string;
+  /** Set when the comment is anchored to a run of text in a Portable Text field. */
+  selection?: CommentTextSelection;
+  /** A copy of the content the comment was written about. */
+  contentSnapshot?: unknown;
+  reactions: CommentReaction[];
+  /** Local only. Present while a create is failing or being retried. */
+  state?: CommentLocalState;
+}
+/**
+ * A thread: one comment plus its replies.
+ *
+ * Unlike the Studio, the SDK returns every thread it finds. The Studio hides
+ * threads whose field is gone from the schema or hidden by a conditional, which
+ * it can do because it has the schema. Check `fieldPath` yourself if your app
+ * needs the same behaviour.
+ * @beta
+ */
+interface CommentThread {
+  threadId: string;
+  /** The field the thread hangs off, taken from its first comment. */
+  fieldPath: string;
+  parentComment: Comment;
+  /** Oldest first. */
+  replies: Comment[];
+  /** The parent plus its replies. */
+  commentsCount: number;
+  /** Taken from the parent comment; replies follow it. */
+  status: CommentStatus;
+  /** `createdAt` of the most recent comment in the thread. */
+  lastActivityAt: string;
+}
+/** @beta */
+interface CreateCommentOptions extends DocumentHandle {
+  message: CommentMessage;
+  /**
+   * Which field the thread hangs off, for example `title` or
+   * `body[_key=="intro"].content`.
+   *
+   * Required, and it has to resolve to a real path. There is no such thing as a
+   * comment on a document as a whole: the Studio only ever creates field
+   * comments, and its comment inspector throws on an empty path rather than
+   * ignoring it, so a pathless comment takes the inspector down for everyone
+   * looking at that document.
+   */
+  fieldPath: string | Path;
+  /**
+   * Anchors the comment to a run of text inside a Portable Text field. Building
+   * one needs a live editor, so this comes from
+   * `@portabletext/plugin-sdk-value` rather than being constructed by hand.
+   */
+  selection?: CommentTextSelection;
+  /** Reuse the id of a failed comment to retry it. Defaults to a new id. */
+  commentId?: string;
+  /** Defaults to a new id, which starts a new thread. */
+  threadId?: string;
+  /** @defaultValue `'open'` */
+  status?: CommentStatus;
+  /**
+   * The `_rev` of the document when the comment was written.
+   *
+   * Not filled in automatically: the SDK's local document revision is replaced
+   * by a transaction id while an edit is in flight, so it can name a revision
+   * that never reached the server. Nothing in the Studio reads this today.
+   */
+  documentRevisionId?: string;
+  /**
+   * Ambient information stored alongside the comment, merged over the defaults.
+   *
+   * The Studio writes `tool`, `payload`, `intent`, and `notification` here for
+   * its notification backend. The SDK has no source for any of them, so
+   * mentions in comments created this way do not send email unless you supply
+   * `notification` yourself. Deliberately loose: the organization-level store
+   * treats this as free-form, so no shape is worth promising.
+   */
+  context?: Record<string, unknown>;
+  /** A copy of the content being discussed. References in it are weakened. */
+  contentSnapshot?: unknown;
+}
+/** @beta */
+interface ReplyToCommentOptions extends DocumentHandle {
+  /** The comment being replied to. Replies to a reply join the same thread. */
+  parentCommentId: string;
+  message: CommentMessage;
+  commentId?: string;
+  /** Only needed when the parent is not loaded, such as following a deep link. */
+  threadId?: string;
+  /** Only needed when the parent is not loaded. */
+  fieldPath?: string | Path;
+  /** Required when the parent is not loaded. */
+  status?: CommentStatus;
+}
+/** @beta */
+interface UpdateCommentOptions extends DatasetHandle {
+  commentId: string;
+  message: CommentMessage;
+}
+/** @beta */
+interface SetCommentStatusOptions extends DatasetHandle {
+  /** The thread's first comment. Replies follow their parent. */
+  commentId: string;
+  status: CommentStatus;
+}
+/** @beta */
+interface RemoveCommentOptions extends DatasetHandle {
+  commentId: string;
+}
+/**
+ * Starts a thread on a document, or on one of its fields.
+ *
+ * Creates the project's comments dataset if this is the first comment anywhere
+ * in it. The comment appears locally before the server confirms it; if the
+ * write fails it stays, carrying `_state.createError`, and retrying with the
+ * same `commentId` replaces it.
+ *
+ * @beta
+ */
+declare const createComment: (instance: SanityInstance, options: CreateCommentOptions) => Promise<Comment>;
+/**
+ * Adds a reply to an existing thread.
+ *
+ * The thread and field are taken from the parent comment, so a reply always
+ * matches the same list as the comment it answers. Supply them only when the
+ * parent is not loaded.
+ *
+ * @beta
+ */
+declare const replyToComment: (instance: SanityInstance, options: ReplyToCommentOptions) => Promise<Comment>;
+/**
+ * Rewrites a comment's message and stamps `lastEditedAt`.
+ * @beta
+ */
+declare const updateComment: (instance: SanityInstance, options: UpdateCommentOptions) => Promise<void>;
+/**
+ * Resolves or reopens a thread.
+ *
+ * Pass the thread's first comment: replies follow it, patched server-side in
+ * one query so a reply created by someone else at the same moment is caught
+ * too.
+ *
+ * @beta
+ */
+declare const setCommentStatus: (instance: SanityInstance, options: SetCommentStatusOptions) => Promise<void>;
+/**
+ * Deletes a comment, and its replies when it starts a thread.
+ * @beta
+ */
+declare const removeComment: (instance: SanityInstance, options: RemoveCommentOptions) => Promise<void>;
+/**
+ * Which comments to read.
+ * @beta
+ */
+interface CommentsOptions extends DocumentHandle {
+  /**
+   * Narrow to one field. Omit to get every comment on the document.
+   */
+  fieldPath?: string | Path;
+  /** Narrow to open or resolved threads. Omit for both. */
+  status?: CommentStatus;
+}
+/** @beta */
+interface ResolveCommentsOptions extends CommentsOptions {
+  signal?: AbortSignal;
+}
+/**
+ * A stable string standing for one set of read options.
+ *
+ * Only React needs this: it holds one state source steady across renders and
+ * defers swapping to a new one while the previous list is still on screen.
+ * `fieldPath` is normalised on the way in, so a path array and the equivalent
+ * string address the same list.
+ *
+ * @internal
+ */
+declare function getCommentsOptionsKey(options: CommentsOptions): string;
+/** @internal */
+declare function parseCommentsOptionsKey(key: string): CommentsOptions;
+/**
+ * Every comment on a document, newest first.
+ *
+ * `undefined` until the first snapshot arrives. Replies are included; use
+ * {@link getCommentThreadsState} to read them grouped.
+ *
+ * @beta
+ */
+declare const getCommentsState: (instance: SanityInstance, options: CommentsOptions) => StateSource<Comment[] | undefined>;
+/**
+ * Threads on a document, newest thread first, each with its replies oldest first.
+ *
+ * A thread's `status` and `fieldPath` come from its first comment, so filtering
+ * by either selects whole threads rather than individual replies.
+ *
+ * @beta
+ */
+declare const getCommentThreadsState: (instance: SanityInstance, options: CommentsOptions) => StateSource<CommentThread[] | undefined>;
+/**
+ * Waits for a document's comments to load.
+ *
+ * Holds a subscriber only while resolving, so a component that suspends on this
+ * and then errors before mounting does not strand the list. Throw the promise
+ * for Suspense, then read through {@link getCommentsState}.
+ *
+ * @beta
+ */
+declare const resolveComments: (instance: SanityInstance, options: ResolveCommentsOptions) => Promise<Comment[]>;
+/**
+ * Waits for a document's comments to load, grouped into threads.
+ * @beta
+ */
+declare const resolveCommentThreads: (instance: SanityInstance, options: ResolveCommentsOptions) => Promise<CommentThread[]>;
+/**
+ * Creates or validates a `DocumentHandle` object.
+ * Ensures the provided object conforms to the `DocumentHandle` interface.
+ * @param handle - The object containing document identification properties.
+ * @returns The validated `DocumentHandle` object.
+ * @public
+ */
+declare function createDocumentHandle<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(handle: DocumentHandle<TDocumentType, TDataset, TProjectId>): DocumentHandle<TDocumentType, TDataset, TProjectId>;
+/**
+ * Creates or validates a `DocumentTypeHandle` object.
+ * Ensures the provided object conforms to the `DocumentTypeHandle` interface.
+ * @param handle - The object containing document type identification properties.
+ * @returns The validated `DocumentTypeHandle` object.
+ * @public
+ */
+declare function createDocumentTypeHandle<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(handle: DocumentTypeHandle<TDocumentType, TDataset, TProjectId>): DocumentTypeHandle<TDocumentType, TDataset, TProjectId>;
+/**
+ * Creates or validates a `ProjectHandle` object.
+ * Ensures the provided object conforms to the `ProjectHandle` interface.
+ * @param handle - The object containing project identification properties.
+ * @returns The validated `ProjectHandle` object.
+ * @public
+ */
+declare function createProjectHandle<TProjectId extends string = string>(handle: ProjectHandle<TProjectId>): ProjectHandle<TProjectId>;
+/**
+ * Creates or validates a `DatasetHandle` object.
+ * Ensures the provided object conforms to the `DatasetHandle` interface.
+ * @param handle - The object containing dataset identification properties.
+ * @returns The validated `DatasetHandle` object.
+ * @public
+ */
+declare function createDatasetHandle<TDataset extends string = string, TProjectId extends string = string>(handle: DatasetHandle<TDataset, TProjectId>): DatasetHandle<TDataset, TProjectId>;
+/**
+ * Logging infrastructure for the Sanity SDK
+ *
+ * Provides multi-level, namespace-based logging for both SDK users and maintainers.
+ * In production builds, all logging can be stripped via tree-shaking.
+ *
+ * @example SDK User
+ * ```ts
+ * import {configureLogging} from '@sanity/sdk'
+ *
+ * configureLogging({
+ *   level: 'info',
+ *   namespaces: ['auth', 'document']
+ * })
+ * ```
+ *
+ * @example SDK Maintainer
+ * ```ts
+ * configureLogging({
+ *   level: 'trace',
+ *   namespaces: ['*'],
+ *   internal: true
+ * })
+ * ```
+ */
+/**
+ * Log levels in order of verbosity (least to most)
+ * - error: Critical failures that prevent operation
+ * - warn: Issues that may cause problems but don't stop execution
+ * - info: High-level informational messages (SDK user level)
+ * - debug: Detailed debugging information (maintainer level)
+ * - trace: Very detailed tracing (maintainer level, includes RxJS streams)
+ * @public
+ */
+type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+/**
+ * Log namespaces organize logs by functional domain
+ *
+ * @remarks
+ * This is an extensible string type. As logging is added to more modules,
+ * additional namespaces will be recognized. Currently implemented namespaces
+ * will be documented as they are added.
+ * @internal
+ */
+type LogNamespace = string;
+/**
+ * Configuration for the logging system
+ * @public
+ */
+interface LoggerConfig {
+  /**
+   * Minimum log level to output
+   * @defaultValue 'warn'
+   */
+  level?: LogLevel;
+  /**
+   * Namespaces to enable. Use ['*'] for all namespaces
+   * @defaultValue []
+   * @remarks
+   * Available namespaces depend on which modules have logging integrated.
+   * Check the SDK documentation for the current list of instrumented modules.
+   * @example ['auth', 'document']
+   */
+  namespaces?: string[];
+  /**
+   * Enable internal/maintainer-level logging
+   * Shows RxJS streams, store internals, etc.
+   * @defaultValue false
+   */
+  internal?: boolean;
+  /**
+   * Custom log handler (for testing or custom output)
+   * @defaultValue console methods
+   */
+  handler?: LogHandler;
+  /**
+   * Enable timestamps in log output
+   * @defaultValue true
+   */
+  timestamps?: boolean;
+  /**
+   * Enable in production builds
+   * @defaultValue false
+   */
+  enableInProduction?: boolean;
+}
+/**
+ * Custom log handler interface
+ *
+ * @internal
+ */
+interface LogHandler {
+  error: (message: string, context?: LogContext) => void;
+  warn: (message: string, context?: LogContext) => void;
+  info: (message: string, context?: LogContext) => void;
+  debug: (message: string, context?: LogContext) => void;
+  trace: (message: string, context?: LogContext) => void;
+}
+/**
+ * Context object attached to log messages
+ *
+ * This interface allows you to attach arbitrary contextual data to log messages.
+ * The index signature `[key: string]: unknown` enables you to add any custom
+ * properties relevant to your log entry (e.g., `userId`, `documentId`, `action`, etc.).
+ *
+ * **Sensitive data sanitization:**
+ * Top-level keys containing sensitive names (`token`, `password`, `secret`, `apiKey`,
+ * `authorization`) are automatically redacted to `[REDACTED]` in log output.
+ *
+ * @example
+ * ```ts
+ * logger.info('User logged in', {
+ *   userId: '123',          // Custom context
+ *   action: 'login',        // Custom context
+ *   token: 'secret'         // Will be redacted to [REDACTED]
+ * })
+ * ```
+ *
+ * @internal
+ */
+interface LogContext {
+  /**
+   * Custom context properties that provide additional information about the log entry.
+   * Any key-value pairs can be added here (e.g., userId, documentId, requestId, etc.).
+   * Keys with sensitive names (token, password, secret, apiKey, authorization) are
+   * automatically sanitized.
+   */
+  [key: string]: unknown;
+  /** Error object if logging an error */
+  error?: Error | unknown;
+  /** Duration in milliseconds for timed operations */
+  duration?: number;
+  /** Stack trace for debugging */
+  stack?: string;
+  /** Instance context (automatically added when available) */
+  instanceContext?: InstanceContext;
+}
+/**
+ * Instance context information automatically added to logs
+ * @internal
+ */
+interface InstanceContext {
+  /** Unique instance ID */
+  instanceId?: string;
+  /** Project ID */
+  projectId?: string;
+  /** Dataset name */
+  dataset?: string;
+}
+/**
+ * Logger instance for a specific namespace
+ * @internal
+ */
+interface Logger {
+  readonly namespace: string;
+  error: (message: string, context?: LogContext) => void;
+  warn: (message: string, context?: LogContext) => void;
+  info: (message: string, context?: LogContext) => void;
+  debug: (message: string, context?: LogContext) => void;
+  trace: (message: string, context?: LogContext) => void;
+  /** Check if a log level is enabled (for performance-sensitive code) */
+  isLevelEnabled: (level: LogLevel) => boolean;
+  /** Create a child logger with extended context */
+  child: (context: LogContext) => Logger;
+  /** Get the instance context if available */
+  getInstanceContext: () => InstanceContext | undefined;
+}
+/**
+ * Configure logging for the Sanity SDK
+ *
+ * This function allows you to control what logs are output by the SDK,
+ * making it easier to debug issues in development or production.
+ *
+ * @remarks
+ * **Zero-Config via Environment Variable (Recommended):**
+ *
+ * The SDK automatically reads the `DEBUG` environment variable, making it
+ * easy to enable logging without code changes:
+ *
+ * ```bash
+ * # Enable all SDK logging at debug level
+ * DEBUG=sanity:* npm start
+ *
+ * # Enable specific namespaces
+ * DEBUG=sanity:auth,sanity:document npm start
+ *
+ * # Enable trace level for all namespaces
+ * DEBUG=sanity:trace:* npm start
+ *
+ * # Enable internal/maintainer logs
+ * DEBUG=sanity:*:internal npm start
+ * ```
+ *
+ * This matches the pattern used by Sanity CLI and Studio, making it familiar
+ * and easy for support teams to help troubleshoot issues.
+ *
+ * **Programmatic Configuration (Advanced):**
+ *
+ * For more control (custom handlers, dynamic configuration), call this function
+ * explicitly. Programmatic configuration overrides environment variables.
+ *
+ * **For Application Developers:**
+ * Use `info`, `warn`, or `error` levels to see high-level SDK activity
+ * without being overwhelmed by internal details.
+ *
+ * **For SDK Maintainers:**
+ * Use `debug` or `trace` levels with `internal: true` to see detailed
+ * information about store operations, RxJS streams, and state transitions.
+ *
+ * **Instance Context:**
+ * Logs automatically include instance information (projectId, dataset, instanceId)
+ * when available, making it easier to debug multi-instance scenarios:
+ * ```
+ * [INFO] [auth] [project:abc] [dataset:production] User logged in
+ * ```
+ *
+ * **Available Namespaces:**
+ * - `sdk` - SDK initialization, configuration, and lifecycle
+ * - `auth` - Authentication and authorization (when instrumented in the future)
+ * - And more as logging is added to modules
+ *
+ * @example Zero-config via environment variable (recommended for debugging)
+ * ```bash
+ * # Just set DEBUG and run your app - no code changes needed!
+ * DEBUG=sanity:* npm start
+ * ```
+ *
+ * @example Programmatic configuration (application developer)
+ * ```ts
+ * import {configureLogging} from '@sanity/sdk'
+ *
+ * // Log warnings and errors for auth and document operations
+ * configureLogging({
+ *   level: 'warn',
+ *   namespaces: ['auth', 'document']
+ * })
+ * ```
+ *
+ * @example Programmatic configuration (SDK maintainer)
+ * ```ts
+ * import {configureLogging} from '@sanity/sdk'
+ *
+ * // Enable all logs including internal traces
+ * configureLogging({
+ *   level: 'trace',
+ *   namespaces: ['*'],
+ *   internal: true
+ * })
+ * ```
+ *
+ * @example Custom handler (for testing)
+ * ```ts
+ * import {configureLogging} from '@sanity/sdk'
+ *
+ * const logs: string[] = []
+ * configureLogging({
+ *   level: 'info',
+ *   namespaces: ['*'],
+ *   handler: {
+ *     error: (msg) => logs.push(msg),
+ *     warn: (msg) => logs.push(msg),
+ *     info: (msg) => logs.push(msg),
+ *     debug: (msg) => logs.push(msg),
+ *     trace: (msg) => logs.push(msg),
+ *   }
+ * })
+ * ```
+ *
+ * @public
+ */
+declare function configureLogging(config: LoggerConfig): void;
+/**
+ * Fetcher for a project's datasets (`GET /datasets`), on the shared fetcher
+ * cache.
+ *
+ * @internal
+ */
+declare const datasets: Fetcher<[options?: ProjectHandle<string> | undefined], DatasetsResponse>;
+/**
+ * Represents an action to create a new document.
+ * Specifies the document type and optionally a document ID (which will be treated as the published ID).
+ * @beta
+ */
+interface CreateDocumentAction<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string> extends DocumentTypeHandle<TDocumentType, TDataset, TProjectId> {
+  type: 'document.create';
+  /**
+   * Optional initial field values for the document.
+   * These values will be set when the document is created.
+   * System fields (_id, _type, _rev, _createdAt, _updatedAt) are omitted as they are set automatically.
+   */
+  initialValue?: Partial<Omit<SanityDocument$2<TDocumentType, `${TProjectId}.${TDataset}`>, '_id' | '_type' | '_rev' | '_createdAt' | '_updatedAt'>>;
+}
+/**
+ * Represents an action to delete an existing document.
+ * Requires the full document handle including the document ID.
+ * @beta
+ */
+interface DeleteDocumentAction<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string> extends DocumentHandle<TDocumentType, TDataset, TProjectId> {
+  type: 'document.delete';
+}
+/**
+ * Represents an action to edit an existing document using patches.
+ * Requires the full document handle and an array of patch operations.
+ * @beta
+ */
+interface EditDocumentAction<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string> extends DocumentHandle<TDocumentType, TDataset, TProjectId> {
+  type: 'document.edit';
+  patches?: PatchOperations[];
+  /**
+   * When `true`, the given `patches` are forwarded verbatim to the server and
+   * applied as-is locally, instead of being re-derived by diffing document
+   * snapshots. This preserves the operational intent of the patches (e.g.
+   * keyed array inserts/unsets), which lets concurrent edits from other
+   * clients interleave coherently instead of being overwritten by
+   * position-based patches computed from a stale snapshot.
+   *
+   * Use this when the patches were produced by an editor that tracks its own
+   * operations (e.g. a collaborative text editor). During a rebase onto a
+   * changed remote document, preserved patches are re-applied operationally;
+   * if a patch can no longer apply, the transaction is skipped and reported
+   * as a `rebase-error` document event.
+   */
+  preserveOperations?: boolean;
+}
+/**
+ * Represents an action to publish the draft version of a document.
+ * Requires the full document handle.
+ * @beta
+ */
+interface PublishDocumentAction<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string> extends DocumentHandle<TDocumentType, TDataset, TProjectId> {
+  type: 'document.publish';
+}
+/**
+ * Represents an action to unpublish a document, moving its published content to a draft.
+ * Requires the full document handle.
+ * @beta
+ */
+interface UnpublishDocumentAction<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string> extends DocumentHandle<TDocumentType, TDataset, TProjectId> {
+  type: 'document.unpublish';
+}
+/**
+ * Represents an action to discard the draft changes of a document.
+ * Requires the full document handle.
+ * @beta
+ */
+interface DiscardDocumentAction<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string> extends DocumentHandle<TDocumentType, TDataset, TProjectId> {
+  type: 'document.discard';
+}
+/**
+ * Union type representing all possible document actions within the SDK.
+ * @beta
+ */
+type DocumentAction<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string> = CreateDocumentAction<TDocumentType, TDataset, TProjectId> | DeleteDocumentAction<TDocumentType, TDataset, TProjectId> | EditDocumentAction<TDocumentType, TDataset, TProjectId> | PublishDocumentAction<TDocumentType, TDataset, TProjectId> | UnpublishDocumentAction<TDocumentType, TDataset, TProjectId> | DiscardDocumentAction<TDocumentType, TDataset, TProjectId>;
+/**
+ * Union of every action accepted by `applyDocumentActions` — both document-
+ * level actions and release-lifecycle actions.
+ * @beta
+ */
+type Action<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string> = DocumentAction<TDocumentType, TDataset, TProjectId> | ReleaseAction;
+/**
+ * Creates a `CreateDocumentAction` object.
+ * @param doc - A handle identifying the document type, dataset, and project. An optional `documentId` can be provided.
+ * @param initialValue - Optional initial field values for the document. (System fields are omitted as they are set automatically.)
+ * @returns A `CreateDocumentAction` object ready for dispatch.
+ * @beta
+ */
+declare function createDocument<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(doc: DocumentTypeHandle<TDocumentType, TDataset, TProjectId>, initialValue?: Partial<Omit<SanityDocument$2<TDocumentType, `${TProjectId}.${TDataset}`>, '_id' | '_type' | '_rev' | '_createdAt' | '_updatedAt'>>): CreateDocumentAction<TDocumentType, TDataset, TProjectId>;
+/**
+ * Creates a `DeleteDocumentAction` object.
+ * @param doc - A handle uniquely identifying the document to be deleted.
+ * @returns A `DeleteDocumentAction` object ready for dispatch.
+ * @beta
+ */
+declare function deleteDocument<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(doc: DocumentHandle<TDocumentType, TDataset, TProjectId>): DeleteDocumentAction<TDocumentType, TDataset, TProjectId>;
+/**
+ * Options for creating an `EditDocumentAction`.
+ * @beta
+ */
+interface EditDocumentOptions {
+  /**
+   * Forward the given patches verbatim instead of re-deriving them by
+   * diffing document snapshots. See {@link EditDocumentAction.preserveOperations}.
+   */
+  preserveOperations?: boolean;
+}
+/**
+ * Creates an `EditDocumentAction` object with patches for modifying a document.
+ * Accepts patches in either the standard `PatchOperations` format or as a `SanityMutatePatchMutation` from `@sanity/mutate`.
+ *
+ * @param doc - A handle uniquely identifying the document to be edited.
+ * @param sanityMutatePatch - A patch mutation object from `@sanity/mutate`.
+ * @param options - Options controlling how the patches are processed.
+ * @returns An `EditDocumentAction` object ready for dispatch.
+ * @beta
+ */
+declare function editDocument<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(doc: DocumentHandle<TDocumentType, TDataset, TProjectId>, sanityMutatePatch: PatchMutation, options?: EditDocumentOptions): EditDocumentAction<TDocumentType, TDataset, TProjectId>;
+/**
+ * Creates an `EditDocumentAction` object with patches for modifying a document.
+ *
+ * @param doc - A handle uniquely identifying the document to be edited.
+ * @param patches - A single patch operation or an array of patch operations.
+ * @param options - Options controlling how the patches are processed.
+ * @returns An `EditDocumentAction` object ready for dispatch.
+ * @beta
+ */
+declare function editDocument<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(doc: DocumentHandle<TDocumentType, TDataset, TProjectId>, patches?: PatchOperations | PatchOperations[], options?: EditDocumentOptions): EditDocumentAction<TDocumentType, TDataset, TProjectId>;
+/**
+ * Creates a `PublishDocumentAction` object.
+ * @param doc - A handle uniquely identifying the document to be published.
+ * @returns A `PublishDocumentAction` object ready for dispatch.
+ * @beta
+ */
+declare function publishDocument<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(doc: DocumentHandle<TDocumentType, TDataset, TProjectId>): PublishDocumentAction<TDocumentType, TDataset, TProjectId>;
+/**
+ * Creates an `UnpublishDocumentAction` object.
+ * @param doc - A handle uniquely identifying the document to be unpublished.
+ * @returns An `UnpublishDocumentAction` object ready for dispatch.
+ * @beta
+ */
+declare function unpublishDocument<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(doc: DocumentHandle<TDocumentType, TDataset, TProjectId>): UnpublishDocumentAction<TDocumentType, TDataset, TProjectId>;
+/**
+ * Creates a `DiscardDocumentAction` object.
+ * @param doc - A handle uniquely identifying the document whose draft changes are to be discarded.
+ * @returns A `DiscardDocumentAction` object ready for dispatch.
+ * @beta
+ */
+declare function discardDocument<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(doc: DocumentHandle<TDocumentType, TDataset, TProjectId>): DiscardDocumentAction<TDocumentType, TDataset, TProjectId>;
+/**
+ * Creates a new release. The `releaseId` must be unique within the current
+ * retention period.
+ * @beta
+ */
+interface CreateReleaseAction extends ReleaseHandle {
+  type: 'release.create';
+  metadata: ReleaseDocument['metadata'];
+}
+/**
+ * Patches the metadata of an existing release.
+ * @beta
+ */
+interface EditReleaseAction extends ReleaseHandle {
+  type: 'release.edit';
+  patch: PatchOperations;
+}
+/**
+ * Publishes all version documents in a release.
+ * @beta
+ */
+interface PublishReleaseAction extends ReleaseHandle {
+  type: 'release.publish';
+}
+/**
+ * Schedules a release to be published at the given UTC time. Locks the
+ * version documents server-side until the release is unscheduled or published.
+ * @beta
+ */
+interface ScheduleReleaseAction extends ReleaseHandle {
+  type: 'release.schedule';
+  publishAt: string;
+}
+/**
+ * Unschedules a release that was previously scheduled, returning it to the
+ * active editable state.
+ * @beta
+ */
+interface UnscheduleReleaseAction extends ReleaseHandle {
+  type: 'release.unschedule';
+}
+/**
+ * Archives an active release. Version documents within the release are
+ * removed and no longer queryable, though still recoverable through history
+ * during the retention period.
+ * @beta
+ */
+interface ArchiveReleaseAction extends ReleaseHandle {
+  type: 'release.archive';
+}
+/**
+ * Restores an archived release. Only possible during the retention period.
+ * @beta
+ */
+interface UnarchiveReleaseAction extends ReleaseHandle {
+  type: 'release.unarchive';
+}
+/**
+ * Permanently deletes an archived or published release. To remove an active
+ * release, use the archive action first.
+ * @beta
+ */
+interface DeleteReleaseAction extends ReleaseHandle {
+  type: 'release.delete';
+}
+/**
+ * Union of all release actions that can be dispatched alongside document
+ * actions through `applyDocumentActions`.
+ * @beta
+ */
+type ReleaseAction = CreateReleaseAction | EditReleaseAction | PublishReleaseAction | ScheduleReleaseAction | UnscheduleReleaseAction | ArchiveReleaseAction | UnarchiveReleaseAction | DeleteReleaseAction;
+/** @beta */
+declare function createRelease(handle: ReleaseHandle, metadata?: ReleaseDocument['metadata']): CreateReleaseAction;
+/** @beta */
+declare function editRelease(handle: ReleaseHandle, patch: PatchOperations): EditReleaseAction;
+/** @beta */
+declare function publishRelease(handle: ReleaseHandle): PublishReleaseAction;
+/** @beta */
+declare function scheduleRelease(handle: ReleaseHandle, publishAt: string): ScheduleReleaseAction;
+/** @beta */
+declare function unscheduleRelease(handle: ReleaseHandle): UnscheduleReleaseAction;
+/** @beta */
+declare function archiveRelease(handle: ReleaseHandle): ArchiveReleaseAction;
+/** @beta */
+declare function unarchiveRelease(handle: ReleaseHandle): UnarchiveReleaseAction;
+/** @beta */
+declare function deleteRelease(handle: ReleaseHandle): DeleteReleaseAction;
+/**
+ * Split the entire path string on dots "outside" of any brackets.
+ *
+ * For example:
+ * ```
+ * "friends[0].name"
+ * ```
+ *
+ * becomes:
+ *
+ * ```
+ * [...ParseSegment<"friends[0]">, ...ParseSegment<"name">]
+ * ```
+ *
+ * (We use a simple recursion that splits on the first dot.)
+ */
+type PathParts<TPath extends string> = TPath extends `${infer Head}.${infer Tail}` ? [Head, ...PathParts<Tail>] : TPath extends '' ? [] : [TPath];
+/**
+ * Given a type T and an array of "access keys" Parts, recursively index into T.
+ *
+ * If a part is a key, it looks up that property.
+ * If T is an array and the part is a number, it "indexes" into the element type.
+ */
+type DeepGet<TValue, TPath extends readonly (string | number)[]> = TPath extends [] ? TValue : TPath extends readonly [infer THead, ...infer TTail] ? DeepGet<TValue extends undefined | null ? undefined : THead extends keyof TValue ? TValue[THead] : THead extends number ? TValue extends readonly (infer TElement)[] ? TElement | undefined : undefined : undefined // Key/index doesn't exist
+, TTail extends readonly (string | number)[] ? TTail : []> : never;
+/**
+ * Given a document type TDocument and a JSON Match path string TPath,
+ * compute the type found at that path.
+ * @beta
+ */
+type JsonMatch<TDocument, TPath extends string> = DeepGet<TDocument, PathParts<TPath>>;
+/**
+ * Represents a set of document that will go into `applyMutations`. Before
+ * applying a mutation, it's expected that all relevant documents that the
+ * mutations affect are included, including those that do not exist yet.
+ * Documents that don't exist have a `null` value.
+ */
+type DocumentSet<TDocument extends SanityDocument$1 = SanityDocument$1> = { [TDocumentId in string]?: TDocument | null; };
+type Grant = 'read' | 'update' | 'create' | 'history';
+/** @beta */
+interface PermissionDeniedReason {
+  type: 'precondition' | 'access';
+  message: string;
+  documentId?: string;
+}
+/** @beta */
+type DocumentPermissionsResult = {
+  allowed: false;
+  message: string;
+  reasons: PermissionDeniedReason[];
+} | {
+  allowed: true;
+  message?: undefined;
+  reasons?: undefined;
+};
+interface SharedListener {
+  events: Observable<ListenEvent<SanityDocument>>;
+  dispose: () => void;
+}
+interface DocumentStoreState {
+  documentStates: { [TDocumentId in string]?: DocumentState; };
+  queued: QueuedTransaction[];
+  applied: AppliedTransaction[];
+  outgoing?: OutgoingTransaction;
+  grants?: Record<Grant, ExprNode>;
+  /**
+   * The current user's identity (their user ID).
+   */
+  identity?: string;
+  error?: unknown;
+  sharedListener: SharedListener;
+  fetchDocument: (documentId: string) => Observable<SanityDocument$2 | null>;
+  events: Subject<DocumentEvent>;
+}
+interface DocumentState {
+  id: string;
+  /**
+   * the "remote" local copy that matches the server. represents the last known
+   * server state. this gets updated every time we confirm remote patches
+   */
+  remote?: SanityDocument$2 | null;
+  /**
+   * the current ephemeral working copy that includes local optimistic changes
+   * that have not yet been confirmed by the server
+   */
+  local?: SanityDocument$2 | null;
+  /**
+   * the revision that our remote document is at
+   */
+  remoteRev?: string | null;
+  /**
+   * Array of subscription IDs. This document state will be deleted if there are
+   * no subscribers.
+   */
+  subscriptions: string[];
+  /**
+   * An object keyed by transaction ID of revisions sent out but that have not
+   * yet been verified yet. When an applied transaction is transitioned to an
+   * outgoing transaction, it also adds unverified revisions for each document
+   * that is part of that outgoing transaction. Transactions are submitted to
+   * the server with a locally generated transaction ID. This way we can observe
+   * when our transaction comes back through the shared listener. Each listener
+   * event that comes back contains a `previousRev`. If we see our own
+   * transaction with a different `previousRev` than expected, we can rebase our
+   * local transactions on top of this new remote.
+   */
+  unverifiedRevisions?: { [TTransactionId in string]?: UnverifiedDocumentRevision; };
+  /**
+   * transaction IDs recently submitted by this client for this document,
+   * newest last. used to label `remote-patches` events with the correct
+   * `origin` even after the corresponding `unverifiedRevisions` entry has
+   * been pruned (e.g. by a sync event that raced the listener echo). capped
+   * to the most recent entries.
+   */
+  recentOwnTransactionIds?: string[];
+}
+/**
+ * @beta
+ * Options for specifying a document and optionally a path within it.
+ */
+interface DocumentOptions<TPath extends string | undefined = undefined, TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string> extends DocumentHandle<TDocumentType, TDataset, TProjectId> {
+  path?: TPath;
+}
+/** @beta */
+declare function getDocumentState<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(instance: SanityInstance, options: DocumentOptions<undefined, TDocumentType, TDataset, TProjectId>): StateSource<SanityDocument$2<TDocumentType, `${TProjectId}.${TDataset}`> | undefined | null>;
+/** @beta */
+declare function getDocumentState<TPath extends string = string, TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(instance: SanityInstance, options: DocumentOptions<TPath, TDocumentType, TDataset, TProjectId>): StateSource<JsonMatch<SanityDocument$2<TDocumentType, `${TProjectId}.${TDataset}`>, TPath> | undefined>;
+/** @beta */
+declare function getDocumentState<TData>(instance: SanityInstance, options: DocumentOptions<string | undefined>): StateSource<TData | undefined | null>;
+/** @beta */
+declare function resolveDocument<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(instance: SanityInstance, docHandle: DocumentHandle<TDocumentType, TDataset, TProjectId>): Promise<SanityDocument$2<TDocumentType, `${TProjectId}.${TDataset}`> | null>;
+/** @beta */
+declare function resolveDocument<TData extends SanityDocument$2>(instance: SanityInstance, docHandle: DocumentHandle<string, string, string>): Promise<TData | null>;
+/** @beta */
+declare const getDocumentSyncStatus: BoundStoreAction<DocumentStoreState, [doc: DocumentHandle<string, string, string>], StateSource<boolean | undefined>>;
+type PermissionsStateOptions = {
+  resource?: DocumentResource;
+  actions: DocumentAction[];
+};
+/** @beta */
+declare const getPermissionsState: BoundStoreAction<DocumentStoreState, [PermissionsStateOptions], StateSource<DocumentPermissionsResult>>;
+/** @beta */
+declare const resolvePermissions: BoundStoreAction<DocumentStoreState, [options: PermissionsStateOptions], Promise<DocumentPermissionsResult>>;
+/** @beta */
+declare const subscribeDocumentEvents: BoundStoreAction<DocumentStoreState, [options: {
+  resource?: DocumentResource;
+  eventHandler: (e: DocumentEvent) => void;
+}], () => void>;
+type ActionMap = {
+  create: 'sanity.action.document.version.create';
+  discard: 'sanity.action.document.version.discard';
+  unpublish: 'sanity.action.document.unpublish';
+  delete: 'sanity.action.document.delete';
+  edit: 'sanity.action.document.edit';
+  publish: 'sanity.action.document.publish';
+  releaseCreate: 'sanity.action.release.create';
+  releaseEdit: 'sanity.action.release.edit';
+  releasePublish: 'sanity.action.release.publish';
+  releaseSchedule: 'sanity.action.release.schedule';
+  releaseUnschedule: 'sanity.action.release.unschedule';
+  releaseArchive: 'sanity.action.release.archive';
+  releaseUnarchive: 'sanity.action.release.unarchive';
+  releaseDelete: 'sanity.action.release.delete';
+};
+type OptimisticLock = {
+  ifDraftRevisionId?: string;
+  ifPublishedRevisionId?: string;
+};
+interface ReleaseMetadataPayload {
+  title?: string;
+  description?: string;
+  intendedPublishAt?: string;
+  releaseType?: 'asap' | 'scheduled' | 'undecided';
+  cardinality?: 'one' | 'many';
+}
+type HttpAction = {
+  actionType: ActionMap['create'];
+  publishedId: string;
+  attributes: SanityDocumentLike;
+} | {
+  actionType: ActionMap['discard'];
+  versionId: string;
+  purge?: boolean;
+} | {
+  actionType: ActionMap['unpublish'];
+  draftId: string;
+  publishedId: string;
+} | {
+  actionType: ActionMap['delete'];
+  publishedId: string;
+  includeDrafts?: string[];
+} | {
+  actionType: ActionMap['edit'];
+  draftId: string;
+  publishedId: string;
+  patch: PatchOperations;
+} | ({
+  actionType: ActionMap['publish'];
+  draftId: string;
+  publishedId: string;
+} & OptimisticLock) | {
+  actionType: ActionMap['releaseCreate'];
+  releaseId: string;
+  metadata?: ReleaseMetadataPayload;
+} | {
+  actionType: ActionMap['releaseEdit'];
+  releaseId: string;
+  patch: PatchOperations;
+} | {
+  actionType: ActionMap['releasePublish'];
+  releaseId: string;
+} | {
+  actionType: ActionMap['releaseSchedule'];
+  releaseId: string;
+  publishAt: string;
+} | {
+  actionType: ActionMap['releaseUnschedule'];
+  releaseId: string;
+} | {
+  actionType: ActionMap['releaseArchive'];
+  releaseId: string;
+} | {
+  actionType: ActionMap['releaseUnarchive'];
+  releaseId: string;
+} | {
+  actionType: ActionMap['releaseDelete'];
+  releaseId: string;
+};
+/**
+ * Represents a transaction that is queued to be applied but has not yet been
+ * applied. A transaction will remain in a queued state until all required
+ * documents for the transactions are available locally.
+ */
+interface QueuedTransaction {
+  /**
+   * the ID of this transaction. this is generated client-side.
+   */
+  transactionId: string;
+  /**
+   * the high-level actions associated with this transaction. note that these
+   * actions don't mention draft IDs and is meant to abstract away the draft
+   * model from users.
+   */
+  actions: Action[];
+  /**
+   * An optional flag set to disable this transaction from being batched with
+   * other transactions.
+   */
+  disableBatching?: boolean;
+}
+/**
+ * Represents a transaction that has been applied locally but has not been
+ * committed/transitioned-to-outgoing. These transactions are visible to the
+ * user but may be rebased upon a new working document set. Applied transactions
+ * also contain the resulting `outgoingActions` that will be submitted to
+ * Content Lake. These `outgoingActions` depend on the state of the working
+ * documents so they are recomputed on rebase and are only relevant to applied
+ * actions (we cannot compute `outgoingActions` for queued transactions because
+ * we haven't resolved the set of documents the actions are dependent on yet).
+ *
+ * In order to support better conflict resolution, the original `previous` set
+ * is saved as the `base` set.
+ */
+interface AppliedTransaction extends QueuedTransaction {
+  /**
+   * the resulting set of documents after the actions have been applied
+   */
+  working: DocumentSet;
+  /**
+   * the previous set of documents before the action was applied
+   */
+  previous: DocumentSet;
+  /**
+   * the original `previous` document set captured when this action was
+   * originally applied. this is used as a reference point to do a 3-way merge
+   * if this applied transaction ever needs to be reapplied on a different
+   * set of documents.
+   */
+  base: DocumentSet;
+  /**
+   * the `_rev`s from `previous` document set
+   */
+  previousRevs: { [TDocumentId in string]?: string; };
+  /**
+   * a timestamp for when this transaction was applied locally
+   */
+  timestamp: string;
+  /**
+   * the resulting HTTP actions derived from the state of the `working` document
+   * set. these are sent to Content Lake as-is when this transaction is batched
+   * and transitioned into an outgoing transaction.
+   */
+  outgoingActions: HttpAction[];
+  /**
+   * similar to `outgoingActions` but comprised of mutations instead of actions.
+   * Useful for debugging, and is also used by liveEdit documents to send mutations,
+   * since they can't use the Actions API which is pretty dependent on the draft model.
+   */
+  outgoingMutations: Mutation[];
+}
+/**
+ * Represents a set of applied transactions batched into a single outgoing
+ * transaction. An outgoing transaction is the result of batching many applied
+ * actions. An outgoing transaction may be reverted locally if the server
+ * does not accept it.
+ */
+interface OutgoingTransaction extends AppliedTransaction {
+  disableBatching: boolean;
+  batchedTransactionIds: string[];
+}
+interface UnverifiedDocumentRevision {
+  transactionId: string;
+  documentId: string;
+  previousRev: string | undefined;
+  timestamp: string;
+}
+/** @beta Response body from submitting an outgoing transaction (actions or mutations API). */
+type DocumentTransactionSubmissionResult = Awaited<ReturnType<SanityClient['action']>> | MultipleMutationResult;
+/** @beta */
+type DocumentEvent = ActionErrorEvent | TransactionRevertedEvent | TransactionAcceptedEvent | DocumentRebaseErrorEvent | DocumentEditedEvent | DocumentCreatedEvent | DocumentDeletedEvent | DocumentPublishedEvent | DocumentUnpublishedEvent | DocumentDiscardedEvent | DocumentRemotePatchesEvent;
+/**
+ * @beta
+ * Event emitted when a precondition to applying an action fails.
+ * (For example: when trying to edit a document that no longer exists.)
+ */
+interface ActionErrorEvent {
+  type: 'error';
+  documentId: string;
+  transactionId: string;
+  message: string;
+  error: unknown;
+}
+/**
+ * @beta
+ * Event emitted when a transaction is accepted.
+ */
+interface TransactionAcceptedEvent {
+  type: 'accepted';
+  outgoing: OutgoingTransaction;
+  result: DocumentTransactionSubmissionResult;
+}
+/**
+ * @beta
+ * Event emitted when a transaction is reverted.
+ */
+interface TransactionRevertedEvent {
+  type: 'reverted';
+  message: string;
+  error: unknown;
+  outgoing: OutgoingTransaction;
+}
+/**
+ * @beta
+ * Event emitted when an attempt to apply local changes to a modified remote document fails.
+ */
+interface DocumentRebaseErrorEvent {
+  type: 'rebase-error';
+  documentId: string;
+  transactionId: string;
+  message: string;
+  error: unknown;
+}
+/**
+ * @beta
+ * Event emitted when a document is edited.
+ */
+interface DocumentEditedEvent {
+  type: 'edited';
+  documentId: string;
+  outgoing: OutgoingTransaction;
+}
+/**
+ * @beta
+ * Event emitted when a document is created.
+ */
+interface DocumentCreatedEvent {
+  type: 'created';
+  documentId: string;
+  outgoing: OutgoingTransaction;
+}
+/**
+ * @beta
+ * Event emitted when a document is deleted.
+ */
+interface DocumentDeletedEvent {
+  type: 'deleted';
+  documentId: string;
+  outgoing: OutgoingTransaction;
+}
+/**
+ * @beta
+ * Event emitted when a document is published.
+ */
+interface DocumentPublishedEvent {
+  type: 'published';
+  documentId: string;
+  outgoing: OutgoingTransaction;
+}
+/**
+ * @beta
+ * Event emitted when a document is unpublished.
+ */
+interface DocumentUnpublishedEvent {
+  type: 'unpublished';
+  documentId: string;
+  outgoing: OutgoingTransaction;
+}
+/**
+ * @beta
+ * Event emitted when a document version is discarded.
+ */
+interface DocumentDiscardedEvent {
+  type: 'discarded';
+  documentId: string;
+  outgoing: OutgoingTransaction;
+}
+/**
+ * @beta
+ * Event emitted when patches for a document are observed through the listener.
+ *
+ * Unlike the whole-document snapshots the store keeps, these are the raw patch
+ * operations from the transaction that produced the change, preserving the
+ * operational intent of the edit (e.g. keyed array inserts/unsets). Consumers
+ * that maintain their own local state, like collaborative text editors, can
+ * apply these directly instead of diffing document snapshots.
+ *
+ * `origin` is `'local'` when the transaction was submitted by this document
+ * store instance (an own edit observed back through the listener) and
+ * `'remote'` when it came from another client.
+ */
+interface DocumentRemotePatchesEvent {
+  type: 'remote-patches';
+  /** The ID of the document version the patches apply to (e.g. a draft ID). */
+  documentId: string;
+  /** The transaction ID that carried these patches. */
+  transactionId: string;
+  /** The revision the document was at before this transaction. */
+  previousRev?: string;
+  /** The timestamp of the transaction. */
+  timestamp: string;
+  /** The patch operations, rooted at the document. */
+  patches: PatchOperations[];
+  /** Whether the transaction originated from this client or another one. */
+  origin: 'local' | 'remote';
+}
+/** @beta */
+interface ActionsResult<TDocument extends SanityDocument$2 = SanityDocument$2> {
+  transactionId: string;
+  documents: DocumentSet<TDocument>;
+  previous: DocumentSet<TDocument>;
+  previousRevs: {
+    [documentId: string]: string | undefined;
+  };
+  appeared: string[];
+  updated: string[];
+  disappeared: string[];
+  submitted: () => Promise<DocumentTransactionSubmissionResult>;
+}
+/** @beta */
+interface ApplyDocumentActionsOptions {
+  /**
+   * List of actions to apply. Accepts both document actions and release
+   * lifecycle actions because they share the same transaction pipeline.
+   */
+  actions: Action[];
+  /**
+   * The resource to which the documents being acted on belong.
+   */
+  resource?: DocumentResource;
+  /**
+   * Optionally provide an ID to be used as this transaction ID
+   */
+  transactionId?: string;
+  /**
+   * Set this to true to prevent this action from being batched with others.
+   */
+  disableBatching?: boolean;
+}
+/** @beta */
+declare function applyDocumentActions<TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(instance: SanityInstance, options: ApplyDocumentActionsOptions): Promise<ActionsResult<SanityDocument$2<TDocumentType, `${TProjectId}.${TDataset}`>>>;
+/** @beta */
+declare function applyDocumentActions(instance: SanityInstance, options: ApplyDocumentActionsOptions): Promise<ActionsResult>;
+/**
+ * Returns the full release document ID for the given release name.
+ * e.g. `getReleaseDocumentId('my-release') === '_.releases.my-release'`
+ * @beta
+ */
+declare function getReleaseDocumentId(releaseId: string): string;
+/**
+ * @public
+ */
+interface FavoriteStatusResponse {
+  isFavorited: boolean;
+}
+/**
+ * @public
+ */
+interface FavoriteDocumentContext extends DocumentHandle {
+  resourceId: string;
+  resourceType: StudioResource['type'] | MediaResource['type'] | CanvasResource['type'];
+  schemaName?: string;
+}
+/**
+ * Fetcher for a document's favorite status, read from the dashboard over
+ * comlink, on the shared fetcher cache.
+ *
+ * @internal
+ */
+declare const favorites: Fetcher<[context: FavoriteDocumentContext], FavoriteStatusResponse>;
+/**
+ * Input for {@link setFavorite}: the document context plus the desired state.
+ *
+ * @public
+ */
+type SetFavoriteInput = FavoriteDocumentContext & {
+  /** The favorite state to move to: `true` to favorite, `false` to unfavorite. */
+  isFavorited: boolean;
+};
+/**
+ * Sets a document's favorite state over comlink, then invalidates the cached
+ * {@link favorites} status for that document so active readers reconverge on
+ * server truth. The write-side counterpart to {@link favorites}.
+ *
+ * @internal
+ */
+declare const setFavorite: (instance: SanityInstance, input: SetFavoriteInput) => Promise<MutationResult<FavoriteStatusResponse>>;
+/**
+ * Related data the Installations API can embed in a response. Each token adds
+ * a top-level field to the {@link Installation} item.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+type InstallationInclude = 'activeConfig' | 'access' | 'interfaces';
+/**
+ * A resource an installation accesses, embedded when `access` is included.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface InstallationAccess {
+  id: string;
+  resourceType: 'datasets' | 'canvases' | 'dashboards' | 'media-libraries';
+  resourceId: string;
+}
+/**
+ * An interface exposed by an installation, embedded when `interfaces` is
+ * included.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface InstallationInterface {
+  id: string;
+  type: 'app' | 'worker' | 'asset_source' | 'panel';
+  name: string;
+  title: string;
+  version: string;
+  /** Module federation module ID; resolved from the host mf-manifest at runtime */
+  moduleId: string;
+  metadata: {
+    group?: string;
+    priority?: number;
+  } | null;
+}
+/**
+ * The active config of an installation, embedded when `activeConfig` is
+ * included. `null` when nothing is deployed.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface InstallationActiveConfig {
+  id: string;
+  installationId: string;
+  deployedBy: string | null;
+  version: string;
+  isActive: boolean;
+  createdAt: string;
+}
+/**
+ * The always-present fields of an active singleton installation returned by the
+ * Installations API (`/installations`), before any {@link InstallationInclude}.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface InstallationBase {
+  id: string;
+  applicationId: string;
+  organizationId: string;
+  installedBy: string | null;
+  createdAt: string;
+  updatedAt: string;
+  application: {
+    title: string;
+    /** Stable, immutable identity of the installed singleton, distinct from `slug`. */
+    name: string;
+    /** Qualified, globally-unique handle of the installed singleton (e.g. `sanity/<name>`). */
+    reference: string;
+    slug: string | null;
+  };
+}
+/**
+ * An active singleton installation as returned by the Installations API
+ * (`/installations`). `activeConfig`, `access` and `interfaces` are top-level
+ * fields, each present only when the matching {@link InstallationInclude} token
+ * was requested.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+type Installation<Include extends InstallationInclude = never> = InstallationBase & Included<InstallationInclude, 'activeConfig', Include, {
+  activeConfig: InstallationActiveConfig | null;
+}> & Included<InstallationInclude, 'access', Include, {
+  access: InstallationAccess[];
+}> & Included<InstallationInclude, 'interfaces', Include, {
+  interfaces: InstallationInterface[];
+}>;
+/**
+ * Options for listing an organization's installations.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface InstallationsOptions<Include extends InstallationInclude = InstallationInclude> {
+  organizationId: string;
+  include?: Include[];
+  /** Page size (1-100, default 50), or `'none'` to disable pagination */
+  limit?: number | 'none';
+  /** Cursor from a previous response's `nextCursor` */
+  cursor?: string;
+}
+/**
+ * The cursor-paginated envelope returned by `GET /installations`.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+interface InstallationsResponse<Include extends InstallationInclude = never> {
+  nextCursor: string | null;
+  data: Installation<Include>[];
+}
+/**
+ * Fetcher for an organization's installations (`GET /installations`), on the
+ * shared fetcher cache.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+declare const installations: Fetcher<[options: InstallationsOptions<InstallationInclude>], InstallationsResponse<InstallationInclude>>;
+/**
+ * Fetcher for a single installation (`GET /installations/:id`), on the shared
+ * fetcher cache. No pre-seeding from {@link installations}: its list keys
+ * include the organization, which this fetcher's params can't reconstruct.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+declare const installation: Fetcher<[installationId: string, options?: {
+  include?: InstallationInclude[];
+} | undefined], Installation<InstallationInclude>>;
+/** @public */
+interface OrganizationMember {
+  sanityUserId: string;
+  isCurrentUser: boolean;
+  user: {
+    id: string;
+    displayName: string;
+    familyName: string;
+    givenName: string;
+    middleName: string | null;
+    imageUrl: string | null;
+    email: string;
+    loginProvider: string;
+  };
+  roles: Array<{
+    name: string;
+    title: string;
+    description?: string;
+  }>;
+}
+/**
+ * The base fields returned from `/organizations/<id>` for every organization.
+ * @public
+ */
+interface OrganizationBase {
+  id: string;
+  name: string;
+  slug: string | null;
+  createdAt: string;
+  createdByUserId: string;
+  updatedAt: string;
+  deletedAt: string | null;
+  dashboardStatus: 'enabled' | 'disabled';
+  aiFeaturesStatus: 'enabled' | 'disabled';
+  mediaLibraryStatus: 'enabled' | 'disabled';
+  requestAccessStatus: 'allowed' | 'disabled';
+  telemetryConsentStatus: 'allowed' | 'msa_denied' | 'customer_denied';
+  oauthAppsStatus: 'allowed' | 'blocked';
+  defaultRoleName: string;
+  domains: string[] | null;
+}
+/** @public */
+interface OrganizationOptions<IncludeMembers extends boolean = false, IncludeFeatures extends boolean = false> {
+  includeMembers?: IncludeMembers;
+  includeFeatures?: IncludeFeatures;
+  organizationId: string;
+}
+/**
+ * An `Organization` with `members` and/or `features` conditionally included
+ * based on the query options used to fetch it.
+ * @public
+ */
+type Organization<IncludeMembers extends boolean = false, IncludeFeatures extends boolean = false> = OrganizationBase & (boolean extends IncludeMembers ? {
+  members?: OrganizationMember[];
+} : IncludeMembers extends true ? {
+  members: OrganizationMember[];
+} : unknown) & (boolean extends IncludeFeatures ? {
+  features?: string[];
+} : IncludeFeatures extends true ? {
+  features: string[];
+} : unknown);
+/**
+ * Fetcher for a single organization (`GET /organizations/:id`), on the shared
+ * fetcher cache. No pre-seeding from the organizations list: it returns a
+ * subset of the detail fields, and a partial seed would serve as fresh for
+ * the whole stale window.
+ *
+ * @internal
+ */
+declare const organization: Fetcher<[options?: OrganizationOptions<boolean, boolean> | undefined], Organization<boolean, boolean>>;
+/**
+ * The list shape returned from `/organizations`, with `members` and/or
+ * `features` conditionally included based on the query options used.
+ * @public
+ */
+type Organizations<IncludeMembers extends boolean = false, IncludeFeatures extends boolean = false> = (Pick<OrganizationBase, 'id' | 'name' | 'slug' | 'createdAt' | 'updatedAt' | 'defaultRoleName' | 'dashboardStatus' | 'aiFeaturesStatus'> & (boolean extends IncludeMembers ? {
+  members?: OrganizationMember[];
+} : IncludeMembers extends true ? {
+  members: OrganizationMember[];
+} : unknown) & (boolean extends IncludeFeatures ? {
+  features?: string[];
+} : IncludeFeatures extends true ? {
+  features: string[];
+} : unknown))[];
+/** @public */
+interface OrganizationsOptions<IncludeMembers extends boolean = false, IncludeFeatures extends boolean = false> extends Omit<OrganizationOptions<IncludeMembers, IncludeFeatures>, 'organizationId'> {
+  /**
+   * When `true`, includes organisations the user has access to via
+   * project-level grants, not just direct organisation memberships.
+   */
+  includeImplicitMemberships?: boolean;
+}
+/**
+ * Fetcher for the current user's organizations (`GET /organizations`), on the
+ * shared fetcher cache.
+ *
+ * @internal
+ */
+declare const organizations: Fetcher<[options?: OrganizationsOptions<boolean, boolean> | undefined], Organizations<boolean, boolean>>;
+/**
+ * @public
+ */
+interface SanityUser {
+  sanityUserId: string;
+  profile: UserProfile;
+  memberships: Membership[];
+}
+/**
+ * @public
+ */
+interface Membership {
+  addedAt?: string;
+  resourceType: string;
+  resourceId: string;
+  roleNames: Array<string>;
+  lastSeenAt?: string | null;
+}
+/**
+ * @public
+ */
+interface UserProfile {
+  id: string;
+  displayName: string;
+  email: string;
+  familyName?: string;
+  givenName?: string;
+  middleName?: string | null;
+  imageUrl?: string;
+  provider: string;
+  tosAcceptedAt?: string;
+  createdAt: string;
+  updatedAt?: string;
+  isCurrentUser?: boolean;
+  providerId?: string;
+}
+/**
+ * @public
+ */
+interface GetUsersOptions extends ProjectHandle {
+  resourceType?: 'organization' | 'project';
+  batchSize?: number;
+  organizationId?: string;
+  userId?: string;
+}
+/**
+ * @public
+ */
+interface UsersGroupState {
+  subscriptions: string[];
+  totalCount?: number;
+  nextCursor?: string | null;
+  lastLoadMoreRequest?: string;
+  users?: SanityUser[];
+  error?: unknown;
+}
+/**
+ * @public
+ */
+interface SanityUserResponse {
+  data: SanityUser[];
+  totalCount: number;
+  nextCursor: string | null;
+}
+/**
+ * @public
+ */
+interface UsersStoreState {
+  users: { [TUsersKey in string]?: UsersGroupState; };
+  error?: unknown;
+}
+/**
+ * @public
+ */
+interface ResolveUsersOptions extends GetUsersOptions {
+  signal?: AbortSignal;
+}
+/**
+ * @public
+ */
+interface GetUserOptions extends ProjectHandle {
+  userId: string;
+  resourceType?: 'organization' | 'project';
+  organizationId?: string;
+}
+/**
+ * @public
+ */
+interface ResolveUserOptions extends GetUserOptions {
+  signal?: AbortSignal;
+}
+/**
+ * One end of a text selection: a Portable Text path plus a character offset
+ * within the span it addresses.
+ * @public
+ */
+interface PresenceSelectionPoint {
+  path: Path;
+  offset: number;
+}
+/**
+ * A Portable Text caret or selected range, as exchanged with the Studio.
+ *
+ * Structurally identical to `EditorSelection` from `@portabletext/editor`, and
+ * declared separately so that `@sanity/sdk` stays free of React dependencies. A
+ * value from the editor can be passed straight through, and vice versa.
+ *
+ * `offset` is a character offset within the span that `path` addresses.
+ * @public
+ */
+type PresenceSelection = {
+  anchor: PresenceSelectionPoint;
+  focus: PresenceSelectionPoint;
+  backward?: boolean;
+} | null;
+/**
+ * Somewhere a participant is, as it arrives over the wire.
+ *
+ * Prefer {@link DocumentPresence} from `getDocumentPresence`, which is scoped to one
+ * document, flattened for rendering, and types `path` accurately.
+ * @public
+ */
+interface PresenceLocation {
+  type: 'document';
+  /**
+   * The specific document the participant is in, so a draft, published, or version
+   * id rather than a bare document id.
+   */
+  documentId: string;
+  /**
+   * The focused field path, empty when they are in the document but not a field.
+   *
+   * Declared as `string[]`, but segments can also be numbers or `{_key: string}`
+   * objects when the focus is inside an array or a Portable Text field, because
+   * that is what other clients send. Guard for those rather than assuming strings.
+   * Widening the declared type is a breaking change, so it waits for the next major;
+   * {@link DocumentPresence.path} is typed correctly today.
+   */
+  path: string[];
+  /**
+   * When the participant said they were last active, on *their* clock.
+   *
+   * Fine for display, unreliable for deciding whether someone is still here: it is
+   * subject to clock skew between machines. Presence already drops participants that
+   * stop announcing, so a session appearing here is one the SDK still considers
+   * live.
+   */
+  lastActiveAt: string;
+  /** A Portable Text caret, when the focused field is a Portable Text field. */
+  selection?: PresenceSelection;
+}
+/**
+ * Which specific document a presence id resolves to.
+ *
+ * Presence compares exact document ids, so a client in a draft and a client in the
+ * published document are in different places even for the same `documentId`. Pass
+ * the perspective you are editing under and the SDK resolves it; the React hooks
+ * take it from `ResourceProvider` when you do not pass one.
+ * @public
+ */
+interface PresencePerspectiveOptions extends PerspectiveHandle {
+  /** Live-edit documents have no draft, so presence resolves to the published id. */
+  liveEdit?: boolean;
+}
+/**
+ * What an app reports about where the current user is.
+ *
+ * Omit `path` for document-level presence, or pass one for field-level presence.
+ * @public
+ */
+interface ReportPresenceOptions extends PresencePerspectiveOptions {
+  /**
+   * The document the user is in.
+   *
+   * Pass the plain document id; the perspective decides which specific document that
+   * resolves to. An already-specific id is accepted and re-resolved, so passing
+   * `drafts.abc` while the perspective is `published` reports the published document.
+   */
+  documentId: string;
+  /**
+   * The focused field path. Supports keyed and numeric segments, so array items
+   * and Portable Text spans can be addressed.
+   */
+  path?: Path;
+  /** A Portable Text caret, when the focused field is a Portable Text field. */
+  selection?: PresenceSelection;
+}
+/**
+ * One participant's session and everywhere it currently is.
+ *
+ * Keyed by session, not by user: the same person in two tabs is two entries with
+ * the same `user`.
+ * @public
+ */
+interface UserPresence {
+  user: SanityUser;
+  locations: PresenceLocation[];
+  /** Identifies one tab. Stable while that tab is open, and not reused. */
+  sessionId: string;
+}
+/**
+ * One participant at one location within a single document, flattened so it can
+ * be rendered directly against a field.
+ *
+ * Unlike {@link PresenceLocation.path}, `path` here is typed as a full `Path`, so
+ * keyed and numeric segments are described rather than cast away.
+ * @beta
+ */
+interface DocumentPresence {
+  user: SanityUser;
+  /** Identifies one tab, so the same person in two tabs appears twice. */
+  sessionId: string;
+  /**
+   * The specific document id this participant is in: a draft, published, or
+   * version id, depending on which perspective they are editing.
+   */
+  documentId: string;
+  /** The focused field path. Empty when they are in the document but no field. */
+  path: Path;
+  /**
+   * When they said they were last active, on *their* clock. Fine for display,
+   * unreliable for liveness. See {@link PresenceLocation.lastActiveAt}.
+   */
+  lastActiveAt: string;
+  /** The Portable Text caret, when they are focused in a Portable Text field. */
+  selection?: PresenceSelection;
+}
+/** @beta */
+interface DocumentPresenceOptions extends PresencePerspectiveOptions {
+  /**
+   * The document to look at. Resolved through the perspective exactly as
+   * {@link ReportPresenceOptions.documentId} is, so reads match writes.
+   */
+  documentId: string;
+  /**
+   * Narrows to participants at or below this field path. Omit it for everyone in
+   * the document.
+   */
+  path?: Path;
+  /**
+   * By default a draft, its published version, and any release versions are
+   * treated as the same document, which is what document lists want. Set this to
+   * compare ids exactly, which is what field-level indicators want so that a
+   * draft and a release version do not bleed into each other.
+   */
+  excludeVersions?: boolean;
+}
+/** @public */
+type TransportEvent = RollCallEvent | StateEvent | DisconnectEvent;
+/** @public */
+interface RollCallEvent {
+  type: 'rollCall';
+  userId: string;
+  sessionId: string;
+}
+/** @public */
+interface StateEvent {
+  type: 'state';
+  userId: string;
+  sessionId: string;
+  timestamp: string;
+  locations: PresenceLocation[];
+}
+/** @public */
+interface DisconnectEvent {
+  type: 'disconnect';
+  userId: string;
+  sessionId: string;
+  timestamp: string;
+}
+/** @beta */
+declare function getPresence(instance: SanityInstance, params?: {
+  resource?: DocumentResource;
+}): StateSource<UserPresence[]>;
+/**
+ * Presence within a single document, flattened to one entry per participant per
+ * location so it can be rendered directly against a field.
+ *
+ * Reading presence never announces anything. Use `reportPresence` to make the
+ * current user visible to others.
+ *
+ * @param instance - the Sanity instance
+ * @param params - the document to look at, its perspective, an optional `path` to
+ *   narrow to a field subtree, and `excludeVersions` to compare document ids exactly
+ *
+ * @beta
+ */
+declare function getDocumentPresence(instance: SanityInstance, params: {
+  resource?: DocumentResource;
+} & DocumentPresenceOptions): StateSource<DocumentPresence[]>;
+/**
+ * Announces where the current user is, so other clients in the same project and
+ * dataset can show them. Reading presence never announces anything, so this is
+ * the only way an app becomes visible to others.
+ *
+ * Call it again whenever the user moves. Announcements are collapsed over a short
+ * window and then repeated every 30 seconds while idle, which is what tells peers
+ * the session is still alive.
+ *
+ * Which specific document each location resolves to depends on its perspective, and
+ * that matters for interoperability: other clients, the Studio included, compare
+ * exact document ids for field-level presence. Pass the perspective you are editing
+ * under rather than building a draft or version id yourself.
+ *
+ * @param instance - the Sanity instance
+ * @param params - the resource to announce on, plus the locations to report.
+ *   Pass one location with a `documentId` for document-level presence, add a
+ *   `path` for field-level presence, and pass an empty array to appear present
+ *   without being in any document.
+ *
+ * @beta
+ */
+declare function reportPresence(instance: SanityInstance, params: {
+  resource?: DocumentResource;
+  locations: ReportPresenceOptions[];
+}): void;
+/**
+ * @public
+ * The result of a projection query
+ */
+interface ProjectionValuePending<TValue extends object> {
+  data: TValue | null;
+  isPending: boolean;
+}
+interface DocumentStatus {
+  lastEditedDraftAt?: string;
+  lastEditedPublishedAt?: string;
+  lastEditedVersionAt?: string;
+}
+/**
+ *
+ * @internal
+ */
+interface PreviewQueryResult {
+  _id: string;
+  _type: string;
+  _updatedAt: string;
+  titleCandidates: Record<string, unknown>;
+  subtitleCandidates: Record<string, unknown>;
+  media?: PreviewMedia | null;
+  _status?: DocumentStatus;
+}
+/**
+ * Represents a media asset in a preview.
+ *
+ * @public
+ */
+interface PreviewMedia {
+  type: 'image-asset';
+  _ref: string;
+  url: string;
+}
+/**
+ * Represents the set of values displayed as a preview for a given Sanity document.
+ * This includes a primary title, a secondary subtitle, an optional piece of media associated
+ * with the document, and the document's status.
+ *
+ * @public
+ */
+interface PreviewValue {
+  /**
+   * The primary text displayed for the document preview.
+   */
+  title: string;
+  /**
+   * A secondary line of text providing additional context about the document.
+   */
+  subtitle?: string;
+  /**
+   * An optional piece of media representing the document within its preview.
+   * Currently, only image assets are available.
+   */
+  media?: PreviewMedia | null;
+  /**
+   * The status of the document.
+   */
+  _status?: {
+    /** The date of the last published edit */
+    lastEditedPublishedAt?: string;
+    /** The date of the last draft edit */
+    lastEditedDraftAt?: string;
+  };
+}
+/** @public */
+interface ProjectMemberRole {
+  name: string;
+  title: string;
+  description: string;
+}
+/** @public */
+interface ProjectMember {
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+  isCurrentUser: boolean;
+  isRobot: boolean;
+  roles: ProjectMemberRole[];
+}
+/** @public */
+interface ProjectMetadata {
+  color?: string;
+  externalStudioHost?: string;
+  initialTemplate?: string;
+  cliInitializedAt?: string;
+  integration: 'manage' | 'cli';
+}
+/**
+ * The base fields returned from `/projects` for every project.
+ * @public
+ */
+interface ProjectBase {
+  id: string;
+  displayName: string;
+  studioHost: string | null;
+  organizationId: string;
+  metadata: ProjectMetadata;
+  isBlocked: boolean;
+  isDisabled: boolean;
+  isDisabledByUser: boolean;
+  activityFeedEnabled: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+/**
+ * A `Project` with `members` and/or `features` conditionally included
+ * based on the query options used to fetch it.
+ * @public
+ */
+type Project<IncludeMembers extends boolean = true, IncludeFeatures extends boolean = true> = ProjectBase & (boolean extends IncludeMembers ? {
+  members?: ProjectMember[];
+} : IncludeMembers extends true ? {
+  members: ProjectMember[];
+} : unknown) & (boolean extends IncludeFeatures ? {
+  features?: string[];
+} : IncludeFeatures extends true ? {
+  features: string[];
+} : unknown);
+/** @public */
+interface ProjectOptions<IncludeMembers extends boolean = true, IncludeFeatures extends boolean = true> extends ProjectHandle {
+  includeMembers?: IncludeMembers;
+  includeFeatures?: IncludeFeatures;
+}
+/**
+ * Fetcher for a single project (`GET /projects/:id`), on the shared fetcher
+ * cache. Pre-seeds from the default {@link projects} list entry when it can
+ * satisfy the read — the default list carries features but not members, so
+ * only `includeMembers: false` reads seed.
+ *
+ * @internal
+ */
+declare const project: Fetcher<[options?: ProjectOptions<boolean, boolean> | undefined], Project<boolean, boolean>>;
+interface ProjectionOptions<TProjection extends string = string, TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string> extends DocumentHandle<TDocumentType, TDataset, TProjectId> {
+  projection: TProjection;
+}
+/**
+ * @beta
+ */
+declare function getProjectionState<TProjection extends string = string, TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(instance: SanityInstance, options: ProjectionOptions<TProjection, TDocumentType, TDataset, TProjectId>): StateSource<ProjectionValuePending<SanityProjectionResult<TProjection, TDocumentType, `${TProjectId}.${TDataset}`>> | undefined>;
+/**
+ * @beta
+ */
+declare function getProjectionState<TData extends object>(instance: SanityInstance, options: ProjectionOptions): StateSource<ProjectionValuePending<TData> | undefined>;
+/**
+ * @beta
+ */
+declare function getProjectionState(instance: SanityInstance, options: ProjectionOptions): StateSource<ProjectionValuePending<Record<string, unknown>> | undefined>;
+/** @beta */
+declare function resolveProjection<TProjection extends string = string, TDocumentType extends string = string, TDataset extends string = string, TProjectId extends string = string>(instance: SanityInstance, options: ProjectionOptions<TProjection, TDocumentType, TDataset, TProjectId>): Promise<ProjectionValuePending<SanityProjectionResult<TProjection, TDocumentType, `${TProjectId}.${TDataset}`>>>;
+/** @beta */
+declare function resolveProjection<TData extends object>(instance: SanityInstance, options: ProjectionOptions): Promise<ProjectionValuePending<TData>>;
+/** @public */
+interface ProjectsOptions<IncludeMembers extends boolean = false, IncludeFeatures extends boolean = true> {
+  organizationId?: string;
+  includeMembers?: IncludeMembers;
+  includeFeatures?: IncludeFeatures;
+  onlyExplicitMembership?: boolean;
+}
+/**
+ * Fetcher for the current user's projects (`GET /projects`), on the shared
+ * fetcher cache.
+ *
+ * @internal
+ */
+declare const projects: Fetcher<[options?: ProjectsOptions<boolean, boolean> | undefined], Project<boolean, boolean>[]>;
+/**
+ * @beta
+ */
+interface QueryOptions<TQuery extends string = string, TDataset extends string = string, TProjectId extends string = string> extends Pick<ResponseQueryOptions, 'useCdn' | 'cache' | 'next' | 'cacheMode' | 'tag'>, DatasetHandle<TDataset, TProjectId> {
+  query: TQuery;
+  params?: Record<string, unknown>;
+}
+/**
+ * @beta
+ */
+interface ResolveQueryOptions<TQuery extends string = string, TDataset extends string = string, TProjectId extends string = string> extends QueryOptions<TQuery, TDataset, TProjectId> {
+  signal?: AbortSignal;
+}
+/** @internal */
+declare const getQueryKey: (instance: SanityInstance, options: QueryOptions) => string;
+/** @internal */
+declare const parseQueryKey: (key: string) => QueryOptions;
+/**
+ * Returns the state source for a query.
+ *
+ * This function returns a state source that represents the current result of a GROQ query.
+ * Subscribing to the state source will instruct the SDK to fetch the query (if not already fetched)
+ * and will keep the query live using the Live content API (considering sync tags) to provide up-to-date results.
+ * When the last subscriber is removed, the query state is automatically cleaned up from the store.
+ *
+ * Note: This functionality is for advanced users who want to build their own framework integrations.
+ * Our SDK also provides a React integration (useQuery hook) for convenient usage.
+ *
+ * Note: Automatic cleanup can interfere with React Suspense because if a component suspends while being the only subscriber,
+ * cleanup might occur unexpectedly. In such cases, consider using `resolveQuery` instead.
+ *
+ * @beta
+ */
+declare function getQueryState<TQuery extends string = string, TDataset extends string = string, TProjectId extends string = string>(instance: SanityInstance, queryOptions: QueryOptions<TQuery, TDataset, TProjectId>): StateSource<SanityQueryResult<TQuery, `${TProjectId}.${TDataset}`> | undefined>;
+/** @beta */
+declare function getQueryState<TData>(instance: SanityInstance, queryOptions: QueryOptions): StateSource<TData | undefined>;
+/** @beta */
+declare function getQueryState(instance: SanityInstance, queryOptions: QueryOptions): StateSource<unknown>;
+/**
+ * Resolves the result of a query without registering a lasting subscriber.
+ *
+ * This function fetches the result of a GROQ query and returns a promise that resolves with the query result.
+ * It registers a temporary subscriber for the lifetime of the resolution (released shortly after the promise
+ * settles), so the query state participates in normal cleanup even when no lasting subscriber ever attaches —
+ * e.g. when a suspended component errors before committing. This makes it ideal for use with React Suspense,
+ * where the returned promise is thrown to delay rendering until the query result becomes available.
+ * Once the promise resolves, it is expected that a real subscriber will be added via `getQueryState` to manage ongoing updates.
+ *
+ * Additionally, an optional AbortSignal can be provided to cancel the query and immediately clear the associated state
+ * if there are no other active subscribers.
+ *
+ * @beta
+ */
+declare function resolveQuery<TQuery extends string = string, TDataset extends string = string, TProjectId extends string = string>(instance: SanityInstance, queryOptions: ResolveQueryOptions<TQuery, TDataset, TProjectId>): Promise<SanityQueryResult<TQuery, `${TProjectId}.${TDataset}`>>;
+/** @beta */
+declare function resolveQuery<TData>(instance: SanityInstance, queryOptions: ResolveQueryOptions): Promise<TData>;
+/**
+ * Lifecycle states a release document can be in. Mirrors the server's
+ * `ReleaseState`.
+ * @beta
+ */
+type ReleaseState = 'active' | 'archiving' | 'unarchiving' | 'archived' | 'published' | 'publishing' | 'scheduled' | 'scheduling';
+interface ReleasesStoreState {
+  activeReleases?: ReleaseDocument[];
+  allReleases?: ReleaseDocument[];
+  error?: unknown;
+}
+/**
+ * Get the active releases from the store.
+ * @internal
+ */
+declare const getActiveReleasesState: (instance: SanityInstance, options?: {
+  resource?: DocumentResource;
+}) => StateSource<ReleaseDocument[] | undefined>;
+/**
+ * Get every release in the store, including archived and published.
+ * @internal
+ */
+declare const getAllReleasesState: (instance: SanityInstance, options?: {
+  resource?: DocumentResource;
+}) => StateSource<ReleaseDocument[] | undefined>;
+declare const _getPerspectiveStateSelector: StoreAction<ReleasesStoreState, [_?: (PerspectiveHandle & {
+  projectId?: string;
+  dataset?: string;
+  resource?: DocumentResource;
+}) | undefined], StateSource<string[] | "previewDrafts" | "published" | "drafts" | "raw" | undefined>, unknown>;
+type OmitFirst<T extends unknown[]> = T extends [unknown, ...infer R] ? R : never;
+type SelectorParams = OmitFirst<Parameters<typeof _getPerspectiveStateSelector>>;
+type BoundGetPerspectiveState = BoundStoreAction<ReleasesStoreState, SelectorParams, ReturnType<typeof _getPerspectiveStateSelector>>;
+/**
+ * Provides a subscribable state source for a "perspective" for the Sanity client,
+ * which is used to fetch documents as though certain Content Releases are active.
+ *
+ * @param instance - The Sanity instance to get the perspective for
+ * @param options - The options for the perspective -- usually a release name
+ *
+ * @returns A subscribable perspective value, usually a list of applicable release names,
+ * or a single release name / default perspective (such as 'drafts').
+ *
+ * @public
+ */
+declare const getPerspectiveState: BoundGetPerspectiveState;
+/**
+ * Returns the state source for users associated with a specific resource.
+ *
+ * This function returns a state source that represents the current list of users for a given
+ * resource. Subscribing to the state source will instruct the SDK to fetch the users (if not
+ * already fetched) and will load more from this state source as well. When the last subscriber is
+ * removed, the users state is automatically cleaned up from the store after a delay.
+ *
+ * Note: This functionality is for advanced users who want to build their own framework
+ * integrations. Our SDK also provides a React integration for convenient usage.
+ *
+ * @beta
+ */
+declare const getUsersState: BoundStoreAction<UsersStoreState, [options?: GetUsersOptions | undefined], StateSource<{
+  data: SanityUser[];
+  totalCount: number;
+  hasMore: boolean;
+} | undefined>>;
+/**
+ * Resolves the users for a specific resource without registering a lasting subscriber.
+ *
+ * This function fetches the users for a given resource and returns a promise that resolves with
+ * the users result. Unlike `getUsersState`, which registers subscribers to keep the data live and
+ * performs automatic cleanup, `resolveUsers` does not track subscribers. This makes it ideal for
+ * use with React Suspense, where the returned promise is thrown to delay rendering until the users
+ * result becomes available. Once the promise resolves, it is expected that a real subscriber will
+ * be added via `getUsersState` to manage ongoing updates.
+ *
+ * Additionally, an optional AbortSignal can be provided to cancel the request and immediately
+ * clear the associated state if there are no active subscribers.
+ *
+ * @beta
+ */
+declare const resolveUsers: BoundStoreAction<UsersStoreState, [ResolveUsersOptions], Promise<{
+  data: SanityUser[];
+  totalCount: number;
+  hasMore: boolean;
+}>>;
+/**
+ * Loads more users for a specific resource.
+ *
+ * This function triggers a request to fetch the next page of users for a given resource. It
+ * requires that users have already been loaded for the resource (via `resolveUsers` or
+ * `getUsersState`), and that there are more users available to load (as indicated by the `hasMore`
+ * property).
+ *
+ * The function returns a promise that resolves when the next page of users has been loaded.
+ *
+ * @beta
+ */
+declare const loadMoreUsers: BoundStoreAction<UsersStoreState, [options?: GetUsersOptions | undefined], Promise<{
+  data: SanityUser[];
+  totalCount: number;
+  hasMore: boolean;
+}>>;
+/**
+ * @beta
+ */
+declare const getUserState: BoundStoreAction<UsersStoreState, [GetUserOptions], Observable<SanityUser | undefined>>;
+/**
+ * @beta
+ */
+declare const resolveUser: BoundStoreAction<UsersStoreState, [ResolveUserOptions], Promise<SanityUser>>;
+/**
+ * @public
+ * Extracts the project ID from a CorsOriginError message.
+ * @param error - The error to extract the project ID from.
+ * @returns The project ID or null if the error is not a CorsOriginError.
+ */
+declare function getCorsErrorProjectId(error: Error): string | null;
+/**
+ * Returns true when the given error looks like a dynamic-import or
+ * code-split chunk-loading failure.
+ *
+ * These errors typically surface when a user has a tab open against a
+ * previously-deployed version of an app and the JavaScript or CSS chunk
+ * filenames have since changed: a fresh deployment removes the hashed assets
+ * the open tab still references. Detecting them lets the SDK trigger an
+ * automatic reload so the user gets the new build without manual intervention.
+ *
+ * Recognized shapes (webpack ChunkLoadError, Vite "Failed to fetch
+ * dynamically imported module", Firefox "error loading dynamically imported
+ * module", Safari "Importing a module script failed", and Vite "Unable to
+ * preload CSS").
+ *
+ * @param error - The value to inspect. Anything that is not an Error
+ *   instance returns false.
+ * @returns True if the error matches a known import/chunk-load failure.
+ *
+ * @public
+ */
+declare function isImportError(error: unknown): boolean;
+/**
+ * This version is provided by pkg-utils at build time
+ * @internal
+ */
+declare const CORE_SDK_VERSION: {};
+/**
+ * @public
+ */
+type SanityProject$1 = SanityProject;
+/**
+ * Represents the various states the authentication can be in.
+ *
+ * @public
+ */
+type AuthState = LoggedInAuthState | LoggedOutAuthState | LoggingInAuthState | ErrorAuthState;
+/**
+ * Logged-in state from the auth state.
+ * @public
+ */
+type LoggedInAuthState = {
+  type: AuthStateType.LOGGED_IN;
+  token: string;
+  currentUser: CurrentUser | null;
+  lastTokenRefresh?: number;
+};
+/**
+ * Logged-out state from the auth state.
+ * @public
+ */
+type LoggedOutAuthState = {
+  type: AuthStateType.LOGGED_OUT;
+  isDestroyingSession: boolean;
+};
+/**
+ * Logging-in state from the auth state.
+ * @public
+ */
+type LoggingInAuthState = {
+  type: AuthStateType.LOGGING_IN;
+  isExchangingToken: boolean;
+};
+/**
+ * Error state from the auth state.
+ * @public
+ */
+type ErrorAuthState = {
+  type: AuthStateType.ERROR;
+  error: unknown;
+};
+/**
+ * Represents the various states the authentication can be in.
+ *
+ * @public
+ */
+interface DashboardContext {
+  mode?: string;
+  env?: string;
+  orgId?: string;
+}
+/**
+ * The method of authentication used.
+ * @internal
+ */
+type AuthMethodOptions = 'localstorage' | 'cookie' | undefined;
+/**
+ * @public
+ */
+interface AuthStoreState {
+  authState: AuthState;
+  providers?: AuthProvider[];
+  options: {
+    initialLocationHref: string;
+    clientFactory: (config: ClientConfig) => SanityClient;
+    customProviders: AuthConfig['providers'];
+    storageKey: string;
+    storageArea: Storage | undefined;
+    apiHost: string | undefined;
+    loginUrl: string;
+    callbackUrl: string | undefined;
+    providedToken: string | undefined;
+    authMethod: AuthMethodOptions;
+  };
+  dashboardContext?: DashboardContext;
+}
+/**
+ * @public
+ */
+declare const getCurrentUserState: BoundStoreAction<AuthStoreState, [], StateSource<CurrentUser | null>>;
+/**
+ * @public
+ */
+declare const getTokenState: BoundStoreAction<AuthStoreState, [], StateSource<string | null>>;
+/**
+ * @public
+ */
+declare const getLoginUrlState: BoundStoreAction<AuthStoreState, [], StateSource<string>>;
+/**
+ * @public
+ */
+declare const getAuthState: BoundStoreAction<AuthStoreState, [], StateSource<AuthState>>;
+/**
+ * @public
+ */
+declare const getDashboardOrganizationId: BoundStoreAction<AuthStoreState, [], StateSource<string | undefined>>;
+/**
+ * Returns a state source indicating if the SDK is running within a dashboard context.
+ * @public
+ */
+declare const getIsInDashboardState: BoundStoreAction<AuthStoreState, [], StateSource<boolean>>;
+/**
+ * Action to explicitly set the authentication token.
+ * Used internally by the Comlink token refresh.
+ * @internal
+ */
+declare const setAuthToken: BoundStoreAction<AuthStoreState, [token: string | null], void>;
+export { PreviewMedia as $, unpublishDocument as $n, ApplicationInterface as $r, ApplyDocumentActionsOptions as $t, loadMoreUsers as A, DocumentAction as An, updateComment as Ar, organizations as At, parseQueryKey as B, UnscheduleReleaseAction as Bn, ClientStoreState as Br, InstallationInclude as Bt, slicePath$1 as C, Selector as Ci, Action as Cn, ReplyToCommentOptions as Cr, SanityUser as Ct, getCorsErrorProjectId as D, DeleteDocumentAction as Dn, removeComment as Dr, UsersStoreState as Dt, isImportError as E, CreateReleaseAction as En, createComment as Er, UsersGroupState as Et, getActiveReleasesState as F, PublishReleaseAction as Fn, CommentStatus as Fr, organization as Ft, getProjectionState as G, deleteRelease as Gn, observeOrganizationVerificationState as Gr, installations as Gt, ProjectsOptions as H, createDocument as Hn, getClientState as Hr, InstallationsOptions as Ht, getAllReleasesState as I, ReleaseAction as In, CommentTextSelection as Ir, Installation as It, ProjectMember as J, editRelease as Jn, Application as Jr, SetFavoriteInput as Jt, Project as K, discardDocument as Kn, OrgVerificationResult as Kr, FavoriteDocumentContext as Kt, QueryOptions as L, ScheduleReleaseAction as Ln, CommentTextSelectionItem as Lr, InstallationAccess as Lt, resolveUsers as M, EditDocumentOptions as Mn, CommentLocalState as Mr, OrganizationBase as Mt, getPerspectiveState as N, EditReleaseAction as Nn, CommentMessage as Nr, OrganizationMember as Nt, getUserState as O, DeleteReleaseAction as On, replyToComment as Or, Organizations as Ot, ReleaseState as P, PublishDocumentAction as Pn, CommentReaction as Pr, OrganizationOptions as Pt, project as Q, unarchiveRelease as Qn, ApplicationInclude as Qr, ActionsResult as Qt, getQueryKey as R, UnarchiveReleaseAction as Rn, CommentThread as Rr, InstallationActiveConfig as Rt, jsonMatch$1 as S, defineMutation as Si, JsonMatch as Sn, RemoveCommentOptions as Sr, ResolveUsersOptions as St, CORE_SDK_VERSION as T, BoundStoreAction as Ti, CreateDocumentAction as Tn, UpdateCommentOptions as Tr, UserProfile as Tt, projects as U, createRelease as Un, logout as Ur, InstallationsResponse as Ut, resolveQuery as V, archiveRelease as Vn, getClient as Vr, InstallationInterface as Vt, resolveProjection as W, deleteDocument as Wn, handleAuthCallback as Wr, installation as Wt, ProjectMetadata as X, publishRelease as Xn, ApplicationBase as Xr, setFavorite as Xt, ProjectMemberRole as Y, publishDocument as Yn, ApplicationAccess as Yr, favorites as Yt, ProjectOptions as Z, scheduleRelease as Zn, ApplicationDeployment as Zr, getReleaseDocumentId as Zt, SanityDocument$3 as _, FetcherDefinition as _i, resolveDocument as _n, getCommentsState as _r, UserPresence as _t, LoggedOutAuthState as a, DeleteApplicationInput as ai, DocumentEditedEvent as an, LogLevel as ar, reportPresence as at, getPathDepth as b, MutationResult as bi, DocumentPermissionsResult as bn, resolveComments as br, Membership as bt, getCurrentUserState as c, application as ci, DocumentRemotePatchesEvent as cn, LoggerConfig as cr, DocumentPresenceOptions as ct, getLoginUrlState as d, updateApplication as di, TransactionAcceptedEvent as dn, createDocumentTypeHandle as dr, PresenceSelection as dt, ApplicationStudioConfig as ei, applyDocumentActions as en, unscheduleRelease as er, PreviewQueryResult as et, getTokenState as f, AccessResourceType as fi, TransactionRevertedEvent as fn, createProjectHandle as fr, PresenceSelectionPoint as ft, Role as g, Fetcher as gi, getPermissionsState as gn, getCommentsOptionsKey as gr, TransportEvent as gt, ReleaseDocument$1 as h, CacheWriter as hi, getDocumentSyncStatus as hn, getCommentThreadsState as hr, StateEvent as ht, LoggedInAuthState as i, ApplicationsResponse as ii, DocumentDiscardedEvent as in, LogContext as ir, getPresence as it, resolveUser as j, EditDocumentAction as jn, Comment as jr, Organization as jt, getUsersState as k, DiscardDocumentAction as kn, setCommentStatus as kr, OrganizationsOptions as kt, getDashboardOrganizationId as l, applications as li, DocumentTransactionSubmissionResult as ln, createDatasetHandle as lr, PresenceLocation as lt, CurrentUser$1 as m, CacheTag as mi, getDocumentState as mn, ResolveCommentsOptions as mr, RollCallEvent as mt, AuthStoreState as n, ApplicationWorkspace as ni, DocumentCreatedEvent as nn, configureLogging as nr, ProjectionValuePending as nt, LoggingInAuthState as o, DeletedResult as oi, DocumentEvent as on, LogNamespace as or, DisconnectEvent as ot, setAuthToken as p, checkPermissions as pi, DocumentOptions as pn, CommentsOptions as pr, ReportPresenceOptions as pt, ProjectBase as q, editDocument as qn, AuthStateType as qr, FavoriteStatusResponse as qt, ErrorAuthState as r, ApplicationsOptions as ri, DocumentDeletedEvent as rn, InstanceContext as rr, getDocumentPresence as rt, getAuthState as s, UpdateApplicationInput as si, DocumentPublishedEvent as sn, Logger as sr, DocumentPresence as st, AuthState as t, ApplicationVisibility as ti, ActionErrorEvent as tn, datasets as tr, PreviewValue as tt, getIsInDashboardState as u, deleteApplication as ui, DocumentUnpublishedEvent as un, createDocumentHandle as ur, PresencePerspectiveOptions as ut, SanityProject$1 as v, FetcherSnapshot as vi, resolvePermissions as vn, parseCommentsOptionsKey as vr, GetUserOptions as vt, stringifyPath$1 as w, StateSource as wi, ArchiveReleaseAction as wn, SetCommentStatusOptions as wr, SanityUserResponse as wt, joinPaths as x, defineFetcher as xi, PermissionDeniedReason as xn, CreateCommentOptions as xr, ResolveUserOptions as xt, getIndexForKey$1 as y, MutationDefinition as yi, subscribeDocumentEvents as yn, resolveCommentThreads as yr, GetUsersOptions as yt, getQueryState as z, UnpublishDocumentAction as zn, ClientOptions as zr, InstallationBase as zt };
+//# sourceMappingURL=authStore-C0o1NOxW.d.ts.map