@sanity/sdk-react 3.0.0-rc.0 → 3.0.0-rc.1

package/dist/index.d.ts

@@ -1,54 +1,81 @@
-import {ActionsResult} from '@sanity/sdk'
-import {AgentGenerateOptions} from '@sanity/sdk'
-import {AgentPatchOptions} from '@sanity/sdk'
-import {AgentPatchResult} from '@sanity/sdk'
-import {AgentPromptOptions} from '@sanity/sdk'
-import {AgentPromptResult} from '@sanity/sdk'
-import {AgentResourceOptions} from '@sanity/sdk'
-import {AgentTransformOptions} from '@sanity/sdk'
-import {AgentTranslateOptions} from '@sanity/sdk'
-import {AuthState} from '@sanity/sdk'
-import {CanvasResource} from '@sanity/message-protocol'
-import {ClientOptions} from '@sanity/sdk'
-import {Context} from 'react'
-import {CurrentUser} from '@sanity/sdk'
-import {DatasetsResponse} from '@sanity/client'
-import {DocumentAction} from '@sanity/sdk'
-import {DocumentEvent} from '@sanity/sdk'
-import {DocumentPermissionsResult} from '@sanity/sdk'
-import {DocumentResource} from '@sanity/sdk'
-import {FallbackProps} from 'react-error-boundary'
-import {FavoriteStatusResponse} from '@sanity/sdk'
-import {FrameMessage} from '@sanity/sdk'
-import {GetUserOptions} from '@sanity/sdk'
-import {GetUsersOptions} from '@sanity/sdk'
-import {MediaResource} from '@sanity/message-protocol'
-import {PathChangeMessage} from '@sanity/message-protocol'
-import {PerspectiveHandle} from '@sanity/sdk'
-import {PreviewValue} from '@sanity/sdk'
-import {ProjectHandle} from '@sanity/sdk'
-import {PropsWithChildren} from 'react'
-import {QueryOptions} from '@sanity/sdk'
-import {default as React_2} from 'react'
-import {ReactElement} from 'react'
-import {ReactNode} from 'react'
-import {ReleaseDocument} from '@sanity/sdk'
-import {SanityClient} from '@sanity/client'
-import {SanityConfig} from '@sanity/sdk'
-import {SanityDocument} from '@sanity/types'
-import {SanityInstance} from '@sanity/sdk'
-import {SanityProject} from '@sanity/sdk'
-import {SanityProject as SanityProject_2} from '@sanity/client'
-import {SanityProjectMember} from '@sanity/client'
-import {SanityUser} from '@sanity/sdk'
-import {SortOrderingItem} from '@sanity/types'
-import {DocumentHandle as StrictDocumentHandle} from '@sanity/sdk'
-import {DocumentTypeHandle as StrictDocumentTypeHandle} from '@sanity/sdk'
-import {ResourceHandle as StrictResourceHandle} from '@sanity/sdk'
-import {StudioResource} from '@sanity/message-protocol'
-import {TokenSource} from '@sanity/sdk'
-import {UserPresence} from '@sanity/sdk'
-import {WindowMessage} from '@sanity/sdk'
+import { AccessResourceType } from "@sanity/sdk";
+import { ActionsResult } from "@sanity/sdk";
+import { AgentGenerateOptions } from "@sanity/sdk";
+import { AgentPatchOptions } from "@sanity/sdk";
+import { AgentPatchResult } from "@sanity/sdk";
+import { AgentPromptOptions } from "@sanity/sdk";
+import { AgentPromptResult } from "@sanity/sdk";
+import { AgentTransformOptions } from "@sanity/sdk";
+import { AgentTranslateOptions } from "@sanity/sdk";
+import { Application } from "@sanity/sdk";
+import { ApplicationBase } from "@sanity/sdk";
+import { ApplicationInclude } from "@sanity/sdk";
+import { ApplicationsOptions } from "@sanity/sdk";
+import { ApplicationsResponse } from "@sanity/sdk";
+import { AuthState } from "@sanity/sdk";
+import { CanvasResource } from "@sanity/message-protocol";
+import { ClientOptions } from "@sanity/sdk";
+import { Context } from "react";
+import { CreateUserApplicationInput } from "@sanity/sdk";
+import { CurrentUser } from "@sanity/sdk";
+import { DatasetHandle } from "@sanity/sdk";
+import { DatasetsResponse } from "@sanity/client";
+import { DeleteApplicationInput } from "@sanity/sdk";
+import { DeletedResult } from "@sanity/sdk";
+import { DeleteUserApplicationInput } from "@sanity/sdk";
+import { DocumentAction } from "@sanity/sdk";
+import { DocumentEvent } from "@sanity/sdk";
+import { DocumentHandle as DocumentHandle_2 } from "@sanity/sdk";
+import { DocumentOptions } from "@sanity/sdk";
+import { DocumentPermissionsResult } from "@sanity/sdk";
+import { DocumentResource } from "@sanity/sdk";
+import { DocumentTypeHandle as DocumentTypeHandle_2 } from "@sanity/sdk";
+import { FallbackProps } from "react-error-boundary";
+import { FavoriteStatusResponse } from "@sanity/sdk";
+import { FrameMessage } from "@sanity/sdk";
+import { GetUserOptions } from "@sanity/sdk";
+import { GetUsersOptions } from "@sanity/sdk";
+import { Installation } from "@sanity/sdk";
+import { InstallationInclude } from "@sanity/sdk";
+import { InstallationsOptions } from "@sanity/sdk";
+import { InstallationsResponse } from "@sanity/sdk";
+import { JsonMatch } from "@sanity/sdk";
+import { MediaResource } from "@sanity/message-protocol";
+import { Organization } from "@sanity/sdk";
+import { OrganizationOptions } from "@sanity/sdk";
+import { Organizations } from "@sanity/sdk";
+import { OrganizationsOptions } from "@sanity/sdk";
+import { PathChangeMessage } from "@sanity/message-protocol";
+import { PreviewValue } from "@sanity/sdk";
+import { Project } from "@sanity/sdk";
+import { ProjectHandle } from "@sanity/sdk";
+import { ProjectOptions } from "@sanity/sdk";
+import { ProjectsOptions } from "@sanity/sdk";
+import { PropsWithChildren } from "react";
+import { QueryOptions } from "@sanity/sdk";
+import { default as React_2 } from "react";
+import { ReactElement } from "react";
+import { ReactNode } from "react";
+import { ReleaseAction } from "@sanity/sdk";
+import { ReleaseDocument } from "@sanity/sdk";
+import { SanityClient } from "@sanity/client";
+import { SanityConfig } from "@sanity/sdk";
+import { SanityDocument } from "@sanity/types";
+import { SanityDocument as SanityDocument_2 } from "groq";
+import { SanityInstance } from "@sanity/sdk";
+import { SanityProjectionResult } from "groq";
+import { SanityProjectMember } from "@sanity/client";
+import { SanityQueryResult } from "groq";
+import { SanityUser } from "@sanity/sdk";
+import { SortOrderingItem } from "@sanity/types";
+import { StudioResource } from "@sanity/message-protocol";
+import { TokenSource } from "@sanity/sdk";
+import { UpdateApplicationInput } from "@sanity/sdk";
+import { UpdateUserApplicationInput } from "@sanity/sdk";
+import { UserApplication } from "@sanity/sdk";
+import { UserApplicationsOptions } from "@sanity/sdk";
+import { UserPresence } from "@sanity/sdk";
+import { WindowMessage } from "@sanity/sdk";
 
 /**
  * @public
@@ -57,15 +84,15 @@ export declare interface AgentResourceContextOptions {
   /**
    * The project ID of the current context
    */
-  projectId: string
+  projectId: string;
   /**
    * The dataset of the current context
    */
-  dataset: string
+  dataset: string;
   /**
    * Optional document ID if the user is viewing/editing a specific document
    */
-  documentId?: string
+  documentId?: string;
 }
 
 /**
@@ -92,7 +119,7 @@ export declare interface AgentResourceContextOptions {
 export declare function AuthBoundary({
   LoginErrorComponent,
   ...props
-}: AuthBoundaryProps): React.ReactNode
+}: AuthBoundaryProps): React.ReactNode;
 
 /**
  * @internal
@@ -103,33 +130,33 @@ export declare interface AuthBoundaryProps {
    * Receives all props. Defaults to {@link Login}.
    */
   LoginComponent?: React.ComponentType<{
-    header?: React.ReactNode
-    footer?: React.ReactNode
-  }>
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+  }>;
   /**
    * Custom component to render during OAuth callback processing.
    * Receives all props. Defaults to {@link LoginCallback}.
    */
   CallbackComponent?: React.ComponentType<{
-    header?: React.ReactNode
-    footer?: React.ReactNode
-  }>
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+  }>;
   /**
    * Custom component to render when authentication errors occur.
    * Receives error boundary props and layout props. Defaults to
    * {@link LoginError}
    */
-  LoginErrorComponent?: React.ComponentType<LoginErrorProps>
+  LoginErrorComponent?: React.ComponentType<LoginErrorProps>;
   /** Header content to display */
-  header?: React.ReactNode
+  header?: React.ReactNode;
   /**
    * The project IDs to use for organization verification.
    */
-  projectIds?: string[]
+  projectIds?: string[];
   /** Footer content to display */
-  footer?: React.ReactNode
+  footer?: React.ReactNode;
   /** Protected content to render when authenticated */
-  children?: React.ReactNode
+  children?: React.ReactNode;
   /**
    * Whether to verify that the project belongs to the organization specified in the dashboard context.
    * By default, organization verification is enabled when running in a dashboard context.
@@ -137,60 +164,66 @@ export declare interface AuthBoundaryProps {
    * WARNING: Disabling organization verification is NOT RECOMMENDED and may cause your application
    * to break in the future. This should never be disabled in production environments.
    */
-  verifyOrganization?: boolean
+  verifyOrganization?: boolean;
 }
 
 /**
  * @public
  */
-export declare type ComlinkStatus = 'idle' | 'handshaking' | 'connected' | 'disconnected'
+export declare type ComlinkStatus =
+  "idle" | "handshaking" | "connected" | "disconnected";
 
 /**
  * This provider is used to provide the Comlink token refresh feature.
  * It is used to automatically request a new token on 401 error if enabled.
  * @public
  */
-export declare const ComlinkTokenRefreshProvider: React_2.FC<PropsWithChildren>
-
-declare interface DashboardResource {
-  id: string
-  name: string
-  title: string
-  basePath: string
-  projectId: string
-  dataset: string
-  type: string
-  userApplicationId: string
-  url: string
-}
-
-export {DatasetsResponse}
+export declare const ComlinkTokenRefreshProvider: React_2.FC<PropsWithChildren>;
 
 /**
- * Return type for the useDispatchIntent hook
- * @beta
+ * Optional per-call overrides for {@link useCreateDocument}'s create function.
+ * @public
  */
-declare interface DispatchIntent {
-  dispatchIntent: () => void
+export declare interface CreateDocumentOverrides {
+  /**
+   * Use this document ID instead of generating one. Overrides any `documentId`
+   * supplied on the handle passed to `useCreateDocument`.
+   */
+  documentId?: string;
+}
+
+declare interface DashboardResource {
+  id: string;
+  name: string;
+  title: string;
+  basePath: string;
+  projectId: string;
+  dataset: string;
+  type: string;
+  userApplicationId: string;
+  url: string;
 }
 
+export { DatasetsResponse };
+
 /**
- * SDK React DocumentHandle with optional explicit resource field.
- * Resource is resolved from context when not provided.
- * When a `resourceName` is provided, the resource will be resolved from the context using the `ResourcesContext`,
- * if there is a matching resource by that name.
+ * React SDK document handle. Adds `resourceName` to the core `DocumentHandle`.
+ *
+ * Import from `@sanity/sdk-react` (not `@sanity/sdk`) when writing option types
+ * for hooks — this version understands `resourceName` resolution.
+ *
  * @public
  */
 export declare interface DocumentHandle<
   TDocumentType extends string = string,
   TDataset extends string = string,
   TProjectId extends string = string,
-> extends DocumentTypeHandle<TDocumentType, TDataset, TProjectId> {
-  documentId: string
+> extends DocumentHandle_2<TDocumentType, TDataset, TProjectId> {
+  resourceName?: string;
 }
 
 declare interface DocumentInteractionHistory {
-  recordEvent: (eventType: 'viewed' | 'edited' | 'created' | 'deleted') => void
+  recordEvent: (eventType: "viewed" | "edited" | "created" | "deleted") => void;
 }
 
 /**
@@ -205,29 +238,29 @@ export declare interface DocumentsOptions<
   TProjectId extends string = string,
 >
   extends
-    ResourceHandle<TProjectId, TDataset>,
-    Pick<QueryOptions<TDocumentType, TDataset, TProjectId>, 'params'> {
+    ResourceHandle<TDataset, TProjectId>,
+    Pick<QueryOptions, "perspective" | "params"> {
   /**
    * Filter documents by their `_type`. Can be a single type or an array of types.
    */
-  documentType?: TDocumentType | TDocumentType[]
+  documentType?: TDocumentType | TDocumentType[];
   /**
    * GROQ filter expression to apply to the query
    */
-  filter?: string
+  filter?: string;
   /**
    * Number of items to load per batch (defaults to 25)
    */
-  batchSize?: number
+  batchSize?: number;
   /**
    * Sorting configuration for the results
    * @beta
    */
-  orderings?: SortOrderingItem[]
+  orderings?: SortOrderingItem[];
   /**
    * Text search query to filter results
    */
-  search?: string
+  search?: string;
 }
 
 /**
@@ -244,97 +277,135 @@ export declare interface DocumentsResponse<
   /**
    * Array of document handles for the current batch
    */
-  data: DocumentHandle<TDocumentType, TDataset, TProjectId>[]
+  data: DocumentHandle_2<TDocumentType, TDataset, TProjectId>[];
   /**
    * Whether there are more items available to load
    */
-  hasMore: boolean
+  hasMore: boolean;
   /**
    * Total count of items matching the query
    */
-  count: number
+  count: number;
   /**
    * Whether a query is currently in progress
    */
-  isPending: boolean
+  isPending: boolean;
   /**
    * Function to load the next batch of results
    */
-  loadMore: () => void
+  loadMore: () => void;
 }
 
 /**
- * SDK React DocumentTypeHandle with optional explicit resource field.
- * Resource is resolved from context when not provided.
- * When a `resourceName` is provided, the resource will be resolved from the context using the `ResourcesContext`,
- * if there is a matching resource by that name.
+ * React SDK document-type handle. Adds `resourceName` to the core `DocumentTypeHandle`.
  * @public
  */
 export declare interface DocumentTypeHandle<
   TDocumentType extends string = string,
   TDataset extends string = string,
   TProjectId extends string = string,
-> extends ResourceHandle<TProjectId, TDataset> {
-  documentType: TDocumentType
-  documentId?: string
-  liveEdit?: boolean
+> extends DocumentTypeHandle_2<TDocumentType, TDataset, TProjectId> {
+  resourceName?: string;
 }
 
-/** React-layer edit document options: DocumentHandle with optional path */
-declare type EditDocumentOptions<TPath extends string | undefined = undefined> = DocumentHandle & {
-  path?: TPath
+/**
+ * The value returned by a fetcher-backed hook. The hook suspends until the
+ * first fetch succeeds, so `data` is always present once your component renders.
+ *
+ * @public
+ */
+export declare interface FetcherHookResult<TData> {
+  /** The resolved data. Guaranteed present — the hook suspends until the first fetch succeeds. */
+  data: TData;
+  /** A fetch for this entry is in flight (background revalidation or a `refetch()`). */
+  isFetching: boolean;
+  /** The most recent background-fetch failure while data still renders; cleared by the next success. */
+  error: unknown;
+  /** Imperatively refetch, bypassing staleness. Resolves with the refreshed data. */
+  refetch: () => Promise<TData>;
 }
 
 /**
  * @internal
  */
 export declare interface FrameConnection<TFrameMessage extends FrameMessage> {
-  connect: (frameWindow: Window) => () => void
-  sendMessage: <T extends TFrameMessage['type']>(
+  connect: (frameWindow: Window) => () => void;
+  sendMessage: <T extends TFrameMessage["type"]>(
     ...params: Extract<
       TFrameMessage,
       {
-        type: T
+        type: T;
       }
-    >['data'] extends undefined
+    >["data"] extends undefined
       ? [type: T]
       : [
           type: T,
           data: Extract<
             TFrameMessage,
             {
-              type: T
+              type: T;
             }
-          >['data'],
+          >["data"],
         ]
-  ) => void
+  ) => void;
 }
 
+declare type IgnoredKey =
+  "_id" | "_type" | "_rev" | "_createdAt" | "_updatedAt";
+
 /**
  * @alpha
  */
-declare type LoginErrorProps = FallbackProps
+declare type LoginErrorProps = FallbackProps;
 
 declare interface ManageFavorite extends FavoriteStatusResponse {
-  favorite: () => Promise<void>
-  unfavorite: () => Promise<void>
-  isFavorited: boolean
+  favorite: () => Promise<void>;
+  unfavorite: () => Promise<void>;
+  isFavorited: boolean;
 }
 
 /**
  * @public
  */
-declare type MessageData = Record<string, unknown> | undefined
+declare type MessageData = Record<string, unknown> | undefined;
 
 /**
  * @internal
  */
 export declare type MessageHandler<TWindowMessage extends WindowMessage> = (
-  event: TWindowMessage['data'],
-) => TWindowMessage['response'] | Promise<TWindowMessage['response']>
+  event: TWindowMessage["data"],
+) => TWindowMessage["response"] | Promise<TWindowMessage["response"]>;
 
-declare interface NamedResources {
-  [key: string]: DocumentResource
+/**
+ * The value returned by a mutation-backed hook. The write-side counterpart to
+ * {@link FetcherHookResult}: local `{mutate, isPending, error, data, reset}`
+ * state around a core mutation action.
+ *
+ * @public
+ */
+export declare interface MutationHookResult<TInput, TResult> {
+  /**
+   * Runs the mutation. Resolves with the server response; rejects on failure
+   * (the failure is also captured in {@link MutationHookResult.error}, so a
+   * fire-and-forget caller should read `error` and an `await`ing caller should
+   * `try`/`catch`).
+   */
+  mutate: (input: TInput) => Promise<TResult>;
+  /** A mutation is currently in flight. */
+  isPending: boolean;
+  /** The most recent failure; cleared by the next `mutate` or `reset`. */
+  error: unknown;
+  /** The last successful server response, or `undefined` before the first success. */
+  data: TResult | undefined;
+  /** Clears state back to idle and abandons any in-flight result. */
+  reset: () => void;
+}
+
+/** In-flight CLI PR is using named sources since it's aspirational.
+ *  We can transform the shape in this function until it's finalized.
+ */
+declare interface NamedSources {
+  [key: string]: SanityConfig;
 }
 
 /**
@@ -342,13 +413,13 @@ declare interface NamedResources {
  * @category Types
  */
 export declare interface NavigateToStudioResult {
-  navigateToStudioDocument: () => void
+  navigateToStudioDocument: () => void;
 }
 
 declare interface Observer<T> {
-  next?: (value: T) => void
-  error?: (err: unknown) => void
-  complete?: () => void
+  next?: (value: T) => void;
+  error?: (err: unknown) => void;
+  complete?: () => void;
 }
 
 /**
@@ -361,28 +432,27 @@ export declare interface PaginatedDocumentsOptions<
   TDocumentType extends string = string,
   TDataset extends string = string,
   TProjectId extends string = string,
->
-  extends
-    ResourceHandle<TProjectId, TDataset>,
-    Pick<QueryOptions<TDocumentType, TDataset, TProjectId>, 'params'> {
-  documentType?: TDocumentType | TDocumentType[]
+> extends WithResourceNameSupport<
+  Omit<QueryOptions<TDocumentType, TDataset, TProjectId>, "query">
+> {
+  documentType?: TDocumentType | TDocumentType[];
   /**
    * GROQ filter expression to apply to the query
    */
-  filter?: string
+  filter?: string;
   /**
    * Number of items to display per page (defaults to 25)
    */
-  pageSize?: number
+  pageSize?: number;
   /**
    * Sorting configuration for the results
    * @beta
    */
-  orderings?: SortOrderingItem[]
+  orderings?: SortOrderingItem[];
   /**
    * Text search query to filter results
    */
-  search?: string
+  search?: string;
 }
 
 /**
@@ -399,116 +469,120 @@ export declare interface PaginatedDocumentsResponse<
   /**
    * Array of document handles for the current page
    */
-  data: DocumentHandle<TDocumentType, TDataset, TProjectId>[]
+  data: DocumentHandle_2<TDocumentType, TDataset, TProjectId>[];
   /**
    * Whether a query is currently in progress
    */
-  isPending: boolean
+  isPending: boolean;
   /**
    * Number of items displayed per page
    */
-  pageSize: number
+  pageSize: number;
   /**
    * Current page number (1-indexed)
    */
-  currentPage: number
+  currentPage: number;
   /**
    * Total number of pages available
    */
-  totalPages: number
+  totalPages: number;
   /**
    * Starting index of the current page (0-indexed)
    */
-  startIndex: number
+  startIndex: number;
   /**
    * Ending index of the current page (exclusive, 0-indexed)
    */
-  endIndex: number
+  endIndex: number;
   /**
    * Total count of items matching the query
    */
-  count: number
+  count: number;
   /**
    * Navigate to the first page
    */
-  firstPage: () => void
+  firstPage: () => void;
   /**
    * Whether there is a first page available to navigate to
    */
-  hasFirstPage: boolean
+  hasFirstPage: boolean;
   /**
    * Navigate to the previous page
    */
-  previousPage: () => void
+  previousPage: () => void;
   /**
    * Whether there is a previous page available to navigate to
    */
-  hasPreviousPage: boolean
+  hasPreviousPage: boolean;
   /**
    * Navigate to the next page
    */
-  nextPage: () => void
+  nextPage: () => void;
   /**
    * Whether there is a next page available to navigate to
    */
-  hasNextPage: boolean
+  hasNextPage: boolean;
   /**
    * Navigate to the last page
    */
-  lastPage: () => void
+  lastPage: () => void;
   /**
    * Whether there is a last page available to navigate to
    */
-  hasLastPage: boolean
+  hasLastPage: boolean;
   /**
    * Navigate to a specific page number
    * @param pageNumber - The page number to navigate to (1-indexed)
    */
-  goToPage: (pageNumber: number) => void
+  goToPage: (pageNumber: number) => void;
 }
 
 /**
  * @public
  * @category Types
  * @interface
+ * @deprecated use the Project type directly.
  */
-export declare type ProjectWithoutMembers = Omit<SanityProject_2, 'members'>
+export declare type ProjectWithoutMembers = Project;
 
 /**
  * This version is provided by pkg-utils at build time
  * @internal
  */
-export declare const REACT_SDK_VERSION: {}
-
-/** Options for useQuery: QueryOptions with resource made optional (resolved from context) */
-declare type ReactQueryOptions = Omit<QueryOptions, 'resource' | 'resourceName'> & ResourceHandle
+export declare const REACT_SDK_VERSION: {};
 
 /** @internal */
 export declare function renderSanityApp(
   rootElement: HTMLElement | null,
-  namedResources: NamedResources,
+  namedSources: NamedSources,
   options: RenderSanitySDKAppOptions,
   children: React.ReactNode,
-): () => void
+): () => void;
 
 declare interface RenderSanitySDKAppOptions {
-  reactStrictMode?: boolean
+  reactStrictMode?: boolean;
 }
 
 /**
- * SDK React ResourceHandle with optional explicit resource field.
- * Resource is resolved from context when not provided.
- * When a `resourceName` is provided, the resource will be resolved from the context using the `ResourcesContext`,
- * if there is a matching resource by that name.
+ * React SDK resource handle — extends the core DatasetHandle with `resourceName`
+ * for context-based resource resolution.
+ *
+ * Use this (or its subtypes) as the options type for custom hooks that need to
+ * accept a resource. It accepts a `resource` object, a `resourceName` registered
+ * via the `resources` prop on `<SanityApp>`, or a bare `projectId`/`dataset` pair
+ * for backward compatibility.
+ *
  * @public
  */
 export declare interface ResourceHandle<
-  TProjectId extends string = string,
   TDataset extends string = string,
-> {
-  resource?: DocumentResource<TProjectId, TDataset>
-  resourceName?: string
-  perspective?: PerspectiveHandle['perspective']
+  TProjectId extends string = string,
+> extends DatasetHandle<TDataset, TProjectId> {
+  /**
+   * Name of a resource registered via the `resources` prop on `<SanityApp>`.
+   * Resolved to a `DocumentResource` at the React layer.
+   */
+  resourceName?: string;
 }
 
 /**
@@ -516,14 +590,7 @@ export declare interface ResourceHandle<
  *
  * @internal
  *
- * @remarks
- * - **Root usage** (no parent instance): creates a `SanityInstance` with the
- *   given config and provides it via `SanityInstanceContext`.
- * - **Nested usage** (inside an existing provider): sets
- *   `ResourceContext` and `PerspectiveContext` so hooks in the subtree
- *   resolve the correct resource/perspective without creating a new instance.
- *
- * @example Root provider
+ * @example
  * ```tsx
  * <ResourceProvider
  *   resource={{ projectId: 'your-project-id', dataset: 'production' }}
@@ -532,46 +599,31 @@ export declare interface ResourceHandle<
  *   <YourApp />
  * </ResourceProvider>
  * ```
- *
- * @example Nested override
- * ```tsx
- * <ResourceProvider
- *   resource={{ projectId: 'other-project', dataset: 'staging' }}
- *   fallback={<LoadingSpinner />}
- * >
- *   <SubSection />
- * </ResourceProvider>
- * ```
  */
 export declare function ResourceProvider({
   children,
   fallback,
   resource,
-  ...rest
-}: ResourceProviderProps): React.ReactNode
+  ...config
+}: ResourceProviderProps): React.ReactNode;
 
 /**
- * Props for the ResourceProvider component.
- *
- * Extends `SanityConfig` (minus `defaultResource`) so new config fields are
- * automatically forwarded. The `resource` prop replaces `defaultResource`
- * with a name that better describes its role at the React layer.
- *
+ * Props for the ResourceProvider component
  * @internal
  */
-export declare interface ResourceProviderProps extends Omit<SanityConfig, 'defaultResource'> {
+export declare interface ResourceProviderProps extends SanityConfig {
   /**
    * The document resource (project/dataset, media library, or canvas)
    * for this subtree. Hooks that don't specify an explicit resource will
    * use this value.
    */
-  resource?: DocumentResource
+  resource?: DocumentResource;
   /**
    * React node to show while content is loading.
    * Used as the fallback for the internal Suspense boundary.
    */
-  fallback: React.ReactNode
-  children: React.ReactNode
+  fallback: React.ReactNode;
+  children: React.ReactNode;
 }
 
 /**
@@ -581,49 +633,57 @@ export declare interface ResourceProviderProps extends Omit<SanityConfig, 'defau
  * as well as application context and state which is used by the Sanity React hooks. Your application
  * must be wrapped with the SanityApp component to function properly.
  *
- * The `config` prop accepts a {@link SanityConfig} object. Use the `resources` prop to declare
- * one or more named data resources for your app.
+ * The `config` prop on the SanityApp component accepts either a single {@link SanityConfig} object, or an array of them.
+ * This allows your app to work with one or more of your organization's datasets.
+ *
+ * When rendered inside a Sanity Studio that provides `SDKStudioContext`, the `config` prop is
+ * optional — `SanityApp` will automatically derive `projectId`, `dataset`, and auth from the
+ * Studio workspace.
  *
- * When rendered inside a Sanity Studio that provides `SDKStudioContext`, the `config` and `resources`
- * props are optional — `SanityApp` will automatically derive them from the Studio workspace.
+ * @remarks
+ * When passing multiple SanityConfig objects to the `config` prop, the first configuration in the array becomes the default
+ * configuration used by the App SDK Hooks.
  *
- * When both `config` and `SDKStudioContext` are available, the explicit props take precedence.
+ * When both `config` and `SDKStudioContext` are available, the explicit `config` takes precedence.
  *
  * @category Components
  * @param props - Your Sanity configuration and the React children to render
  * @returns Your Sanity application, integrated with your Sanity configuration and application context
  *
- * @example Single project
+ * @example
  * ```tsx
- * import { SanityApp } from '@sanity/sdk-react'
+ * import { SanityApp, type SanityConfig } from '@sanity/sdk-react'
  *
- * export default function MyApp() {
- *   return (
- *     <SanityApp
- *       resources={{
- *         default: { projectId: 'my-project-id', dataset: 'production' },
- *       }}
- *       fallback={<div>Loading…</div>}
- *     >
- *       <MyAppRoot />
- *     </SanityApp>
- *   )
+ * import MyAppRoot from './Root'
+ *
+ * // Single project configuration
+ * const mySanityConfig: SanityConfig = {
+ *   projectId: 'my-project-id',
+ *   dataset: 'production',
  * }
- * ```
  *
- * @example Multiple resources
- * ```tsx
- * import { SanityApp } from '@sanity/sdk-react'
+ * // Or multiple project configurations
+ * const multipleConfigs: SanityConfig[] = [
+ *   // Configuration for your main project. This will be used as the default project for hooks.
+ *   {
+ *     projectId: 'marketing-website-project',
+ *     dataset: 'production',
+ *   },
+ *   // Configuration for a separate blog project
+ *   {
+ *     projectId: 'blog-project',
+ *     dataset: 'production',
+ *   },
+ *   // Configuration for a separate ecommerce project
+ *   {
+ *     projectId: 'ecommerce-project',
+ *     dataset: 'production',
+ *   }
+ * ]
  *
  * export default function MyApp() {
  *   return (
- *     <SanityApp
- *       resources={{
- *         default: { projectId: 'abc123', dataset: 'production' },
- *         'blog-project': { projectId: 'def456', dataset: 'production' },
- *       }}
- *       fallback={<div>Loading…</div>}
- *     >
+ *     <SanityApp config={mySanityConfig} fallback={<div>Loading…</div>}>
  *       <MyAppRoot />
  *     </SanityApp>
  *   )
@@ -634,9 +694,8 @@ export declare function SanityApp({
   children,
   fallback,
   config: configProp,
-  resources: resourcesProp,
   ...props
-}: SanityAppProps): ReactElement
+}: SanityAppProps): ReactElement;
 
 /**
  * @public
@@ -644,54 +703,136 @@ export declare function SanityApp({
  */
 export declare interface SanityAppProps {
   /**
-   * Core configuration for the SDK instance (auth, studio, perspective).
-   * Optional when `SanityApp` is rendered inside an `SDKStudioContext`
-   * provider (e.g. inside Sanity Studio) — the config is derived from
-   * the workspace automatically.
+   * One or more SanityConfig objects providing a project ID and dataset name.
+   * Optional when `SanityApp` is rendered inside an `SDKStudioContext` provider
+   * (e.g. inside Sanity Studio) — the config is derived from the workspace
+   * automatically.
    */
-  config?: SanityConfig
+  config?: SanityConfig | SanityConfig[];
+  /** @deprecated use the `config` prop instead. */
+  sanityConfigs?: SanityConfig[];
+  resources?: Record<string, DocumentResource>;
+  children: React.ReactNode;
+  fallback: React.ReactNode;
   /**
-   * Named document resources for the application. The resource keyed `"default"`
-   * is used automatically when no explicit resource is specified in hooks.
+   * Set this to automatically fetch and register the organization's media library and canvas as named resources.
+   * These resources will be available to hooks as `media-library` and `canvas`.
+   *
+   * The SDK App must be running in the organization's Dashboard to use this feature.
+   *
+   * @example
+   * ```tsx
+   *
+   * const MyApp = () => {
+   *   // should "just work" because of inferMediaLibraryAndCanvas.
+   *   const {data: assets} = useDocuments({
+   *     documentType: 'sanity.asset',
+   *     resourceName: 'media-library',
+   *   })
+   *   return (
+   *     <div>
+   *       {assets.map((asset) => (
+   *         <div key={asset._id}>{asset.originalFilename}</div>
+   *       ))}
+   *     </div>
+   *   )
+   * }
+   * <SanityApp inferMediaLibraryAndCanvas>
+   *   <MyApp />
+   * </SanityApp>
+   * ```
    */
-  resources?: Record<string, DocumentResource>
-  children: React.ReactNode
-  fallback: React.ReactNode
+  inferMediaLibraryAndCanvas?: boolean;
 }
 
-export {SanityDocument}
+export { SanityDocument };
 
-export {SanityProjectMember}
+/**
+ * Provides an externally-created Sanity instance to child components through React Context.
+ *
+ * @internal
+ *
+ * @remarks
+ * Unlike {@link ResourceProvider}, this component does not create or dispose a SanityInstance.
+ * The caller is responsible for creating the instance via `createSanityInstance` and disposing
+ * it when appropriate. This is useful when a non-React system layer (e.g. a state machine)
+ * owns the instance and the React tree should consume it without managing its lifecycle.
+ *
+ * All SDK hooks (`useSanityInstance`, `useDocuments`, etc.) will read from the provided instance.
+ *
+ * @example Providing a pre-created instance
+ * ```tsx
+ * import { createSanityInstance, type SanityConfig } from '@sanity/sdk'
+ * import { SanityInstanceProvider } from '@sanity/sdk-react'
+ *
+ * const config: SanityConfig = {
+ *   projectId: 'my-project-id',
+ *   dataset: 'production',
+ * }
+ *
+ * const instance = createSanityInstance(config)
+ *
+ * function App() {
+ *   return (
+ *     <SanityInstanceProvider instance={instance} fallback={<div>Loading...</div>}>
+ *       <MyApp />
+ *     </SanityInstanceProvider>
+ *   )
+ * }
+ * ```
+ *
+ * @category Components
+ */
+export declare function SanityInstanceProvider({
+  instance,
+  fallback,
+  children,
+}: SanityInstanceProviderProps): React.ReactNode;
+
+/**
+ * Props for the SanityInstanceProvider component
+ * @public
+ */
+export declare interface SanityInstanceProviderProps {
+  /**
+   * A pre-created SanityInstance to provide to child components.
+   * The caller owns the instance lifecycle — SanityInstanceProvider
+   * will not dispose it on unmount.
+   */
+  instance: SanityInstance;
+  /**
+   * React node to show while content is loading.
+   * Used as the fallback for the internal Suspense boundary.
+   */
+  fallback: React.ReactNode;
+  children: React.ReactNode;
+}
+
+export { SanityProjectMember };
 
 /**
  * @internal
  *
  * Top-level context provider that provides access to the Sanity SDK.
- *
- * Creates a single `ResourceProvider` (and therefore a single `SanityInstance`)
- * for the given config. Resource resolution is handled by `ResourcesContext`
- * and the `"default"` named resource.
  */
 export declare function SDKProvider({
   children,
   config,
-  resources,
   fallback,
+  inferMediaLibraryAndCanvas,
   ...props
-}: SDKProviderProps): ReactElement
+}: SDKProviderProps): ReactElement;
 
 /**
  * @internal
  */
 export declare interface SDKProviderProps extends AuthBoundaryProps {
-  children: ReactNode
-  config: SanityConfig
-  /**
-   * Named document resources map. Provided to `ResourcesContext` for
-   * name-based resource resolution in hooks.
-   */
-  resources?: Record<string, DocumentResource>
-  fallback: ReactNode
+  children: ReactNode;
+  config: SanityConfig | SanityConfig[];
+  fallback: ReactNode;
+  resources?: Record<string, DocumentResource>;
+  /** When set, automatically fetches and registers the organization's media library and canvas as named resources. */
+  inferMediaLibraryAndCanvas?: boolean;
 }
 
 /**
@@ -728,15 +869,9 @@ export declare interface SDKProviderProps extends AuthBoundaryProps {
  *
  * @public
  */
-export declare const SDKStudioContext: Context<StudioWorkspaceHandle | null>
-
-export {SortOrderingItem}
+export declare const SDKStudioContext: Context<StudioWorkspaceHandle | null>;
 
-export {StrictDocumentHandle}
-
-export {StrictDocumentTypeHandle}
-
-export {StrictResourceHandle}
+export { SortOrderingItem };
 
 /**
  * Minimal duck-typed interface representing a Sanity Studio workspace.
@@ -747,15 +882,15 @@ export {StrictResourceHandle}
  */
 export declare interface StudioWorkspaceHandle {
   /** The Sanity project ID for this workspace. */
-  projectId: string
+  projectId: string;
   /** The dataset name for this workspace. */
-  dataset: string
+  dataset: string;
   /**
    * Whether the Studio has determined the user is authenticated.
    * When `true` and the token source emits `null`, the SDK infers
    * cookie-based auth is in use and skips the logged-out state.
    */
-  authenticated?: boolean
+  authenticated?: boolean;
   /** Authentication state for this workspace. */
   auth: {
     /**
@@ -766,38 +901,39 @@ export declare interface StudioWorkspaceHandle {
      * Optional because Studios before Aug 2022 may not expose it. When
      * absent, the SDK falls back to localStorage/cookie discovery.
      */
-    token?: TokenSource
-  }
+    token?: TokenSource;
+  };
 }
 
 declare interface StudioWorkspacesResult {
-  workspacesByProjectIdAndDataset: WorkspacesByProjectIdDataset
-  error: string | null
+  workspacesByProjectIdAndDataset: WorkspacesByProjectIdDataset;
+  error: string | null;
 }
 
 declare interface Subscribable<T> {
-  subscribe(observer: Observer<T>): Subscription
+  subscribe(observer: Observer<T>): Subscription;
   subscribe(
     next: (value: T) => void,
     error?: (err: unknown) => void,
     complete?: () => void,
-  ): Subscription
+  ): Subscription;
 }
 
 declare interface Subscription {
-  unsubscribe(): void
+  unsubscribe(): void;
 }
 
-declare type Updater<TValue> = TValue | ((currentValue: TValue) => TValue)
+declare type Updater<TValue> = TValue | ((currentValue: TValue) => TValue);
 
 /**
  * @public
-
+ * @function
+ *
  * Returns the active releases for the current project,
  * represented as a list of release documents.
  *
  * @returns The active releases for the current project.
- * @category Projects
+ * @category Releases
  * @example
  * ```tsx
  * import {useActiveReleases} from '@sanity/sdk-react'
@@ -805,15 +941,9 @@ declare type Updater<TValue> = TValue | ((currentValue: TValue) => TValue)
  * const activeReleases = useActiveReleases()
  * ```
  */
-declare type UseActiveReleases = {
-  (options?: ResourceHandle | undefined): ReleaseDocument[]
-}
-
-/**
- * @public
- * @function
- */
-export declare const useActiveReleases: UseActiveReleases
+export declare function useActiveReleases(
+  options?: WithResourceNameSupport<SanityConfig> | undefined,
+): ReleaseDocument[];
 
 /**
  * @alpha
@@ -882,9 +1012,9 @@ export declare const useActiveReleases: UseActiveReleases
  *
  * @category Agent Actions
  */
-export declare function useAgentGenerate(): (
-  options: AgentGenerateOptions & WithResourceNameSupport<AgentResourceOptions>,
-) => Subscribable<unknown>
+export declare function useAgentGenerate(
+  resourceHandle?: ResourceHandle,
+): (options: AgentGenerateOptions) => Subscribable<unknown>;
 
 /**
  * @alpha
@@ -1035,9 +1165,9 @@ export declare function useAgentGenerate(): (
  *
  * @category Agent Actions
  */
-export declare function useAgentPatch(): (
-  options: AgentPatchOptions & WithResourceNameSupport<AgentResourceOptions>,
-) => Promise<AgentPatchResult>
+export declare function useAgentPatch(
+  resourceHandle?: ResourceHandle,
+): (options: AgentPatchOptions) => Promise<AgentPatchResult>;
 
 /**
  * @alpha
@@ -1133,9 +1263,9 @@ export declare function useAgentPatch(): (
  *
  * @category Agent Actions
  */
-export declare function useAgentPrompt(): (
-  options: AgentPromptOptions & WithResourceNameSupport<AgentResourceOptions>,
-) => Promise<AgentPromptResult>
+export declare function useAgentPrompt(
+  resourceHandle?: ResourceHandle,
+): (options: AgentPromptOptions) => Promise<AgentPromptResult>;
 
 /**
  * @public
@@ -1167,7 +1297,9 @@ export declare function useAgentPrompt(): (
  * }
  * ```
  */
-export declare function useAgentResourceContext(options: AgentResourceContextOptions): void
+export declare function useAgentResourceContext(
+  options: AgentResourceContextOptions,
+): void;
 
 /**
  * @alpha
@@ -1240,9 +1372,9 @@ export declare function useAgentResourceContext(options: AgentResourceContextOpt
  *
  * @category Agent Actions
  */
-export declare function useAgentTransform(): (
-  options: AgentTransformOptions & WithResourceNameSupport<AgentResourceOptions>,
-) => Subscribable<unknown>
+export declare function useAgentTransform(
+  resourceHandle?: ResourceHandle,
+): (options: AgentTransformOptions) => Subscribable<unknown>;
 
 /**
  * @alpha
@@ -1334,9 +1466,76 @@ export declare function useAgentTransform(): (
  *
  * @category Agent Actions
  */
-export declare function useAgentTranslate(): (
-  options: AgentTranslateOptions & WithResourceNameSupport<AgentResourceOptions>,
-) => Subscribable<unknown>
+export declare function useAgentTranslate(
+  resourceHandle?: ResourceHandle,
+): (options: AgentTranslateOptions) => Subscribable<unknown>;
+
+/**
+ * @public
+ * @function
+ *
+ * Returns every release the dataset has — including `archived`, `published`,
+ * and mid-transition states (`archiving`, `unarchiving`, `publishing`,
+ * `scheduling`).
+ *
+ * Use this hook when you're building a release-management UI (listing
+ * releases, surfacing lifecycle controls, etc.) so a release stays visible
+ * across its full lifecycle — including after it's been published or
+ * archived. For perspective / content queries, prefer
+ * {@link useActiveReleases}, which filters to releases that still affect
+ * what's queryable.
+ *
+ * @returns Every release for the current project, sorted to match the order
+ * used by {@link useActiveReleases}.
+ * @category Releases
+ * @example
+ * ```tsx
+ * import {useAllReleases} from '@sanity/sdk-react'
+ *
+ * const releases = useAllReleases()
+ * ```
+ */
+export declare function useAllReleases(
+  options?: WithResourceNameSupport<SanityConfig> | undefined,
+): ReleaseDocument[];
+
+/**
+ * Returns a single application by id.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ * The `include` tokens you pass shape `data`: each requested token adds its
+ * field, and omitted ones are absent from the type.
+ *
+ * @public
+ * @param applicationId - The application id.
+ * @param options - Optional `include` list to expand related resources.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export declare const useApplication: <
+  Include extends ApplicationInclude = never,
+>(
+  applicationId: string,
+  options?: {
+    include?: Include[];
+  },
+) => FetcherHookResult<Application<Include>>;
+
+/**
+ * Returns the applications matching the given options.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ * The `include` tokens you pass shape `data.data`: each requested token adds its
+ * field, and omitted ones are absent from the type.
+ *
+ * @public
+ * @param options - Filter and include options for the applications list.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export declare const useApplications: <
+  Include extends ApplicationInclude = never,
+>(
+  options: ApplicationsOptions<Include>,
+) => FetcherHookResult<ApplicationsResponse<Include>>;
 
 /**
  * @public
@@ -1351,7 +1550,9 @@ declare interface UseApplyDocumentActions {
       | DocumentAction<TDocumentType, TDataset, TProjectId>
       | DocumentAction<TDocumentType, TDataset, TProjectId>[],
     options?: ResourceHandle,
-  ) => Promise<ActionsResult>
+  ) => Promise<
+    ActionsResult<SanityDocument_2<TDocumentType, `${TProjectId}.${TDataset}`>>
+  >;
 }
 
 /**
@@ -1476,8 +1677,147 @@ declare interface UseApplyDocumentActions {
  *   return <button onClick={handleCreateArticle}>Create Article</button>
  * }
  * ```
+ *
+ * @example Create a new document in a release
+ * ```tsx
+ * import {
+ *   createDocument,
+ *   createDocumentHandle,
+ *   useApplyDocumentActions
+ * } from '@sanity/sdk-react'
+ *
+ * function CreateArticleButton() {
+ *   const apply = useApplyDocumentActions()
+ *
+ *   const handleCreateArticle = () => {
+ *     // Use any valid document ID — not the internal `versions.<releaseName>.<id>` format or "drafts.<id>" format.
+ *     // New documents must be explicitly created with `createDocument` to become part of a release.
+ *     const newDocHandle = createDocumentHandle({
+ *       documentId: crypto.randomUUID(), // or the existing document ID you want to make a release version of
+ *       documentType: 'article',
+ *       perspective: {releaseName: 'summer-drop'},
+ *     })
+ *
+ *     apply(
+ *       createDocument(newDocHandle, {
+ *         title: 'New Article',
+ *         author: 'John Doe',
+ *         publishedAt: new Date().toISOString(),
+ *       })
+ *     )
+ *   }
+ *
+ *   return <button onClick={handleCreateArticle}>Create Article</button>
+ * }
+ * ```
+ *
+ * @example Edit an existing document in a release
+ * ```tsx
+ * import {
+ *   editDocument,
+ *   createDocumentHandle,
+ *   useApplyDocumentActions
+ * } from '@sanity/sdk-react'
+ *
+ * function EditArticleInReleaseButton({documentId}: {documentId: string}) {
+ *   const apply = useApplyDocumentActions()
+ *
+ *   const handleEdit = () => {
+ *     // Pass the document's regular ID — not `versions.<releaseName>.<id>`.
+ *     // Documents that already have a version in the release can be edited directly with `editDocument`.
+ *     const docHandle = createDocumentHandle({
+ *       documentId,
+ *       documentType: 'article',
+ *       perspective: {releaseName: 'summer-drop'},
+ *     })
+ *
+ *     apply(editDocument(docHandle, {title: 'Updated for release'}))
+ *   }
+ *
+ *   return <button onClick={handleEdit}>Edit in Release</button>
+ * }
+ * ```
+ */
+export declare const useApplyDocumentActions: UseApplyDocumentActions;
+
+/**
+ * @public
  */
-export declare const useApplyDocumentActions: UseApplyDocumentActions
+declare interface UseApplyReleaseActions {
+  (): (
+    action: ReleaseAction | ReleaseAction[],
+    options?: ResourceHandle,
+  ) => Promise<ActionsResult>;
+}
+
+/**
+ * @public
+ *
+ * Provides a stable callback function for applying one or more release actions.
+ *
+ * This hook wraps the core `applyDocumentActions` functionality from `@sanity/sdk`,
+ * integrating it with the React component lifecycle and {@link SanityInstance}.
+ * It accepts release-lifecycle actions generated by {@link createRelease},
+ * {@link editRelease}, {@link publishRelease}, {@link scheduleRelease},
+ * {@link unscheduleRelease}, {@link archiveRelease}, {@link unarchiveRelease},
+ * and {@link deleteRelease}.
+ *
+ * Note that actions submitted via this hook will cascade to the documents in the release.
+ * For example, if you create a release and then publish it, the documents in the release will be published.
+ * If you delete a published release, the version documents will be deleted.
+ *
+ * Features:
+ * - Applies one or multiple `ReleaseAction` objects.
+ * - Supports optimistic updates for create/edit/delete: local release state
+ *   reflects changes immediately while in-flight.
+ * - Handles batching: multiple actions passed together are submitted as a
+ *   single atomic transaction.
+ *
+ * Release actions cannot be combined with `liveEdit` document actions in the
+ * same transaction. Submit them as separate transactions if you need both.
+ *
+ * @category Releases
+ * @returns A stable callback. When called with a single `ReleaseAction` or an
+ * array of `ReleaseAction`s, it returns a promise that resolves to an
+ * {@link ActionsResult}.
+ *
+ * @example Create and schedule a release
+ * ```tsx
+ * import {
+ *   createRelease,
+ *   scheduleRelease,
+ *   useApplyReleaseActions,
+ *   type ReleaseHandle,
+ * } from '@sanity/sdk-react'
+ *
+ * function ScheduleReleaseButton({release}: {release: ReleaseHandle}) {
+ *   const applyRelease = useApplyReleaseActions()
+ *
+ *   const handleSchedule = () =>
+ *     applyRelease([
+ *       createRelease(release, {title: 'Summer drop', releaseType: 'asap'}),
+ *       scheduleRelease(release, '2026-06-01T00:00:00Z'),
+ *     ])
+ *
+ *   return <button onClick={handleSchedule}>Schedule</button>
+ * }
+ * ```
+ *
+ * @example Publish a release
+ * ```tsx
+ * import {publishRelease, useApplyReleaseActions} from '@sanity/sdk-react'
+ *
+ * function PublishButton({releaseId}: {releaseId: string}) {
+ *   const applyRelease = useApplyReleaseActions()
+ *   return (
+ *     <button onClick={() => applyRelease(publishRelease({releaseId}))}>
+ *       Publish all documents in the release
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export declare const useApplyReleaseActions: UseApplyReleaseActions;
 
 /**
  * @internal
@@ -1500,14 +1840,33 @@ export declare const useApplyDocumentActions: UseApplyDocumentActions
  * }
  * ```
  */
-export declare const useAuthState: () => AuthState
+export declare const useAuthState: () => AuthState;
 
 /**
  * Hook to get the currently logged in user
  * @internal
  * @returns The current user or null if not authenticated
  */
-export declare const useAuthToken: () => string | null
+export declare const useAuthToken: () => string | null;
+
+/**
+ * Checks whether the current user holds the given permissions on a resource.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ * `data` maps each requested permission to whether the user has it — keyed by
+ * exactly the permission strings you passed.
+ *
+ * @public
+ * @param resourceType - The type of resource (e.g. `'project'`, `'organization'`).
+ * @param resourceId - The resource id.
+ * @param permissions - The permission names to check.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export declare const useCheckPermissions: <Permission extends string>(
+  resourceType: AccessResourceType,
+  resourceId: string,
+  permissions: Permission[],
+) => FetcherHookResult<Record<Permission, boolean>>;
 
 /**
  * A React hook that provides a client that subscribes to changes in your application,
@@ -1536,7 +1895,59 @@ export declare const useAuthToken: () => string | null
  * @public
  * @function
  */
-export declare const useClient: (options: ClientOptions) => SanityClient
+export declare const useClient: (options: ClientOptions) => SanityClient;
+
+/**
+ * @public
+ * Create a new document, relying on Typegen for the initial-value type.
+ *
+ * @param options - A document-type handle including `documentType`, an optional `documentId`, and optionally `projectId`/`dataset`/`perspective`.
+ * @returns A function that creates the document. It accepts optional initial field values and an optional `{documentId}` override,
+ *          and resolves to the {@link DocumentHandle} of the created document (carrying the generated or supplied id).
+ */
+export declare function useCreateDocument<
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+>(
+  options: DocumentTypeHandle<TDocumentType, TDataset, TProjectId>,
+): (
+  initialValue?: Partial<
+    Omit<
+      SanityDocument_2<TDocumentType, `${TProjectId}.${TDataset}`>,
+      IgnoredKey
+    >
+  >,
+  overrides?: CreateDocumentOverrides,
+) => Promise<DocumentHandle<TDocumentType, TDataset, TProjectId>>;
+
+/**
+ * @public
+ * Create a new document with an explicit type `TData`.
+ *
+ * @param options - A document-type handle including `documentType` and optionally `projectId`/`dataset`/`perspective`.
+ * @returns A function that creates the document. It accepts optional initial field values (typed against `TData`) and an
+ *          optional `{documentId}` override, and resolves to the {@link DocumentHandle} of the created document.
+ */
+export declare function useCreateDocument<
+  TData extends Record<string, unknown>,
+>(
+  options: DocumentTypeHandle,
+): (
+  initialValue?: Partial<Omit<TData, IgnoredKey>>,
+  overrides?: CreateDocumentOverrides,
+) => Promise<DocumentHandle>;
+
+/**
+ * Creates a user application.
+ *
+ * @internal
+ * @returns The mutation envelope `{mutate, isPending, error, data, reset}`.
+ */
+export declare const useCreateUserApplication: () => MutationHookResult<
+  CreateUserApplicationInput,
+  UserApplication
+>;
 
 declare type UseCurrentUser = {
   /**
@@ -1559,15 +1970,15 @@ declare type UseCurrentUser = {
    * )
    * ```
    */
-  (): CurrentUser | null
-}
+  (): CurrentUser | null;
+};
 
 /**
  * @public
  * @function
  * @TODO This should not return null — users of a custom app will always be authenticated via Core
  */
-export declare const useCurrentUser: UseCurrentUser
+export declare const useCurrentUser: UseCurrentUser;
 
 /**
  * @public
@@ -1613,8 +2024,8 @@ export declare const useCurrentUser: UseCurrentUser
  * ```
  */
 export declare function useDashboardNavigate(
-  navigateFn: (options: PathChangeMessage['data']) => void,
-): void
+  navigateFn: (options: PathChangeMessage["data"]) => void,
+): void;
 
 /**
  * @public
@@ -1635,7 +2046,7 @@ export declare function useDashboardNavigate(
  * @category Dashboard
  * @returns The dashboard organization ID (string | undefined)
  */
-export declare function useDashboardOrganizationId(): string | undefined
+export declare function useDashboardOrganizationId(): string | undefined;
 
 declare type UseDatasets = {
   /**
@@ -1643,12 +2054,13 @@ declare type UseDatasets = {
    * Returns metadata for each dataset the current user has access to.
    *
    * @category Datasets
-   * @param options - An object containing the `projectId` to list datasets for.
-   * @returns The metadata for the datasets
+   * @param options - Optional project/resource to read datasets for. Defaults to
+   *   the resource named in `ResourceProvider`/`SDKProvider`.
+   * @returns The metadata for your the datasets
    *
    * @example
    * ```tsx
-   * const datasets = useDatasets({projectId: 'my-project-id'})
+   * const datasets = useDatasets()
    *
    * return (
    *   <select>
@@ -1659,204 +2071,248 @@ declare type UseDatasets = {
    * )
    * ```
    *
+   * @remarks
+   * The `projectId` is resolved in order from:
+   * 1. an explicit `projectId` option
+   * 2. A legacy ProjectContext (e.g. a `<ResourceProvider projectId="…">` with no dataset), then
+   * 3. The active resource (`ResourceProvider`/`SDKProvider`)
+   * 4. `instance.config`.
    */
-  (options: {projectId: string}): DatasetsResponse
-}
+  (options?: ProjectHandle): DatasetsResponse;
+};
 
 /**
  * @public
  * @function
  */
-export declare const useDatasets: UseDatasets
+export declare const useDatasets: UseDatasets;
 
 /**
- * @beta
- *
- * A hook for dispatching intent messages to the Dashboard with a document handle.
- * This allows applications to signal their intent to pass the referenced document to other applications that have registered the ability to perform specific actions on that document.
+ * Soft-deletes an application.
  *
- * @param params - Object containing:
- *   - `action` - Action to perform (currently only 'edit' is supported). Will prompt a picker if multiple handlers are available.
- *   - `intentId` - Specific ID of the intent to dispatch. Either `action` or `intentId` is required.
- *   - `documentHandle` - The document handle containing document ID, type, and either:
- *     - `projectId` and `dataset` for traditional dataset resources, like `{documentId: '123', documentType: 'book', projectId: 'abc123', dataset: 'production'}`
- *     - `resource` for media library, canvas, or dataset resources, like `{documentId: '123', documentType: 'sanity.asset', resource: mediaLibraryResource('ml123')}` or `{documentId: '123', documentType: 'sanity.canvas.document', resource: canvasResource('canvas123')}`
- *   - `paremeters` - Optional parameters to include in the dispatch; will be passed to the resolved intent handler
- * @returns An object containing:
- * - `dispatchIntent` - Function to dispatch the intent message
- *
- * @example
- * ```tsx
- * import {useDispatchIntent} from '@sanity/sdk-react'
- * import {Button} from '@sanity/ui'
- * import {Suspense} from 'react'
- *
- * function DispatchIntentButton({documentId, documentType, projectId, dataset}) {
- *   const {dispatchIntent} = useDispatchIntent({
- *     action: 'edit',
- *     documentHandle: {documentId, documentType, projectId, dataset},
- *   })
- *
- *   return (
- *     <Button
- *       onClick={() => dispatchIntent()}
- *       text="Dispatch Intent"
- *     />
- *   )
- * }
- *
- * // Wrap the component with Suspense since the hook may suspend
- * function MyDocumentAction({documentId, documentType, projectId, dataset}) {
- *   return (
- *     <Suspense fallback={<Button text="Loading..." disabled />}>
- *       <DispatchIntentButton
- *         documentId={documentId}
- *         documentType={documentType}
- *         projectId={projectId}
- *         dataset={dataset}
- *       />
- *     </Suspense>
- *   )
- * }
- * ```
+ * @internal
+ * @returns The mutation envelope `{mutate, isPending, error, data, reset}`.
  */
-export declare function useDispatchIntent(params: UseDispatchIntentParams): DispatchIntent
+export declare const useDeleteApplication: () => MutationHookResult<
+  DeleteApplicationInput,
+  DeletedResult
+>;
 
 /**
- * Parameters for the useDispatchIntent hook
- * @beta
+ * Deletes a user application.
+ *
+ * @internal
+ * @returns The mutation envelope `{mutate, isPending, error, data, reset}`.
  */
-declare interface UseDispatchIntentParams {
-  action?: 'edit'
-  intentId?: string
-  documentHandle: DocumentHandle
-  parameters?: Record<string, unknown>
-}
+export declare const useDeleteUserApplication: () => MutationHookResult<
+  DeleteUserApplicationInput,
+  DeletedResult
+>;
 
 declare interface UseDocument {
+  /** @internal */
+  <
+    TDocumentType extends string,
+    TDataset extends string,
+    TProjectId extends string = string,
+  >(
+    options: UseDocumentOptions<undefined, TDocumentType, TDataset, TProjectId>,
+  ): {
+    data: SanityDocument_2<TDocumentType, `${TProjectId}.${TDataset}`> | null;
+  };
+  /** @internal */
+  <
+    TPath extends string,
+    TDocumentType extends string,
+    TDataset extends string = string,
+    TProjectId extends string = string,
+  >(
+    options: UseDocumentOptions<TPath, TDocumentType>,
+  ): {
+    data:
+      | JsonMatch<
+          SanityDocument_2<TDocumentType, `${TProjectId}.${TDataset}`>,
+          TPath
+        >
+      | undefined;
+  };
+  /** @internal */
+  <TData>(options: DocumentOptions<undefined>): {
+    data: TData | null;
+  };
+  /** @internal */
+  <TData>(options: DocumentOptions<string>): {
+    data: TData | undefined;
+  };
   /**
+   * ## useDocument via Type Inference (Recommended)
+   *
    * @public
    *
-   * ## useDocument with Explicit Types (no path)
+   * The preferred way to use this hook when working with Sanity Typegen.
    *
-   * Provide an explicit type parameter `TData` to type the returned document data.
-   * You can define your own interfaces or use types generated by your Sanity Studio.
+   * Features:
+   * - Automatically infers document types from your schema
+   * - Provides type-safe access to documents and nested fields
+   * - Supports project/dataset-specific type inference
+   * - Works seamlessly with Typegen-generated types
    *
-   * This hook will suspend while the document data is being fetched.
+   * This hook will suspend while the document data is being fetched and loaded.
+   *
+   * When fetching a full document:
+   * - Returns the complete document object if it exists
+   * - Returns `null` if the document doesn't exist
    *
-   * @typeParam TData - The explicit type for the document
+   * When fetching with a path:
+   * - Returns the value at the specified path if both the document and path exist
+   * - Returns `undefined` if either the document doesn't exist or the path doesn't exist in the document
+   *
+   * @category Documents
    * @param options - Configuration including `documentId`, `documentType`, and optionally:
+   *   - `path`: To select a nested value (returns typed value at path)
    *   - `projectId`/`dataset`: For multi-project/dataset setups
-   * @returns The document state
+   * @returns The document state (or nested value if path provided).
    *
-   * @example Basic document fetch with explicit type
+   * @example Basic document fetch
    * ```tsx
-   * import {useDocument, type DocumentHandle, type SanityDocument} from '@sanity/sdk-react'
-   *
-   * interface Book extends SanityDocument {
-   *   _type: 'book'
-   *   title: string
-   *   author: string
-   * }
+   * import {useDocument, type DocumentHandle} from '@sanity/sdk-react'
    *
-   * interface BookViewProps {
-   *   doc: DocumentHandle
+   * interface ProductViewProps {
+   *   doc: DocumentHandle<'product'> // Typegen infers product type
    * }
    *
-   * function BookView({doc}: BookViewProps) {
-   *   const {data: book} = useDocument<Book>({...doc})
-   *   return <h1>{book?.title ?? 'Untitled'} by {book?.author ?? 'Unknown'}</h1>
+   * function ProductView({doc}: ProductViewProps) {
+   *   const {data: product} = useDocument({...doc}) // Fully typed product
+   *   return <h1>{product.title ?? 'Untitled'}</h1>
    * }
    * ```
    *
-   * @inlineType DocumentOptions
-   */
-  <TData>(options: UseDocumentOptions<undefined>): {
-    data: TData | null
-  }
-  /**
-   * @public
-   *
-   * ## useDocument with Explicit Types (with path)
-   *
-   * Provide an explicit type parameter `TData` to type the returned field data
-   * when using a `path` to select a nested value.
-   *
-   * @typeParam TData - The explicit type for the field
-   * @param options - Configuration including `documentId`, `documentType`, `path`, and optionally:
-   *   - `projectId`/`dataset`: For multi-project/dataset setups
-   * @returns The field value at the specified path
-   *
-   * @example Fetching a specific field with explicit type
+   * @example Fetching a specific field
    * ```tsx
    * import {useDocument, type DocumentHandle} from '@sanity/sdk-react'
    *
-   * function BookTitle({doc}: {doc: DocumentHandle}) {
-   *   const {data: title} = useDocument<string>({...doc, path: 'title'})
+   * interface ProductTitleProps {
+   *   doc: DocumentHandle<'product'>
+   * }
+   *
+   * function ProductTitle({doc}: ProductTitleProps) {
+   *   const {data: title} = useDocument({
+   *     ...doc,
+   *     path: 'title' // Returns just the title field
+   *   })
    *   return <h1>{title ?? 'Untitled'}</h1>
    * }
    * ```
    *
    * @inlineType DocumentOptions
    */
-  <TData>(options: UseDocumentOptions<string>): {
-    data: TData | undefined
-  }
+  <
+    TPath extends string | undefined = undefined,
+    TDocumentType extends string = string,
+    TDataset extends string = string,
+    TProjectId extends string = string,
+  >(
+    options: UseDocumentOptions<TPath, TDocumentType>,
+  ): TPath extends string
+    ? {
+        data:
+          | JsonMatch<
+              SanityDocument_2<TDocumentType, `${TProjectId}.${TDataset}`>,
+              TPath
+            >
+          | undefined;
+      }
+    : {
+        data: SanityDocument_2<
+          TDocumentType,
+          `${TProjectId}.${TDataset}`
+        > | null;
+      };
   /**
    * @public
    *
-   * ## useDocument (default)
+   * ## useDocument via Explicit Types
    *
-   * When no explicit type parameter is provided, the hook returns `SanityDocument`.
+   * Use this version when:
+   * - You're not using Sanity Typegen
+   * - You need to manually specify document types
+   * - You're working with dynamic document types
    *
-   * This hook will suspend while the document data is being fetched and loaded.
+   * Key differences from Typegen version:
+   * - Requires manual type specification via `TData`
+   * - Returns `TData | null` for full documents
+   * - Returns `TData | undefined` for nested values
    *
-   * When fetching a full document:
-   * - Returns the complete document object if it exists
-   * - Returns `null` if the document doesn't exist
-   *
-   * When fetching with a path:
-   * - Returns the value at the specified path if both the document and path exist
-   * - Returns `undefined` if either the document doesn't exist or the path doesn't exist in the document
+   * This hook will suspend while the document data is being fetched.
    *
-   * @category Documents
-   * @param options - Configuration including `documentId`, `documentType`, and optionally:
+   * @typeParam TData - The explicit type for the document or field
+   * @typeParam TPath - Optional path to a nested value
+   * @param options - Configuration including `documentId` and optionally:
    *   - `path`: To select a nested value
    *   - `projectId`/`dataset`: For multi-project/dataset setups
-   * @returns The document state (or nested value if path provided).
+   * @returns The document state (or nested value if path provided)
+   *
+   * @example Basic document fetch with explicit type
+   * ```tsx
+   * import {useDocument, type DocumentHandle, type SanityDocument} from '@sanity/sdk-react'
+   *
+   * interface Book extends SanityDocument {
+   *   _type: 'book'
+   *   title: string
+   *   author: string
+   * }
+   *
+   * interface BookViewProps {
+   *   doc: DocumentHandle
+   * }
+   *
+   * function BookView({doc}: BookViewProps) {
+   *   const {data: book} = useDocument<Book>({...doc})
+   *   return <h1>{book?.title ?? 'Untitled'} by {book?.author ?? 'Unknown'}</h1>
+   * }
+   * ```
    *
-   * @example Basic document fetch
+   * @example Fetching a specific field with explicit type
    * ```tsx
    * import {useDocument, type DocumentHandle} from '@sanity/sdk-react'
    *
-   * function ProductView({doc}: {doc: DocumentHandle}) {
-   *   const {data: product} = useDocument({...doc})
-   *   return <h1>{product?.title ?? 'Untitled'}</h1>
+   * interface BookTitleProps {
+   *   doc: DocumentHandle
+   * }
+   *
+   * function BookTitle({doc}: BookTitleProps) {
+   *   const {data: title} = useDocument<string>({...doc, path: 'title'})
+   *   return <h1>{title ?? 'Untitled'}</h1>
    * }
    * ```
    *
    * @inlineType DocumentOptions
    */
-  (options: UseDocumentOptions<undefined>): {
-    data: SanityDocument | null
-  }
+  <TData, TPath extends string>(
+    options: UseDocumentOptions<TPath>,
+  ): TPath extends string
+    ? {
+        data: TData | undefined;
+      }
+    : {
+        data: TData | null;
+      };
   /**
    * @internal
    */
   (options: UseDocumentOptions): {
-    data: unknown
-  }
+    data: unknown;
+  };
 }
 
 /**
  * @public
  * Reads and subscribes to a document's realtime state, incorporating both local and remote changes.
  *
- * You can provide an explicit type parameter for full type safety:
- * - `useDocument<MyType>({...})` returns `{data: MyType | null}`
- * - `useDocument<string>({..., path: 'title'})` returns `{data: string | undefined}`
+ * This hook comes in two main flavors to suit your needs:
  *
- * Without a type parameter, data is typed as `SanityDocument`.
+ * 1. **[Type Inference](#usedocument-via-type-inference-recommended)** (Recommended) - Automatically gets types from your Sanity schema
+ * 2. **[Explicit Types](#usedocument-via-explicit-types)** - Manually specify types when needed
  *
  * @remarks
  * `useDocument` is ideal for realtime editing interfaces where you need immediate feedback on changes.
@@ -1872,7 +2328,7 @@ declare interface UseDocument {
  *
  * @function
  */
-export declare const useDocument: UseDocument
+export declare const useDocument: UseDocument;
 
 /**
  *
@@ -1881,19 +2337,19 @@ export declare const useDocument: UseDocument
  * Subscribes an event handler to events in your application's document store.
  *
  * @category Documents
- * @param options - An object containing the event handler (`onEvent`) and optionally a `resource`. If no resource is provided, the nearest resource from context will be used.
+ * @param options - An object containing the event handler (`onEvent`) and optionally a `DatasetHandle` (projectId and dataset). If the handle is not provided, the nearest Sanity instance from context will be used.
  * @example Creating a custom hook for document event toasts
  * ```tsx
- * import {type DocumentResource, type DocumentEvent, useDocumentEvent} from '@sanity/sdk-react'
+ * import {createDatasetHandle, type DatasetHandle, type DocumentEvent, useDocumentEvent} from '@sanity/sdk-react'
  * import {useToast} from './my-ui-library'
  *
- * // Define options for the custom hook
- * interface DocumentToastsOptions {
- *   resource?: DocumentResource
+ * // Define options for the custom hook, extending DatasetHandle
+ * interface DocumentToastsOptions extends DatasetHandle {
+ *   // Could add more options, e.g., { includeEvents: DocumentEvent['type'][] }
  * }
  *
  * // Define the custom hook
- * function useDocumentToasts({resource}: DocumentToastsOptions = {}) {
+ * function useDocumentToasts({...datasetHandle}: DocumentToastsOptions = {}) {
  *   const showToast = useToast() // Get the toast function
  *
  *   // Define the event handler logic to show toasts on specific events
@@ -1905,20 +2361,24 @@ export declare const useDocument: UseDocument
  *     } else if (event.type === 'deleted') {
  *       showToast(`Document ${event.documentId} deleted.`)
  *     } else {
+ *       // Optionally log other events for debugging
  *       console.log('Document Event:', event.type, event.documentId)
  *     }
  *   }
  *
+ *   // Call the original hook, spreading the handle properties
  *   useDocumentEvent({
- *     resource,
+ *     ...datasetHandle, // Spread the dataset handle (projectId, dataset)
  *     onEvent: handleEvent,
  *   })
  * }
  *
  * function MyComponentWithToasts() {
- *   useDocumentToasts({resource: {projectId: 'p1', dataset: 'ds1'}})
+ *   // Use the custom hook, passing specific handle info
+ *   const specificHandle = createDatasetHandle({ projectId: 'p1', dataset: 'ds1' })
+ *   useDocumentToasts(specificHandle)
  *
- *   // Or rely on context for the resource:
+ *   // // Or use it relying on context for the handle
  *   // useDocumentToasts()
  *
  *   return <div>...</div>
@@ -1928,7 +2388,7 @@ export declare const useDocument: UseDocument
 export declare function useDocumentEvent<
   TDataset extends string = string,
   TProjectId extends string = string,
->(options: UseDocumentEventOptions<TDataset, TProjectId>): void
+>(options: UseDocumentEventOptions<TDataset, TProjectId>): void;
 
 /**
  * @public
@@ -1936,8 +2396,8 @@ export declare function useDocumentEvent<
 declare interface UseDocumentEventOptions<
   TDataset extends string = string,
   TProjectId extends string = string,
-> extends ResourceHandle<TProjectId, TDataset> {
-  onEvent: (documentEvent: DocumentEvent) => void
+> extends ResourceHandle<TDataset, TProjectId> {
+  onEvent: (documentEvent: DocumentEvent) => void;
 }
 
 declare type UseDocumentOptions<
@@ -1946,8 +2406,8 @@ declare type UseDocumentOptions<
   TDataset extends string = string,
   TProjectId extends string = string,
 > = DocumentHandle<TDocumentType, TDataset, TProjectId> & {
-  path?: TPath
-}
+  path?: TPath;
+};
 
 /**
  *
@@ -2027,8 +2487,10 @@ declare type UseDocumentOptions<
  * ```
  */
 export declare function useDocumentPermissions(
-  actionOrActions: DocumentAction | DocumentAction[],
-): DocumentPermissionsResult
+  actionOrActions:
+    | WithResourceNameSupport<DocumentAction>
+    | WithResourceNameSupport<DocumentAction>[],
+): DocumentPermissionsResult;
 
 /**
  * @public
@@ -2056,9 +2518,9 @@ export declare function useDocumentPermissions(
  *
  * @example Combining with useDocuments to render a collection of document previews
  * ```
- * // PreviewComponent.tsx
- * export default function PreviewComponent(docHandle: DocumentHandle) {
- *   const { data: { title, subtitle, media }, isPending } = useDocumentPreview(docHandle)
+ * // PreviewComponent.jsx
+ * export default function PreviewComponent({ document }) {
+ *   const { data: { title, subtitle, media }, isPending } = useDocumentPreview({ document })
  *   return (
  *     <article style={{ opacity: isPending ? 0.5 : 1}}>
  *       {media?.type === 'image-asset' ? <img src={media.url} alt='' /> : ''}
@@ -2068,16 +2530,16 @@ export declare function useDocumentPermissions(
  *   )
  * }
  *
- * // DocumentList.tsx
- * const { data } = useDocuments({ documentType: 'movie' })
+ * // DocumentList.jsx
+ * const { data } = useDocuments({ filter: '_type == "movie"' })
  * return (
  *   <div>
  *     <h1>Movies</h1>
  *     <ul>
  *       {data.map(movie => (
- *         <li key={movie.documentId}>
+ *         <li key={movie._id}>
  *           <Suspense fallback='Loading…'>
- *             <PreviewComponent {...movie} />
+ *             <PreviewComponent document={movie} />
  *           </Suspense>
  *         </li>
  *       ))}
@@ -2089,7 +2551,7 @@ export declare function useDocumentPermissions(
 export declare function useDocumentPreview({
   ref,
   ...docHandle
-}: useDocumentPreviewOptions): useDocumentPreviewResults
+}: useDocumentPreviewOptions): useDocumentPreviewResults;
 
 /**
  * @public
@@ -2100,7 +2562,7 @@ export declare interface useDocumentPreviewOptions extends DocumentHandle {
    * Optional ref object to track visibility. When provided, preview resolution
    * only occurs when the referenced element is visible in the viewport.
    */
-  ref?: React.RefObject<unknown>
+  ref?: React.RefObject<unknown>;
 }
 
 /**
@@ -2109,9 +2571,9 @@ export declare interface useDocumentPreviewOptions extends DocumentHandle {
  */
 export declare interface useDocumentPreviewResults {
   /** The results of inferring the document's preview values */
-  data: PreviewValue
+  data: PreviewValue;
   /** True when inferred preview values are being refreshed */
-  isPending: boolean
+  isPending: boolean;
 }
 
 /**
@@ -2124,11 +2586,89 @@ export declare interface useDocumentPreviewResults {
  *
  * @category Documents
  * @remarks
- * This hook allows specifying an explicit type parameter `TData` for the projected result.
+ * This hook has multiple signatures allowing for fine-grained control over type inference:
+ * - Using Typegen: Infers the return type based on the `documentType`, `dataset`, `projectId`, and `projection`.
+ * - Using explicit type parameter: Allows specifying a custom return type `TData`.
  *
  * @param options - An object containing the `DocumentHandle` properties (`documentId`, `documentType`, etc.), the `projection` string, optional `params`, and an optional `ref`.
  * @returns An object containing the projection results (`data`) and a boolean indicating whether the resolution is pending (`isPending`). Note: Suspense handles initial loading states; `data` being `undefined` after initial loading means the document doesn't exist or the projection yielded no result.
  */
+/**
+ * @public
+ * Fetch a projection, relying on Typegen for the return type based on the handle and projection.
+ *
+ * @category Documents
+ * @param options - Options including the document handle properties (`documentId`, `documentType`, etc.) and the `projection`.
+ * @returns The projected data, typed based on Typegen.
+ *
+ * @example Using Typegen for a book preview
+ * ```tsx
+ * // ProjectionComponent.tsx
+ * import {useDocumentProjection, type DocumentHandle} from '@sanity/sdk-react'
+ * import {useRef} from 'react'
+ * import {defineProjection} from 'groq'
+ *
+ * // Define props using DocumentHandle with the specific document type
+ * type ProjectionComponentProps = {
+ *   doc: DocumentHandle<'book'> // Typegen knows 'book'
+ * }
+ *
+ * // This is required for typegen to generate the correct return type
+ * const myProjection = defineProjection(`{
+ *   title,
+ *   'coverImage': cover.asset->url,
+ *   'authors': array::join(authors[]->{'name': firstName + ' ' + lastName}.name, ', ')
+ * }`)
+ *
+ * export default function ProjectionComponent({ doc }: ProjectionComponentProps) {
+ *   const ref = useRef(null) // Optional ref to track viewport intersection for lazy loading
+ *
+ *   // Spread the doc handle into the options
+ *   // Typegen infers the return type based on 'book' and the projection
+ *   const { data } = useDocumentProjection({
+ *     ...doc, // Pass the handle properties
+ *     ref,
+ *     projection: myProjection,
+ *   })
+ *
+ *   // Suspense handles initial load, check for data existence after
+ *   return (
+ *     <article ref={ref}>
+ *       <h2>{data.title ?? 'Untitled'}</h2>
+ *       {data.coverImage && <img src={data.coverImage} alt={data.title} />}
+ *       <p>{data.authors ?? 'Unknown authors'}</p>
+ *     </article>
+ *   )
+ * }
+ *
+ * // Usage:
+ * // import {createDocumentHandle} from '@sanity/sdk-react'
+ * // const myDocHandle = createDocumentHandle({ documentId: 'book123', documentType: 'book' })
+ * // <Suspense fallback='Loading preview...'>
+ * //   <ProjectionComponent doc={myDocHandle} />
+ * // </Suspense>
+ * ```
+ */
+export declare function useDocumentProjection<
+  TProjection extends string = string,
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+>(
+  options: useDocumentProjectionOptions<
+    TProjection,
+    TDocumentType,
+    TDataset,
+    TProjectId
+  >,
+): useDocumentProjectionResults<
+  SanityProjectionResult<
+    TProjection,
+    TDocumentType,
+    `${TProjectId}.${TDataset}`
+  >
+>;
+
 /**
  * @public
  * Fetch a projection with an explicitly defined return type `TData`.
@@ -2176,7 +2716,7 @@ export declare interface useDocumentPreviewResults {
  */
 export declare function useDocumentProjection<TData extends object>(
   options: useDocumentProjectionOptions,
-): useDocumentProjectionResults<TData>
+): useDocumentProjectionResults<TData>;
 
 /**
  * @public
@@ -2189,11 +2729,11 @@ export declare interface useDocumentProjectionOptions<
   TProjectId extends string = string,
 > extends DocumentHandle<TDocumentType, TDataset, TProjectId> {
   /** The GROQ projection string */
-  projection: TProjection
+  projection: TProjection;
   /** Optional parameters for the projection query */
-  params?: Record<string, unknown>
+  params?: Record<string, unknown>;
   /** Optional ref to track viewport intersection for lazy loading */
-  ref?: React.RefObject<unknown>
+  ref?: React.RefObject<unknown>;
 }
 
 /**
@@ -2202,9 +2742,9 @@ export declare interface useDocumentProjectionOptions<
  */
 export declare interface useDocumentProjectionResults<TData> {
   /** The projected data */
-  data: TData
+  data: TData;
   /** True if the projection is currently being resolved */
-  isPending: boolean
+  isPending: boolean;
 }
 
 /**
@@ -2218,16 +2758,18 @@ export declare interface useDocumentProjectionResults<TData> {
  * @returns An object containing the list of document handles, the loading state, the total count of retrieved document handles, and a function to load more
  *
  * @remarks
- * - The returned document handles include resource information from the current Sanity instance
+ * - The returned document handles include projectId and dataset information from the current Sanity instance
  * - This makes them ready to use with document operations and other document hooks
- * - The hook automatically uses the correct Sanity instance based on the resource in the options
+ * - The hook automatically uses the correct Sanity instance based on the projectId and dataset in the options
  *
  * @example Basic infinite list with loading more
  * ```tsx
  * import {
  *   useDocuments,
+ *   createDatasetHandle,
+ *   type DatasetHandle,
  *   type DocumentHandle,
- *   type DocumentResource,
+ *   type SortOrderingItem
  * } from '@sanity/sdk-react'
  * import {Suspense} from 'react'
  *
@@ -2243,14 +2785,14 @@ export declare interface useDocumentProjectionResults<TData> {
  *
  * // Define props for the list component
  * interface DocumentListProps {
- *   resource: DocumentResource
+ *   dataset: DatasetHandle
  *   documentType: string
  *   search?: string
  * }
  *
- * function DocumentList({resource, documentType, search}: DocumentListProps) {
+ * function DocumentList({dataset, documentType, search}: DocumentListProps) {
  *   const { data, hasMore, isPending, loadMore, count } = useDocuments({
- *     resource,
+ *     ...dataset,
  *     documentType,
  *     search,
  *     batchSize: 10,
@@ -2264,7 +2806,7 @@ export declare interface useDocumentProjectionResults<TData> {
  *         {data.map((docHandle) => (
  *           <li key={docHandle.documentId}>
  *            <Suspense fallback="Loading…">
- *              <MyDocumentComponent doc={docHandle} />
+ *              <MyDocumentComponent docHandle={docHandle} />
  *            </Suspense>
  *           </li>
  *         ))}
@@ -2279,7 +2821,8 @@ export declare interface useDocumentProjectionResults<TData> {
  * }
  *
  * // Usage:
- * // <DocumentList resource={{projectId: 'p1', dataset: 'production'}} documentType="post" search="Sanity" />
+ * // const myDatasetHandle = createDatasetHandle({ projectId: 'p1', dataset: 'production' })
+ * // <DocumentList dataset={myDatasetHandle} documentType="post" search="Sanity" />
  * ```
  *
  * @example Using `filter` and `params` options for narrowing a collection
@@ -2329,16 +2872,16 @@ export declare function useDocuments<
   TDocumentType,
   TDataset,
   TProjectId
->
+>;
 
 declare type UseDocumentSyncStatus = {
   /**
    * Exposes the document's sync status between local and remote document states.
    *
    * @category Documents
-   * @param doc - The document handle to get sync status for. If you pass a `resource` in the handle,
-   * the document will be read from the specified resource. If no `resource` is provided,
-   * the resource will be resolved from context.
+   * @param doc - The document handle to get sync status for. If you pass a `DocumentHandle` with specified `projectId` and `dataset`,
+   * the document will be read from the specified Sanity project and dataset that is included in the handle. If no `projectId` or `dataset` is provided,
+   * the document will use the nearest instance from context.
    * @returns `true` if local changes are synced with remote, `false` if changes are pending. Note: Suspense handles loading states.
    * @example Show sync status indicator
    * ```tsx
@@ -2364,38 +2907,86 @@ declare type UseDocumentSyncStatus = {
    * // <SyncIndicator doc={doc} />
    * ```
    */
-  (doc: DocumentHandle): boolean
-}
+  (doc: DocumentHandle_2): boolean;
+};
 
 /**
  * @public
  * @function
  */
-export declare const useDocumentSyncStatus: UseDocumentSyncStatus
+export declare const useDocumentSyncStatus: UseDocumentSyncStatus;
+
+/**
+ * @public
+ * Edit an entire document, relying on Typegen for the type.
+ *
+ * @param options - Document options including `documentId`, `documentType`, and optionally `projectId`/`dataset`.
+ * @returns A stable function to update the document state. Accepts either the new document state or an updater function `(currentValue) => nextValue`.
+ *          Returns a promise resolving to the {@link ActionsResult}.
+ */
+export declare function useEditDocument<
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+>(
+  options: DocumentOptions<undefined, TDocumentType, TDataset, TProjectId>,
+): (
+  nextValue: Updater<
+    SanityDocument_2<TDocumentType, `${TProjectId}.${TDataset}`>
+  >,
+) => Promise<
+  ActionsResult<SanityDocument_2<TDocumentType, `${TProjectId}.${TDataset}`>>
+>;
+
+/**
+ * @public
+ * Edit a specific path within a document, relying on Typegen for the type.
+ *
+ * @param options - Document options including `documentId`, `documentType`, `path`, and optionally `projectId`/`dataset`.
+ * @returns A stable function to update the value at the specified path. Accepts either the new value or an updater function `(currentValue) => nextValue`.
+ *          Returns a promise resolving to the {@link ActionsResult}.
+ */
+export declare function useEditDocument<
+  TPath extends string = string,
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+>(
+  options: DocumentOptions<TPath, TDocumentType, TDataset, TProjectId>,
+): (
+  nextValue: Updater<
+    JsonMatch<
+      SanityDocument_2<TDocumentType, `${TProjectId}.${TDataset}`>,
+      TPath
+    >
+  >,
+) => Promise<
+  ActionsResult<SanityDocument_2<TDocumentType, `${TProjectId}.${TDataset}`>>
+>;
 
 /**
  * @public
  * Edit an entire document with an explicit type `TData`.
  *
- * @param options - Document options including `documentId` and optionally `resource` or `resourceName`.
+ * @param options - Document options including `documentId` and optionally `projectId`/`dataset`.
  * @returns A stable function to update the document state. Accepts either the new document state (`TData`) or an updater function `(currentValue: TData) => nextValue: TData`.
  *          Returns a promise resolving to the {@link ActionsResult}.
  */
 export declare function useEditDocument<TData>(
-  options: EditDocumentOptions<undefined>,
-): (nextValue: Updater<TData>) => Promise<ActionsResult>
+  options: DocumentOptions<undefined>,
+): (nextValue: Updater<TData>) => Promise<ActionsResult>;
 
 /**
  * @public
  * Edit a specific path within a document with an explicit type `TData`.
  *
- * @param options - Document options including `documentId`, `path`, and optionally `resource` or `resourceName`.
+ * @param options - Document options including `documentId`, `path`, and optionally `projectId`/`dataset`.
  * @returns A stable function to update the value at the specified path. Accepts either the new value (`TData`) or an updater function `(currentValue: TData) => nextValue: TData`.
  *          Returns a promise resolving to the {@link ActionsResult}.
  */
 export declare function useEditDocument<TData>(
-  options: EditDocumentOptions<string>,
-): (nextValue: Updater<TData>) => Promise<ActionsResult>
+  options: DocumentOptions<string>,
+): (nextValue: Updater<TData>) => Promise<ActionsResult>;
 
 /**
  * @internal
@@ -2403,27 +2994,31 @@ export declare function useEditDocument<TData>(
 export declare function useFrameConnection<
   TFrameMessage extends FrameMessage,
   TWindowMessage extends WindowMessage,
->(options: UseFrameConnectionOptions<TWindowMessage>): FrameConnection<TFrameMessage>
+>(
+  options: UseFrameConnectionOptions<TWindowMessage>,
+): FrameConnection<TFrameMessage>;
 
 /**
  * @internal
  */
-export declare interface UseFrameConnectionOptions<TWindowMessage extends WindowMessage> {
-  name: string
-  connectTo: string
-  targetOrigin: string
+export declare interface UseFrameConnectionOptions<
+  TWindowMessage extends WindowMessage,
+> {
+  name: string;
+  connectTo: string;
+  targetOrigin: string;
   onMessage?: {
-    [K in TWindowMessage['type']]: (
+    [K in TWindowMessage["type"]]: (
       data: Extract<
         TWindowMessage,
         {
-          type: K
+          type: K;
         }
-      >['data'],
-    ) => void
-  }
-  heartbeat?: boolean
-  onStatus?: (status: ComlinkStatus) => void
+      >["data"],
+    ) => void;
+  };
+  heartbeat?: boolean;
+  onStatus?: (status: ComlinkStatus) => void;
 }
 
 /**
@@ -2468,19 +3063,57 @@ export declare interface UseFrameConnectionOptions<TWindowMessage extends Window
  */
 export declare const useHandleAuthCallback: () => (
   locationHref?: string | undefined,
-) => Promise<string | false>
+) => Promise<string | false>;
+
+/**
+ * Returns a single installation by id.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ * The `include` tokens you pass shape `data`: each requested token adds its
+ * field, and omitted ones are absent from the type.
+ *
+ * @public
+ * @param installationId - The installation id.
+ * @param options - Optional `include` list to expand related resources.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export declare const useInstallation: <
+  Include extends InstallationInclude = never,
+>(
+  installationId: string,
+  options?: {
+    include?: Include[];
+  },
+) => FetcherHookResult<Installation<Include>>;
+
+/**
+ * Returns the installations matching the given options.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ * The `include` tokens you pass shape `data.data`: each requested token adds its
+ * field, and omitted ones are absent from the type.
+ *
+ * @public
+ * @param options - Filter and include options for the installations list.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export declare const useInstallations: <
+  Include extends InstallationInclude = never,
+>(
+  options: InstallationsOptions<Include>,
+) => FetcherHookResult<InstallationsResponse<Include>>;
 
 /**
  * @internal
  */
-export declare function useLoginUrl(): string
+export declare function useLoginUrl(): string;
 
 /**
  * Hook to log out of the current session
  * @internal
  * @returns A function to log out of the current session
  */
-export declare const useLogOut: () => () => Promise<void>
+export declare const useLogOut: () => () => Promise<void>;
 
 /**
  * @internal
@@ -2530,20 +3163,22 @@ export declare const useLogOut: () => () => Promise<void>
 export declare function useManageFavorite({
   documentId,
   documentType,
-  resource: paramResource,
+  projectId: paramProjectId,
+  dataset: paramDataset,
   resourceId: paramResourceId,
   resourceType,
   schemaName,
-}: UseManageFavoriteProps): ManageFavorite
+}: UseManageFavoriteProps): ManageFavorite;
 
-declare interface UseManageFavoriteProps extends DocumentHandle {
-  resourceId?: string
-  resourceType: StudioResource['type'] | MediaResource['type'] | CanvasResource['type']
+declare interface UseManageFavoriteProps extends DocumentHandle_2 {
+  resourceId?: string;
+  resourceType:
+    StudioResource["type"] | MediaResource["type"] | CanvasResource["type"];
   /**
    * The name of the schema collection this document belongs to.
    * Typically is the name of the workspace when used in the context of a studio.
    */
-  schemaName?: string
+  schemaName?: string;
 }
 
 /**
@@ -2591,9 +3226,76 @@ declare interface UseManageFavoriteProps extends DocumentHandle {
  * ```
  */
 export declare function useNavigateToStudioDocument(
-  documentHandle: DocumentHandle,
+  documentHandle: DocumentHandle_2,
   preferredStudioUrl?: string,
-): NavigateToStudioResult
+): NavigateToStudioResult;
+
+/**
+ * Returns metadata for a given organisation.
+ *
+ * @category Organizations
+ * @param options - Configuration options
+ * @returns A {@link FetcherHookResult} whose `data` is the metadata for the
+ *   organisation. `members` is included only when `includeMembers: true`;
+ *   `features` is included only when `includeFeatures: true`.
+ * @example
+ * ```tsx
+ * function OrganizationName({organizationId}: {organizationId: string}) {
+ *   const {data: organization} = useOrganization({organizationId})
+ *
+ *   return <h1>{organization.name}</h1>
+ * }
+ * ```
+ * @example
+ * ```tsx
+ * const {data: organizationWithMembers} = useOrganization({organizationId, includeMembers: true})
+ * const {data: organizationWithFeatures} = useOrganization({organizationId, includeFeatures: true})
+ * ```
+ * @public
+ * @function
+ */
+export declare const useOrganization: <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = false,
+>(
+  options: OrganizationOptions<IncludeMembers, IncludeFeatures>,
+) => FetcherHookResult<Organization<IncludeMembers, IncludeFeatures>>;
+
+/**
+ * Returns metadata for each organisation the current user has access to.
+ *
+ * @category Organizations
+ * @param options - Configuration options
+ * @returns A {@link FetcherHookResult} whose `data` is an array of organisation
+ *   metadata. `members` is included only when `includeMembers: true`; `features`
+ *   is included only when `includeFeatures: true`.
+ * @example
+ * ```tsx
+ * const {data: organizations} = useOrganizations()
+ *
+ * return (
+ *   <select>
+ *     {organizations.map((organization) => (
+ *       <option key={organization.id}>{organization.name}</option>
+ *     ))}
+ *   </select>
+ * )
+ * ```
+ * @example
+ * ```tsx
+ * const {data: organizationsWithMembers} = useOrganizations({includeMembers: true})
+ * const {data: organizationsWithFeatures} = useOrganizations({includeFeatures: true})
+ * const {data: organizationsIncludingImplicit} = useOrganizations({includeImplicitMemberships: true})
+ * ```
+ * @public
+ * @function
+ */
+export declare const useOrganizations: <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = false,
+>(
+  options?: OrganizationsOptions<IncludeMembers, IncludeFeatures>,
+) => FetcherHookResult<Organizations<IncludeMembers, IncludeFeatures>>;
 
 /**
  * Retrieves pages of {@link DocumentHandle}s, narrowed by optional filters, text searches, and custom ordering,
@@ -2606,16 +3308,18 @@ export declare function useNavigateToStudioDocument(
  * @returns An object containing the list of document handles, pagination details, and functions to navigate between pages
  *
  * @remarks
- * - The returned document handles include resource information from the current Sanity instance
+ * - The returned document handles include projectId and dataset information from the current Sanity instance
  * - This makes them ready to use with document operations and other document hooks
- * - The hook automatically uses the correct Sanity instance based on the resource in the options
+ * - The hook automatically uses the correct Sanity instance based on the projectId and dataset in the options
  *
  * @example Paginated list of documents with navigation
  * ```tsx
  * import {
  *   usePaginatedDocuments,
+ *   createDatasetHandle,
+ *   type DatasetHandle,
  *   type DocumentHandle,
- *   type DocumentResource,
+ *   type SortOrderingItem,
  *   useDocumentProjection
  * } from '@sanity/sdk-react'
  * import {Suspense} from 'react'
@@ -2638,10 +3342,10 @@ export declare function useNavigateToStudioDocument(
  * // Define props for the list component
  * interface PaginatedDocumentListProps {
  *   documentType: string
- *   resource?: DocumentResource
+ *   dataset?: DatasetHandle
  * }
  *
- * function PaginatedDocumentList({documentType, resource}: PaginatedDocumentListProps) {
+ * function PaginatedDocumentList({documentType, dataset}: PaginatedDocumentListProps) {
  *   const {
  *     data,
  *     isPending,
@@ -2652,7 +3356,7 @@ export declare function useNavigateToStudioDocument(
  *     hasNextPage,
  *     hasPreviousPage
  *   } = usePaginatedDocuments({
- *     resource,
+ *     ...dataset,
  *     documentType,
  *     pageSize: 10,
  *     orderings: [{field: '_createdAt', direction: 'desc'}],
@@ -2684,7 +3388,8 @@ export declare function useNavigateToStudioDocument(
  * }
  *
  * // Usage:
- * // <PaginatedDocumentList resource={{projectId: 'p1', dataset: 'production'}} documentType="post" />
+ * // const myDatasetHandle = createDatasetHandle({ projectId: 'p1', dataset: 'production' })
+ * // <PaginatedDocumentList dataset={myDatasetHandle} documentType="post" />
  * ```
  */
 export declare function usePaginatedDocuments<
@@ -2699,104 +3404,82 @@ export declare function usePaginatedDocuments<
   orderings,
   search,
   ...rawOptions
-}: PaginatedDocumentsOptions<TDocumentType, TDataset, TProjectId>): PaginatedDocumentsResponse<
+}: PaginatedDocumentsOptions<
   TDocumentType,
   TDataset,
   TProjectId
->
-
-/**
- * @public
- * @function
- *
- * Returns a single or stack of perspectives for the given perspective handle,
- * which can then be used to correctly query the documents
- * via the `perspective` parameter in the client.
- *
- * @param perspectiveHandle - The perspective handle to get the perspective for.
- * @category Documents
- * @example
- * ```tsx
- * import {usePerspective, useQuery} from '@sanity/sdk-react'
- *
- * const perspective = usePerspective({
- *   perspective: 'rxg1346',
- *   resource: {projectId: 'abc123', dataset: 'production'},
- * })
- * const {data} = useQuery<Movie[]>({
- *   query: '*[_type == "movie"]',
- *   perspective,
- * })
- * ```
- *
- * @returns The perspective for the given perspective handle.
- */
-declare type UsePerspective = {
-  (perspectiveHandle?: ResourceHandle): string | string[]
-}
+>): PaginatedDocumentsResponse<TDocumentType, TDataset, TProjectId>;
 
 /**
  * @public
  * @function
  */
-export declare const usePerspective: UsePerspective
+export declare function usePerspective(
+  perspectiveHandle?: ResourceHandle,
+): string | string[];
 
 /**
- * A hook for subscribing to presence information for the current project.
+ * A hook for subscribing to presence information for the current project or Canvas.
  * @public
  */
 export declare function usePresence(options?: ResourceHandle): {
-  locations: UserPresence[]
-}
-
-declare type UseProject = {
-  /**
-   *
-   * Returns metadata for a given project
-   *
-   * @category Projects
-   * @param projectHandle - An optional project handle identifying which project to retrieve metadata for
-   * @returns The metadata for the project
-   * @example
-   * ```tsx
-   *  function ProjectMetadata({ projectId }: { projectId: string }) {
-   *    const project = useProject({ projectId })
-   *
-   *    return (
-   *      <figure style={{ backgroundColor: project.metadata.color || 'lavender'}}>
-   *        <h1>{project.displayName}</h1>
-   *      </figure>
-   *    )
-   *  }
-   * ```
-   */
-  (projectHandle?: ProjectHandle): SanityProject
-}
+  locations: UserPresence[];
+};
 
 /**
+ * Returns metadata for a given project.
+ *
+ * @category Projects
+ * @param options - Configuration options
+ * @returns A {@link FetcherHookResult} whose `data` is the metadata for the
+ *   project. `members` is included only when `includeMembers: true`; `features`
+ *   is included unless `includeFeatures: false`.
+ * @example
+ * ```tsx
+ * function ProjectMetadata({projectId}: {projectId: string}) {
+ *   const {data: project} = useProject({projectId})
+ *
+ *   return (
+ *     <figure style={{backgroundColor: project.metadata.color || 'lavender'}}>
+ *       <h1>{project.displayName}</h1>
+ *     </figure>
+ *   )
+ * }
+ * ```
+ * @example
+ * ```tsx
+ * const {data: projectWithMembersAndFeatures} = useProject({projectId})
+ * const {data: projectWithMembers} = useProject({projectId, includeMembers: true})
+ * const {data: projectWithoutMembers} = useProject({projectId, includeMembers: false})
+ * const {data: projectWithoutFeatures} = useProject({projectId, includeFeatures: false})
+ * ```
+ * @remarks
+ * The `projectId` is resolved in order from:
+ * 1. an explicit `projectId` option
+ * 2. A legacy ProjectContext (e.g. a `<ResourceProvider projectId="…">` with no dataset), then
+ * 3. The active resource (`ResourceProvider`/`SDKProvider`)
+ * 4. `instance.config`.
  * @public
  * @function
  */
-export declare const useProject: UseProject
-
-/**
- * @public
- * @category Types
- */
-declare type UseProjects = <TIncludeMembers extends boolean = false>(options?: {
-  organizationId?: string
-  includeMembers?: TIncludeMembers
-}) => TIncludeMembers extends true ? SanityProject_2[] : ProjectWithoutMembers[]
+export declare const useProject: <
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+>(
+  options?: ProjectOptions<IncludeMembers, IncludeFeatures>,
+) => FetcherHookResult<Project<IncludeMembers, IncludeFeatures>>;
 
 /**
  * Returns metadata for each project you have access to.
  *
  * @category Projects
  * @param options - Configuration options
- * @returns An array of project metadata. If includeMembers is true, returns full SanityProject objects. Otherwise, returns ProjectWithoutMembers objects.
+ * @returns A {@link FetcherHookResult} whose `data` is an array of project
+ *   metadata. `members` is included only when `includeMembers: true`; `features`
+ *   is included unless `includeFeatures: false`.
  * @example
  * ```tsx
- * const projects = useProjects()
+ * const {data: projects} = useProjects()
  *
  * return (
  *   <select>
@@ -2808,19 +3491,95 @@ declare type UseProjects = <TIncludeMembers extends boolean = false>(options?: {
  * ```
  * @example
  * ```tsx
- * const projectsWithMembers = useProjects({ includeMembers: true })
- * const projectsWithoutMembers = useProjects({ includeMembers: false })
+ * const {data: projects} = useProjects()
+ * const {data: projectsWithFeatures} = useProjects()
+ * const {data: projectsWithMembers} = useProjects({includeMembers: true})
+ * const {data: projectsWithoutMembers} = useProjects({includeMembers: false})
+ * const {data: projectsWithoutFeatures} = useProjects({includeFeatures: false})
  * ```
  * @public
  * @function
  */
-export declare const useProjects: UseProjects
+export declare const useProjects: <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = true,
+>(
+  options?: ProjectsOptions<IncludeMembers, IncludeFeatures>,
+) => FetcherHookResult<Project<IncludeMembers, IncludeFeatures>[]>;
+
+/**
+ * @public
+ * Executes a GROQ query, inferring the result type from the query string and options.
+ * Leverages Sanity Typegen if configured for enhanced type safety.
+ *
+ * @param options - Configuration for the query, including `query`, optional `params`, `projectId`, `dataset`, etc.
+ * @returns An object containing `data` (typed based on the query) and `isPending` (for transitions).
+ *
+ * @example Basic usage (Inferred Type)
+ * ```tsx
+ * import {useQuery} from '@sanity/sdk-react'
+ * import {defineQuery} from 'groq'
+ *
+ * const myQuery = defineQuery(`*[_type == "movie"]{_id, title}`)
+ *
+ * function MovieList() {
+ *   // Typegen infers the return type for data
+ *   const {data} = useQuery({ query: myQuery })
+ *
+ *   return (
+ *     <div>
+ *       <h2>Movies</h2>
+ *       <ul>
+ *         {data.map(movie => <li key={movie._id}>{movie.title}</li>)}
+ *       </ul>
+ *     </div>
+ *   )
+ * }
+ * // Suspense boundary should wrap <MovieList /> for initial load
+ * ```
+ *
+ * @example Using parameters (Inferred Type)
+ * ```tsx
+ * import {useQuery} from '@sanity/sdk-react'
+ * import {defineQuery} from 'groq'
+ *
+ * const myQuery = defineQuery(`*[_type == "movie" && _id == $id][0]`)
+ *
+ * function MovieDetails({movieId}: {movieId: string}) {
+ *   // Typegen infers the return type based on query and params
+ *   const {data, isPending} = useQuery({
+ *     query: myQuery,
+ *     params: { id: movieId }
+ *   })
+ *
+ *   return (
+ *     // utilize `isPending` to signal to users that new data is coming in
+ *     // (e.g. the `movieId` changed and we're loading in the new one)
+ *     <div style={{ opacity: isPending ? 0.5 : 1 }}>
+ *       {data ? <h1>{data.title}</h1> : <p>Movie not found</p>}
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+export declare function useQuery<
+  TQuery extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+>(
+  options: UseQueryOptions<TQuery, TDataset, TProjectId>,
+): {
+  /** The query result, typed based on the GROQ query string */
+  data: SanityQueryResult<TQuery, `${TProjectId}.${TDataset}`>;
+  /** True if a query transition is in progress */
+  isPending: boolean;
+};
 
 /**
  * @public
  * Executes a GROQ query with an explicitly provided result type `TData`.
  *
- * @param options - Configuration for the query, including `query`, optional `params`, `resource`, etc.
+ * @param options - Configuration for the query, including `query`, optional `params`, `projectId`, `dataset`, etc.
  * @returns An object containing `data` (cast to `TData`) and `isPending` (indicates whether a query resolution is pending; note that Suspense handles initial loading states). *
  * @example Manually typed query result
  * ```tsx
@@ -2844,12 +3603,24 @@ export declare const useProjects: UseProjects
  * }
  * ```
  */
-export declare function useQuery<TData>(options: ReactQueryOptions): {
+export declare function useQuery<TData>(
+  options: WithResourceNameSupport<QueryOptions>,
+): {
   /** The query result, cast to the provided type TData */
-  data: TData
+  data: TData;
   /** True if another query is resolving in the background (suspense handles the initial loading state) */
-  isPending: boolean
-}
+  isPending: boolean;
+};
+
+/**
+ * Hook options for useQuery, supporting both direct resource and resourceName.
+ * @beta
+ */
+declare type UseQueryOptions<
+  TQuery extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+> = WithResourceNameSupport<QueryOptions<TQuery, TDataset, TProjectId>>;
 
 /**
  * @internal
@@ -2898,44 +3669,40 @@ export declare function useRecordDocumentHistoryEvent({
   resourceType,
   resourceId,
   schemaName,
-}: UseRecordDocumentHistoryEventProps): DocumentInteractionHistory
+}: UseRecordDocumentHistoryEventProps): DocumentInteractionHistory;
 
 /**
  * @internal
  */
-declare interface UseRecordDocumentHistoryEventProps extends DocumentHandle {
-  resourceType: StudioResource['type'] | MediaResource['type'] | CanvasResource['type']
-  resourceId?: string
+declare interface UseRecordDocumentHistoryEventProps extends DocumentHandle_2 {
+  resourceType:
+    StudioResource["type"] | MediaResource["type"] | CanvasResource["type"];
+  resourceId?: string;
   /**
    * The name of the schema collection this document belongs to.
    * Typically is the name of the workspace when used in the context of a studio.
    */
-  schemaName?: string
+  schemaName?: string;
 }
 
 /**
- * Returns the current {@link DocumentResource} from context.
+ * Returns the currently active `DocumentResource` for the nearest resource context.
  *
- * @public
+ * Resolves in priority order:
+ * 1. A `resource` prop on the nearest `<ResourceProvider>`
+ * 2. The `projectId`/`dataset` from the current `SanityInstance` config
+ * 3. `undefined` when neither is available
  *
+ * @public
  * @category Platform
- * @returns The resource set by the nearest `ResourceProvider`, or `undefined`
  *
- * @remarks
- * With the flat instance model, nested `ResourceProvider`s override the
- * active resource via React context rather than creating child instances.
- * Use this hook when you need the current project/dataset/resource for a
- * subtree instead of reading from `useSanityInstance().config`.
- *
- * @example Get the current resource
+ * @example
  * ```tsx
  * const resource = useResource()
- * if (resource && 'projectId' in resource) {
- *   console.log(resource.projectId, resource.dataset)
- * }
+ * console.log(resource?.projectId, resource?.dataset)
  * ```
  */
-export declare function useResource(): DocumentResource | undefined
+export declare function useResource(): DocumentResource | undefined;
 
 /**
  * @public
@@ -2945,11 +3712,11 @@ export declare interface UserResult {
   /**
    * The user data fetched, or undefined if not found.
    */
-  data: SanityUser | undefined
+  data: SanityUser | undefined;
   /**
    * Whether a user request is currently in progress
    */
-  isPending: boolean
+  isPending: boolean;
 }
 
 /**
@@ -2960,42 +3727,49 @@ export declare interface UsersResult {
   /**
    * The users fetched.
    */
-  data: SanityUser[]
+  data: SanityUser[];
   /**
    * Whether there are more users to fetch.
    */
-  hasMore: boolean
+  hasMore: boolean;
   /**
    * Whether a users request is currently in progress
    */
-  isPending: boolean
+  isPending: boolean;
   /**
    * Load more users.
    */
-  loadMore: () => void
+  loadMore: () => void;
 }
 
 /**
- * Retrieves the current Sanity instance from React context.
+ * Retrieves the current Sanity instance from context
  *
  * @public
  *
  * @category Platform
- * @returns The current instance
+ * @param config - Deprecated. Formerly used to match against the instance hierarchy.
+ * @returns The current Sanity instance
  *
  * @remarks
- * This hook accesses the nearest Sanity instance from React context,
- * provided by a `ResourceProvider` or `SanityApp`.
+ * This hook accesses the nearest Sanity instance from the React context.
+ * The hook must be used within a component wrapped by a `ResourceProvider` or `SanityApp`.
  *
  * @example Get the current instance
  * ```tsx
  * const instance = useSanityInstance()
- * console.log(instance.config)
+ * console.log(instance.config.projectId)
  * ```
  *
  * @throws Error if no SanityInstance is found in context
  */
-export declare const useSanityInstance: () => SanityInstance
+export declare const useSanityInstance: (
+  /**
+   * @deprecated Passing a config to match against the instance hierarchy is deprecated.
+   * Use `useSanityInstance()` without arguments instead.
+   */
+  config?: SanityConfig,
+) => SanityInstance;
 
 /**
  * Hook that fetches studio workspaces and organizes them by projectId:dataset
@@ -3031,7 +3805,29 @@ export declare const useSanityInstance: () => SanityInstance
  * }
  * ```
  */
-export declare function useStudioWorkspacesByProjectIdDataset(): StudioWorkspacesResult
+export declare function useStudioWorkspacesByProjectIdDataset(): StudioWorkspacesResult;
+
+/**
+ * Updates an application's mutable properties (title, icon, visibility).
+ *
+ * @internal
+ * @returns The mutation envelope `{mutate, isPending, error, data, reset}`.
+ */
+export declare const useUpdateApplication: () => MutationHookResult<
+  UpdateApplicationInput,
+  ApplicationBase
+>;
+
+/**
+ * Updates a user application.
+ *
+ * @internal
+ * @returns The mutation envelope `{mutate, isPending, error, data, reset}`.
+ */
+export declare const useUpdateUserApplication: () => MutationHookResult<
+  UpdateUserApplicationInput,
+  UserApplication
+>;
 
 /**
  *
@@ -3065,7 +3861,33 @@ export declare function useStudioWorkspacesByProjectIdDataset(): StudioWorkspace
  * )
  * ```
  */
-export declare function useUser(options: GetUserOptions): UserResult
+export declare function useUser(options: GetUserOptions): UserResult;
+
+/**
+ * Returns a single user application by id.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ *
+ * @public
+ * @param userApplicationId - The user application id.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export declare const useUserApplication: (
+  userApplicationId: string,
+) => FetcherHookResult<UserApplication>;
+
+/**
+ * Returns the current user's applications for the given organisation.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ *
+ * @public
+ * @param options - Options identifying the organisation.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export declare const useUserApplications: (
+  options: UserApplicationsOptions,
+) => FetcherHookResult<UserApplication[]>;
 
 /**
  *
@@ -3098,8 +3920,14 @@ export declare function useUser(options: GetUserOptions): UserResult
  *   </div>
  * )
  * ```
+ * @remarks
+ * For project-scoped queries the `projectId` is resolved in order from:
+ * 1. an explicit `projectId` option
+ * 2. A legacy ProjectContext (e.g. a `<ResourceProvider projectId="…">` with no dataset), then
+ * 3. The active resource (`ResourceProvider`/`SDKProvider`)
+ * 4. `instance.config`.
  */
-export declare function useUsers(options?: GetUsersOptions): UsersResult
+export declare function useUsers(options?: GetUsersOptions): UsersResult;
 
 /**
  * Hook that verifies the current projects belongs to the organization ID specified in the dashboard context.
@@ -3124,7 +3952,7 @@ export declare function useUsers(options?: GetUsersOptions): UsersResult
 export declare function useVerifyOrgProjects(
   disabled?: boolean,
   projectIds?: string[],
-): string | null
+): string | null;
 
 /**
  * @internal
@@ -3142,68 +3970,122 @@ export declare function useWindowConnection<
   name,
   connectTo,
   onMessage,
-}: UseWindowConnectionOptions<TFrameMessage>): WindowConnection<TWindowMessage>
+}: UseWindowConnectionOptions<TFrameMessage>): WindowConnection<TWindowMessage>;
 
 /**
  * @internal
  */
-export declare interface UseWindowConnectionOptions<TMessage extends FrameMessage> {
-  name: string
-  connectTo: string
-  onMessage?: Record<TMessage['type'], WindowMessageHandler<TMessage>>
+export declare interface UseWindowConnectionOptions<
+  TMessage extends FrameMessage,
+> {
+  name: string;
+  connectTo: string;
+  onMessage?: Record<TMessage["type"], WindowMessageHandler<TMessage>>;
 }
 
+/**
+ * Sets the browser's document title, automatically including the app's name
+ * from the manifest.
+ *
+ * This follows the same convention as Sanity Studio workspaces, where the
+ * workspace name is always present in the title:
+ *
+ * - With a view title: `<viewTitle> | <appTitle>`
+ * - Without a view title: `<appTitle>`
+ *
+ * The Sanity dashboard appends `| Sanity` to produce the final browser tab title.
+ *
+ * @param viewTitle - An optional view-specific title to prepend to the app title.
+ *
+ * @example
+ * ```tsx
+ * import {useWindowTitle} from '@sanity/sdk-react'
+ *
+ * function MoviesList() {
+ *   useWindowTitle('Movies')
+ *   return <div>...</div>
+ * }
+ *
+ * // Browser tab: "Movies | My App | Sanity"
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Call without arguments to show just the app title
+ * function AppRoot() {
+ *   useWindowTitle()
+ *   return <Outlet />
+ * }
+ *
+ * // Browser tab: "My App | Sanity"
+ * ```
+ *
+ * @public
+ */
+export declare function useWindowTitle(viewTitle?: string): void;
+
 /**
  * @internal
  */
 export declare interface WindowConnection<TMessage extends WindowMessage> {
-  sendMessage: <TType extends TMessage['type']>(
+  sendMessage: <TType extends TMessage["type"]>(
     type: TType,
     data?: Extract<
       TMessage,
       {
-        type: TType
+        type: TType;
       }
-    >['data'],
-  ) => void
+    >["data"],
+  ) => void;
   fetch: <TResponse>(
     type: string,
     data?: MessageData,
     options?: {
-      signal?: AbortSignal
-      suppressWarnings?: boolean
-      responseTimeout?: number
+      signal?: AbortSignal;
+      suppressWarnings?: boolean;
+      responseTimeout?: number;
     },
-  ) => Promise<TResponse>
+  ) => Promise<TResponse>;
 }
 
 /**
  * @internal
  */
 export declare type WindowMessageHandler<TFrameMessage extends FrameMessage> = (
-  event: TFrameMessage['data'],
-) => TFrameMessage['response']
+  event: TFrameMessage["data"],
+) => TFrameMessage["response"];
 
 /**
- * You should generally prefer to use the React-layer handle types (ResourceHandle, DocumentHandle) from '\@sanity/sdk-react' instead.
- * This type is useful for non-handles (like document actions) that we still want to resolve resources for.
  * Adds React hook support (resourceName resolution) to core types.
- * @internal
+ * Prefer using the React-layer handle types (ResourceHandle, DocumentHandle)
+ * from `@sanity/sdk-react` — this wrapper is kept for cases where overloads
+ * don't fit (e.g. non-handle options objects).
+ *
+ * @typeParam T - The core type to extend (must have optional `resource` field)
+ * @beta
  */
-declare type WithResourceNameSupport<T> = Omit<T, 'resource'> & {
-  resource?: DocumentResource
+declare type WithResourceNameSupport<
+  T extends {
+    resource?: DocumentResource;
+  },
+> = T & {
   /**
    * Optional name of a resource to resolve from context.
    * If provided, will be resolved to a `DocumentResource` via `ResourcesContext`.
    * @beta
    */
-  resourceName?: string
-}
+  resourceName?: string;
+  /**
+   * @deprecated Use `resourceName` instead.
+   * @beta
+   */
+  sourceName?: string;
+};
 
 declare interface WorkspacesByProjectIdDataset {
-  [key: `${string}:${string}`]: DashboardResource[]
+  [key: `${string}:${string}`]: DashboardResource[];
 }
 
-export * from '@sanity/sdk'
+export * from "@sanity/sdk";
 
-export {}
+export {};