@sanity/sdk-react 0.0.0-alpha.3 → 0.0.0-alpha.30

package/dist/index.d.ts

@@ -1,7 +1,2395 @@
+import {ActionsResult} from '@sanity/sdk'
+import {ApplyDocumentActionsOptions} from '@sanity/sdk'
+import {AuthState} from '@sanity/sdk'
+import {CanvasResource} from '@sanity/message-protocol'
+import {ClientOptions} from '@sanity/sdk'
+import {CurrentUser} from '@sanity/sdk'
+import {DatasetHandle} from '@sanity/sdk'
+import {DatasetsResponse} from '@sanity/client'
+import {DocumentAction} from '@sanity/sdk'
+import {DocumentEvent} from '@sanity/sdk'
+import {DocumentHandle} from '@sanity/sdk'
+import {DocumentOptions} from '@sanity/sdk'
+import {DocumentPermissionsResult} from '@sanity/sdk'
+import {FallbackProps} from 'react-error-boundary'
+import {FavoriteStatusResponse} from '@sanity/sdk'
+import {FrameMessage} from '@sanity/sdk'
+import {GetUsersOptions} from '@sanity/sdk'
+import {JsonMatch} from '@sanity/sdk'
+import {MediaResource} from '@sanity/message-protocol'
+import {PerspectiveHandle} from '@sanity/sdk'
+import {PreviewValue} from '@sanity/sdk'
+import {ProjectHandle} from '@sanity/sdk'
+import {QueryOptions} from '@sanity/sdk'
+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 {SanityDocumentResult} from 'groq'
+import {SanityInstance} from '@sanity/sdk'
+import {SanityProject} from '@sanity/sdk'
+import {SanityProject as SanityProject_2} from '@sanity/client'
+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 {ValidProjection} from '@sanity/sdk'
+import {WindowMessage} from '@sanity/sdk'
+
+/**
+ * A component that handles authentication flow and error boundaries for a
+ * protected section of the application.
+ *
+ * @remarks
+ * This component manages different authentication states and renders the
+ * appropriate components based on that state.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <AuthBoundary header={<MyLogo />}>
+ *       <ProtectedContent />
+ *     </AuthBoundary>
+ *   )
+ * }
+ * ```
+ *
+ * @internal
+ */
+export declare function AuthBoundary({
+  LoginErrorComponent,
+  ...props
+}: AuthBoundaryProps): React.ReactNode
+
+/**
+ * @public
+ */
+export declare interface AuthBoundaryProps {
+  /**
+   * Custom component to render the login screen.
+   * Receives all props. Defaults to {@link Login}.
+   */
+  LoginComponent?: React.ComponentType<{
+    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
+  }>
+  /**
+   * Custom component to render when authentication errors occur.
+   * Receives error boundary props and layout props. Defaults to
+   * {@link LoginError}
+   */
+  LoginErrorComponent?: React.ComponentType<LoginErrorProps>
+  /** Header content to display */
+  header?: React.ReactNode
+  /**
+   * The project IDs to use for organization verification.
+   */
+  projectIds?: string[]
+  /** Footer content to display */
+  footer?: React.ReactNode
+  /** Protected content to render when authenticated */
+  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.
+   *
+   * 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
+}
+
+/**
+ * @public
+ */
+export declare type ComlinkStatus = 'idle' | 'handshaking' | 'connected' | 'disconnected'
+
+declare interface DashboardResource {
+  id: string
+  name: string
+  title: string
+  basePath: string
+  projectId: string
+  dataset: string
+  type: string
+  userApplicationId: string
+  url: string
+}
+
+export {DatasetsResponse}
+
+declare interface DocumentInteractionHistory {
+  recordEvent: (eventType: 'viewed' | 'edited' | 'created' | 'deleted') => void
+  isConnected: boolean
+}
+
+/**
+ * Configuration options for the useDocuments hook
+ *
+ * @beta
+ * @category Types
+ */
+export declare interface DocumentsOptions<
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+> extends DatasetHandle<TDataset, TProjectId>,
+    Pick<QueryOptions, 'perspective' | 'params'> {
+  /**
+   * Filter documents by their `_type`. Can be a single type or an array of types.
+   */
+  documentType?: TDocumentType | TDocumentType[]
+  /**
+   * GROQ filter expression to apply to the query
+   */
+  filter?: string
+  /**
+   * Number of items to load per batch (defaults to 25)
+   */
+  batchSize?: number
+  /**
+   * Sorting configuration for the results
+   */
+  orderings?: SortOrderingItem[]
+  /**
+   * Text search query to filter results
+   */
+  search?: string
+}
+
+/**
+ * Return value from the useDocuments hook
+ *
+ * @beta
+ * @category Types
+ */
+export declare interface DocumentsResponse<
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+> {
+  /**
+   * Array of document handles for the current batch
+   */
+  data: DocumentHandle<TDocumentType, TDataset, TProjectId>[]
+  /**
+   * Whether there are more items available to load
+   */
+  hasMore: boolean
+  /**
+   * Total count of items matching the query
+   */
+  count: number
+  /**
+   * Whether a query is currently in progress
+   */
+  isPending: boolean
+  /**
+   * Function to load the next batch of results
+   */
+  loadMore: () => void
+}
+
+/**
+ * @internal
+ */
+export declare interface FrameConnection<TFrameMessage extends FrameMessage> {
+  connect: (frameWindow: Window) => () => void
+  sendMessage: <T extends TFrameMessage['type']>(
+    ...params: Extract<
+      TFrameMessage,
+      {
+        type: T
+      }
+    >['data'] extends undefined
+      ? [type: T]
+      : [
+          type: T,
+          data: Extract<
+            TFrameMessage,
+            {
+              type: T
+            }
+          >['data'],
+        ]
+  ) => void
+}
+
+/**
+ * @alpha
+ */
+declare type LoginErrorProps = FallbackProps
+
+declare interface ManageFavorite extends FavoriteStatusResponse {
+  favorite: () => Promise<void>
+  unfavorite: () => Promise<void>
+  isFavorited: boolean
+  isConnected: boolean
+}
+
+/**
+ * @public
+ */
+declare type MessageData = Record<string, unknown> | undefined
+
+/**
+ * @internal
+ */
+export declare type MessageHandler<TWindowMessage extends WindowMessage> = (
+  event: TWindowMessage['data'],
+) => TWindowMessage['response'] | Promise<TWindowMessage['response']>
+
+/**
+ * @public
+ * @category Types
+ */
+export declare interface NavigateToStudioResult {
+  navigateToStudioDocument: () => void
+  isConnected: boolean
+}
+
+/**
+ * Configuration options for the usePaginatedDocuments hook
+ *
+ * @beta
+ * @category Types
+ */
+export declare interface PaginatedDocumentsOptions<
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+> extends Omit<QueryOptions<TDocumentType, TDataset, TProjectId>, 'query'> {
+  documentType?: TDocumentType | TDocumentType[]
+  /**
+   * GROQ filter expression to apply to the query
+   */
+  filter?: string
+  /**
+   * Number of items to display per page (defaults to 25)
+   */
+  pageSize?: number
+  /**
+   * Sorting configuration for the results
+   */
+  orderings?: SortOrderingItem[]
+  /**
+   * Text search query to filter results
+   */
+  search?: string
+}
+
+/**
+ * Return value from the usePaginatedDocuments hook
+ *
+ * @beta
+ * @category Types
+ */
+export declare interface PaginatedDocumentsResponse<
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+> {
+  /**
+   * Array of document handles for the current page
+   */
+  data: DocumentHandle<TDocumentType, TDataset, TProjectId>[]
+  /**
+   * Whether a query is currently in progress
+   */
+  isPending: boolean
+  /**
+   * Number of items displayed per page
+   */
+  pageSize: number
+  /**
+   * Current page number (1-indexed)
+   */
+  currentPage: number
+  /**
+   * Total number of pages available
+   */
+  totalPages: number
+  /**
+   * Starting index of the current page (0-indexed)
+   */
+  startIndex: number
+  /**
+   * Ending index of the current page (exclusive, 0-indexed)
+   */
+  endIndex: number
+  /**
+   * Total count of items matching the query
+   */
+  count: number
+  /**
+   * Navigate to the first page
+   */
+  firstPage: () => void
+  /**
+   * Whether there is a first page available to navigate to
+   */
+  hasFirstPage: boolean
+  /**
+   * Navigate to the previous page
+   */
+  previousPage: () => void
+  /**
+   * Whether there is a previous page available to navigate to
+   */
+  hasPreviousPage: boolean
+  /**
+   * Navigate to the next page
+   */
+  nextPage: () => void
+  /**
+   * Whether there is a next page available to navigate to
+   */
+  hasNextPage: boolean
+  /**
+   * Navigate to the last page
+   */
+  lastPage: () => void
+  /**
+   * Whether there is a last page available to navigate to
+   */
+  hasLastPage: boolean
+  /**
+   * Navigate to a specific page number
+   * @param pageNumber - The page number to navigate to (1-indexed)
+   */
+  goToPage: (pageNumber: number) => void
+}
+
+/**
+ * @public
+ * @category Types
+ * @interface
+ */
+export declare type ProjectWithoutMembers = Omit<SanityProject_2, 'members'>
+
+/**
+ * This version is provided by pkg-utils at build time
+ * @internal
+ */
+export declare const REACT_SDK_VERSION: {}
+
+/**
+ * Provides a Sanity instance to child components through React Context
+ *
+ * @internal
+ *
+ * @remarks
+ * The ResourceProvider creates a hierarchical structure of Sanity instances:
+ * - When used as a root provider, it creates a new Sanity instance with the given config
+ * - When nested inside another ResourceProvider, it creates a child instance that
+ *   inherits and extends the parent's configuration
+ *
+ * Features:
+ * - Automatically manages the lifecycle of Sanity instances
+ * - Disposes instances when the component unmounts
+ * - Includes a Suspense boundary for data loading
+ * - Enables hierarchical configuration inheritance
+ *
+ * Use this component to:
+ * - Set up project/dataset configuration for an application
+ * - Override specific configuration values in a section of your app
+ * - Create isolated instance hierarchies for different features
+ *
+ * @example Creating a root provider
+ * ```tsx
+ * <ResourceProvider
+ *   projectId="your-project-id"
+ *   dataset="production"
+ *   fallback={<LoadingSpinner />}
+ * >
+ *   <YourApp />
+ * </ResourceProvider>
+ * ```
+ *
+ * @example Creating nested providers with configuration inheritance
+ * ```tsx
+ * // Root provider with production config with nested provider for preview features with custom dataset
+ * <ResourceProvider projectId="abc123" dataset="production" fallback={<Loading />}>
+ *   <div>...Main app content</div>
+ *   <Dashboard />
+ *   <ResourceProvider dataset="preview" fallback={<Loading />}>
+ *     <PreviewFeatures />
+ *   </ResourceProvider>
+ * </ResourceProvider>
+ * ```
+ */
+export declare function ResourceProvider({
+  children,
+  fallback,
+  ...config
+}: ResourceProviderProps): React.ReactNode
+
+/**
+ * Props for the ResourceProvider component
+ * @internal
+ */
+export declare interface ResourceProviderProps extends SanityConfig {
+  /**
+   * React node to show while content is loading
+   * Used as the fallback for the internal Suspense boundary
+   */
+  fallback: React.ReactNode
+  children: React.ReactNode
+}
+
+/**
+ * @public
+ *
+ * The SanityApp component provides your Sanity application with access to your Sanity configuration,
+ * as well as application context and state which is used by the Sanity React hooks. Your application
+ * must be wrapped with the SanityApp component to function properly.
+ *
+ * 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.
+ *
+ * @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.
+ *
+ * @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
+ * ```tsx
+ * import { SanityApp, type SanityConfig } from '@sanity/sdk-react'
+ *
+ * import MyAppRoot from './Root'
+ *
+ * // Single project configuration
+ * const mySanityConfig: SanityConfig = {
+ *   projectId: 'my-project-id',
+ *   dataset: 'production',
+ * }
+ *
+ * // 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 config={mySanityConfig} fallback={<div>Loading…</div>}>
+ *       <MyAppRoot />
+ *     </SanityApp>
+ *   )
+ * }
+ * ```
+ */
+export declare function SanityApp({
+  children,
+  fallback,
+  config,
+  ...props
+}: SanityAppProps): ReactElement
+
+/**
+ * @public
+ * @category Types
+ */
+export declare interface SanityAppProps {
+  config: SanityConfig | SanityConfig[]
+  /** @deprecated use the `config` prop instead. */
+  sanityConfigs?: SanityConfig[]
+  children: React.ReactNode
+  fallback: React.ReactNode
+}
+
+export {SanityDocument}
+
+export {SanityProjectMember}
+
+/**
+ * @internal
+ *
+ * Top-level context provider that provides access to the Sanity SDK.
+ * Creates a hierarchy of ResourceProviders, each providing a SanityInstance that can be
+ * accessed by hooks. The first configuration in the array becomes the default instance.
+ */
+export declare function SDKProvider({
+  children,
+  config,
+  fallback,
+  ...props
+}: SDKProviderProps): ReactElement
+
+/**
+ * @internal
+ */
+export declare interface SDKProviderProps extends AuthBoundaryProps {
+  children: ReactNode
+  config: SanityConfig | SanityConfig[]
+  fallback: ReactNode
+}
+
+export {SortOrderingItem}
+
+declare interface StudioWorkspacesResult {
+  workspacesByProjectIdAndDataset: WorkspacesByProjectIdDataset
+  error: string | null
+  isConnected: boolean
+}
+
+declare type Updater<TValue> = TValue | ((currentValue: TValue) => TValue)
+
+/**
+ * @public
+ */
+declare type UseActiveReleases = {
+  (): ReleaseDocument[]
+}
+
+/**
+ * @public
+
+ * Returns the active releases for the current project,
+ * represented as a list of release documents.
+ *
+ * @returns The active releases for the current project.
+ *
+ * @example
+ * ```tsx
+ * import {useActiveReleases} from '@sanity/sdk-react'
+ *
+ * const activeReleases = useActiveReleases()
+ * ```
+ */
+export declare const useActiveReleases: UseActiveReleases
+
+/**
+ * @beta
+ */
+declare interface UseApplyDocumentActions {
+  (): <
+    TDocumentType extends string = string,
+    TDataset extends string = string,
+    TProjectId extends string = string,
+  >(
+    action:
+      | DocumentAction<TDocumentType, TDataset, TProjectId>
+      | DocumentAction<TDocumentType, TDataset, TProjectId>[],
+    options?: ApplyDocumentActionsOptions,
+  ) => Promise<ActionsResult<SanityDocumentResult<TDocumentType, TDataset, TProjectId>>>
+}
+
+/**
+ * @beta
+ *
+ * Provides a stable callback function for applying one or more document actions.
+ *
+ * This hook wraps the core `applyDocumentActions` functionality from `@sanity/sdk`,
+ * integrating it with the React component lifecycle and {@link SanityInstance}.
+ * It allows you to apply actions generated by functions like `createDocument`,
+ * `editDocument`, `deleteDocument`, `publishDocument`, `unpublishDocument`,
+ * and `discardDocument` to documents.
+ *
+ * Features:
+ * - Applies one or multiple `DocumentAction` objects.
+ * - Supports optimistic updates: Local state reflects changes immediately.
+ * - Handles batching: Multiple actions passed together are sent as a single atomic transaction.
+ * - Integrates with the collaborative editing engine for conflict resolution and state synchronization.
+ *
+ * @category Documents
+ * @returns A stable callback function. When called with a single `DocumentAction` or an array of `DocumentAction`s,
+ * it returns a promise that resolves to an {@link ActionsResult}. The `ActionsResult` contains information about the
+ * outcome, including optimistic results if applicable.
+ *
+ * @remarks
+ * This hook is a fundamental part of interacting with document state programmatically.
+ * It operates within the same unified pipeline as other document hooks like `useDocument` (for reading state)
+ * and {@link useEditDocument} (a higher-level hook specifically for edits).
+ *
+ * When multiple actions are provided in a single call, they are guaranteed to be submitted
+ * as a single transaction to Content Lake. This ensures atomicity for related operations (e.g., creating and publishing a document).
+ *
+ * @function
+ *
+ * @example Publish or unpublish a document
+ * ```tsx
+ * import {
+ *   publishDocument,
+ *   unpublishDocument,
+ *   useApplyDocumentActions,
+ *   type DocumentHandle
+ * } from '@sanity/sdk-react'
+ *
+ * // Define props using the DocumentHandle type
+ * interface PublishControlsProps {
+ *   doc: DocumentHandle
+ * }
+ *
+ * function PublishControls({doc}: PublishControlsProps) {
+ *   const apply = useApplyDocumentActions()
+ *
+ *   const handlePublish = () =>  apply(publishDocument(doc))
+ *   const handleUnpublish = () => apply(unpublishDocument(doc))
+ *
+ *   return (
+ *     <>
+ *       <button onClick={handlePublish}>Publish</button>
+ *       <button onClick={handleUnpublish}>Unpublish</button>
+ *     </>
+ *   )
+ * }
+ * ```
+ *
+ * @example Create and publish a new document
+ * ```tsx
+ * import {
+ *   createDocument,
+ *   publishDocument,
+ *   createDocumentHandle,
+ *   useApplyDocumentActions
+ * } from '@sanity/sdk-react'
+ *
+ * function CreateAndPublishButton({documentType}: {documentType: string}) {
+ *   const apply = useApplyDocumentActions()
+ *
+ *   const handleCreateAndPublish = () => {
+ *     // Create a new handle inside the handler
+ *     const newDocHandle = createDocumentHandle({ documentId: crypto.randomUUID(), documentType })
+ *
+ *     // Apply multiple actions for the new handle as a single transaction
+ *     apply([
+ *       createDocument(newDocHandle),
+ *       publishDocument(newDocHandle),
+ *     ])
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleCreateAndPublish}>
+ *       I'm feeling lucky
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export declare const useApplyDocumentActions: UseApplyDocumentActions
+
+/**
+ * @internal
+ * A React hook that subscribes to authentication state changes.
+ *
+ * This hook provides access to the current authentication state type from the Sanity auth store.
+ * It automatically re-renders when the authentication state changes.
+ *
+ * @remarks
+ * The hook uses `useSyncExternalStore` to safely subscribe to auth state changes
+ * and ensure consistency between server and client rendering.
+ *
+ * @returns The current authentication state type
+ *
+ * @example
+ * ```tsx
+ * function AuthStatus() {
+ *   const authState = useAuthState()
+ *   return <div>Current auth state: {authState}</div>
+ * }
+ * ```
+ */
+export declare const useAuthState: () => AuthState
+
+/**
+ * Hook to get the currently logged in user
+ * @internal
+ * @returns The current user or null if not authenticated
+ */
+export declare const useAuthToken: () => string | null
+
+/**
+ * A React hook that provides a client that subscribes to changes in your application,
+ *
+ * @remarks
+ * This hook is intended for advanced use cases and special API calls that the React SDK
+ * does not yet provide hooks for. We welcome you to get in touch with us to let us know
+ * your use cases for this!
+ *
+ * @category Platform
+ * @returns A Sanity client
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const client = useClient({apiVersion: '2024-11-12'})
+ *   const [document, setDocument] = useState(null)
+ *   useEffect(async () => {
+ *     const doc = client.fetch('*[_id == "myDocumentId"]')
+ *     setDocument(doc)
+ *   }, [])
+ *  return <div>{JSON.stringify(document) ?? 'Loading...'}</div>
+ * }
+ * ```
+ *
+ * @public
+ * @function
+ */
+export declare const useClient: (x: ClientOptions) => SanityClient
+
+declare type UseCurrentUser = {
+  /**
+   * @public
+   *
+   * Provides the currently authenticated user’s profile information.
+   *
+   * @category Users
+   * @returns The current user data
+   *
+   * @example Rendering a basic user profile
+   * ```
+   * const user = useCurrentUser()
+   *
+   * return (
+   *   <figure>
+   *     <img src={user?.profileImage} alt=`Profile image for ${user?.name}` />
+   *     <h2>{user?.name}</h2>
+   *   </figure>
+   * )
+   * ```
+   */
+  (): CurrentUser | null
+}
+
+/**
+ * @public
+ * @function
+ * @TODO This should not return null — users of a custom app will always be authenticated via Core
+ */
+export declare const useCurrentUser: UseCurrentUser
+
+/**
+ * @public
+ *
+ * A React hook that retrieves the dashboard organization ID that is currently selected in the Sanity Dashboard.
+ *
+ * @example
+ * ```tsx
+ * function DashboardComponent() {
+ *   const orgId = useDashboardOrganizationId()
+ *
+ *   if (!orgId) return null
+ *
+ *   return <div>Organization ID: {String(orgId)}</div>
+ * }
+ * ```
+ *
+ * @category Dashboard
+ * @returns The dashboard organization ID (string | undefined)
+ */
+export declare function useDashboardOrganizationId(): string | undefined
+
+declare type UseDatasets = {
+  /**
+   *
+   * Returns metadata for each dataset the current user has access to.
+   *
+   * @category Datasets
+   * @returns The metadata for your the datasets
+   *
+   * @example
+   * ```tsx
+   * const datasets = useDatasets()
+   *
+   * return (
+   *   <select>
+   *     {datasets.map((dataset) => (
+   *       <option key={dataset.name}>{dataset.name}</option>
+   *     ))}
+   *   </select>
+   * )
+   * ```
+   *
+   */
+  (): DatasetsResponse
+}
+
+/**
+ * @public
+ * @function
+ */
+export declare const useDatasets: UseDatasets
+
+declare interface UseDocument {
+  /** @internal */
+  <TDocumentType extends string, TDataset extends string, TProjectId extends string = string>(
+    options: DocumentOptions<undefined, TDocumentType, TDataset, TProjectId>,
+  ): SanityDocumentResult<TDocumentType, TDataset, TProjectId> | null
+  /** @internal */
+  <
+    TPath extends string,
+    TDocumentType extends string,
+    TDataset extends string = string,
+    TProjectId extends string = string,
+  >(
+    options: DocumentOptions<TPath, TDocumentType, TDataset, TProjectId>,
+  ): JsonMatch<SanityDocumentResult<TDocumentType, TDataset, TProjectId>, TPath> | undefined
+  /** @internal */
+  <TData>(options: DocumentOptions<undefined>): TData | null
+  /** @internal */
+  <TData>(options: DocumentOptions<string>): TData | undefined
+  /**
+   * ## useDocument via Type Inference (Recommended)
+   *
+   * @beta
+   *
+   * The preferred way to use this hook when working with Sanity Typegen.
+   *
+   * 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 and loaded.
+   *
+   * 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
+   *
+   * @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 (or nested value if path provided).
+   *
+   * @example Basic document fetch
+   * ```tsx
+   * import {useDocument, type DocumentHandle} from '@sanity/sdk-react'
+   *
+   * interface ProductViewProps {
+   *   doc: DocumentHandle<'product'> // Typegen infers product type
+   * }
+   *
+   * function ProductView({doc}: ProductViewProps) {
+   *   const product = useDocument({...doc}) // Fully typed product
+   *   return <h1>{product.title ?? 'Untitled'}</h1>
+   * }
+   * ```
+   *
+   * @example Fetching a specific field
+   * ```tsx
+   * import {useDocument, type DocumentHandle} from '@sanity/sdk-react'
+   *
+   * interface ProductTitleProps {
+   *   doc: DocumentHandle<'product'>
+   * }
+   *
+   * function ProductTitle({doc}: ProductTitleProps) {
+   *   const title = useDocument({
+   *     ...doc,
+   *     path: 'title' // Returns just the title field
+   *   })
+   *   return <h1>{title ?? 'Untitled'}</h1>
+   * }
+   * ```
+   *
+   * @inlineType DocumentOptions
+   */
+  <
+    TPath extends string | undefined = undefined,
+    TDocumentType extends string = string,
+    TDataset extends string = string,
+    TProjectId extends string = string,
+  >(
+    options: DocumentOptions<TPath, TDocumentType, TDataset, TProjectId>,
+  ): TPath extends string
+    ? JsonMatch<SanityDocumentResult<TDocumentType, TDataset, TProjectId>, TPath> | undefined
+    : SanityDocumentResult<TDocumentType, TDataset, TProjectId> | null
+  /**
+   * @beta
+   *
+   * ## useDocument via Explicit Types
+   *
+   * Use this version when:
+   * - You're not using Sanity Typegen
+   * - You need to manually specify document types
+   * - You're working with dynamic document types
+   *
+   * Key differences from Typegen version:
+   * - Requires manual type specification via `TData`
+   * - Returns `TData | null` for full documents
+   * - Returns `TData | undefined` for nested values
+   *
+   * This hook will suspend while the document data is being fetched.
+   *
+   * @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)
+   *
+   * @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 book = useDocument<Book>({...doc})
+   *   return <h1>{book?.title ?? 'Untitled'} by {book?.author ?? 'Unknown'}</h1>
+   * }
+   * ```
+   *
+   * @example Fetching a specific field with explicit type
+   * ```tsx
+   * import {useDocument, type DocumentHandle} from '@sanity/sdk-react'
+   *
+   * interface BookTitleProps {
+   *   doc: DocumentHandle
+   * }
+   *
+   * function BookTitle({doc}: BookTitleProps) {
+   *   const title = useDocument<string>({...doc, path: 'title'})
+   *   return <h1>{title ?? 'Untitled'}</h1>
+   * }
+   * ```
+   *
+   * @inlineType DocumentOptions
+   */
+  <TData, TPath extends string>(
+    options: DocumentOptions<TPath>,
+  ): TPath extends string ? TData | undefined : TData | null
+  /**
+   * @internal
+   */
+  (options: DocumentOptions): unknown
+}
+
+/**
+ * @beta
+ * Reads and subscribes to a document's realtime state, incorporating both local and remote changes.
+ *
+ * This hook comes in two main flavors to suit your needs:
+ *
+ * 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.
+ * However, it can be resource-intensive since it maintains a realtime connection.
+ *
+ * For simpler cases where:
+ * - You only need to display content
+ * - Realtime updates aren't critical
+ * - You want better performance
+ *
+ * …consider using {@link useProjection} or {@link useQuery} instead. These hooks are more efficient
+ * for read-heavy applications.
+ *
+ * @function
+ */
+export declare const useDocument: UseDocument
+
+/**
+ *
+ * @beta
+ *
+ * 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 `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 {createDatasetHandle, type DatasetHandle, type DocumentEvent, useDocumentEvent} from '@sanity/sdk-react'
+ * import {useToast} from './my-ui-library'
+ *
+ * // 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({...datasetHandle}: DocumentToastsOptions = {}) {
+ *   const showToast = useToast() // Get the toast function
+ *
+ *   // Define the event handler logic to show toasts on specific events
+ *   const handleEvent = (event: DocumentEvent) => {
+ *     if (event.type === 'published') {
+ *       showToast(`Document ${event.documentId} published.`)
+ *     } else if (event.type === 'unpublished') {
+ *       showToast(`Document ${event.documentId} unpublished.`)
+ *     } 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({
+ *     ...datasetHandle, // Spread the dataset handle (projectId, dataset)
+ *     onEvent: handleEvent,
+ *   })
+ * }
+ *
+ * function MyComponentWithToasts() {
+ *   // Use the custom hook, passing specific handle info
+ *   const specificHandle = createDatasetHandle({ projectId: 'p1', dataset: 'ds1' })
+ *   useDocumentToasts(specificHandle)
+ *
+ *   // // Or use it relying on context for the handle
+ *   // useDocumentToasts()
+ *
+ *   return <div>...</div>
+ * }
+ * ```
+ */
+export declare function useDocumentEvent<
+  TDataset extends string = string,
+  TProjectId extends string = string,
+>(options: UseDocumentEventOptions<TDataset, TProjectId>): void
+
+/**
+ * @beta
+ */
+declare interface UseDocumentEventOptions<
+  TDataset extends string = string,
+  TProjectId extends string = string,
+> extends DatasetHandle<TDataset, TProjectId> {
+  onEvent: (documentEvent: DocumentEvent) => void
+}
+
+/**
+ *
+ * @public
+ *
+ * Check if the current user has the specified permissions for the given document actions.
+ *
+ * @category Permissions
+ * @param actionOrActions - One or more document action functions (e.g., `publishDocument(handle)`).
+ * @returns An object that specifies whether the action is allowed; if the action is not allowed, an explanatory message and list of reasons is also provided.
+ *
+ * @remarks
+ * When passing multiple actions, all actions must belong to the same project and dataset.
+ * Note, however, that you can check permissions on multiple documents from the same project and dataset (as in the second example below).
+ *
+ * @example Checking for permission to publish a document
+ * ```tsx
+ * import {
+ *   useDocumentPermissions,
+ *   useApplyDocumentActions,
+ *   publishDocument,
+ *   createDocumentHandle,
+ *   type DocumentHandle
+ * } from '@sanity/sdk-react'
+ *
+ * // Define props using the DocumentHandle type
+ * interface PublishButtonProps {
+ *   doc: DocumentHandle
+ * }
+ *
+ * function PublishButton({doc}: PublishButtonProps) {
+ *   const publishAction = publishDocument(doc)
+ *
+ *   // Pass the same action call to check permissions
+ *   const publishPermissions = useDocumentPermissions(publishAction)
+ *   const apply = useApplyDocumentActions()
+ *
+ *   return (
+ *     <>
+ *       <button
+ *         disabled={!publishPermissions.allowed}
+ *         // Pass the same action call to apply the action
+ *         onClick={() => apply(publishAction)}
+ *         popoverTarget={`${publishPermissions.allowed ? undefined : 'publishButtonPopover'}`}
+ *       >
+ *         Publish
+ *       </button>
+ *       {!publishPermissions.allowed && (
+ *         <div popover id="publishButtonPopover">
+ *           {publishPermissions.message}
+ *         </div>
+ *       )}
+ *     </>
+ *   )
+ * }
+ *
+ * // Usage:
+ * // const doc = createDocumentHandle({ documentId: 'doc1', documentType: 'myType' })
+ * // <PublishButton doc={doc} />
+ * ```
+ *
+ * @example Checking for permissions to edit multiple documents
+ * ```tsx
+ * import {
+ *   useDocumentPermissions,
+ *   editDocument,
+ *   type DocumentHandle
+ * } from '@sanity/sdk-react'
+ *
+ * export default function canEditMultiple(docHandles: DocumentHandle[]) {
+ *   // Create an array containing an editDocument action for each of the document handles
+ *   const editActions = docHandles.map(doc => editDocument(doc))
+ *
+ *   // Return the result of checking for edit permissions on all of the document handles
+ *   return useDocumentPermissions(editActions)
+ * }
+ * ```
+ */
+export declare function useDocumentPermissions(
+  actionOrActions: DocumentAction | DocumentAction[],
+): DocumentPermissionsResult
+
+/**
+ * Retrieves batches of {@link DocumentHandle}s, narrowed by optional filters, text searches, and custom ordering,
+ * with infinite scrolling support. The number of document handles returned per batch is customizable,
+ * and additional batches can be loaded using the supplied `loadMore` function.
+ *
+ * @beta
+ * @category Documents
+ * @param options - Configuration options for the infinite list
+ * @returns An object containing the list of document handles, the loading state, the total count of retrieved document handles, and a function to load more
+ *
+ * @remarks
+ * - 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 projectId and dataset in the options
+ *
+ * @example Basic infinite list with loading more
+ * ```tsx
+ * import {
+ *   useDocuments,
+ *   createDatasetHandle,
+ *   type DatasetHandle,
+ *   type DocumentHandle,
+ *   type SortOrderingItem
+ * } from '@sanity/sdk-react'
+ * import {Suspense} from 'react'
+ *
+ * // Define a component to display a single document (using useProjection for efficiency)
+ * function MyDocumentComponent({doc}: {doc: DocumentHandle}) {
+ *   const {data} = useProjection<{title?: string}>({
+ *     ...doc, // Pass the full handle
+ *     projection: '{title}'
+ *   })
+ *
+ *   return <>{data?.title || 'Untitled'}</>
+ * }
+ *
+ * // Define props for the list component
+ * interface DocumentListProps {
+ *   dataset: DatasetHandle
+ *   documentType: string
+ *   search?: string
+ * }
+ *
+ * function DocumentList({dataset, documentType, search}: DocumentListProps) {
+ *   const { data, hasMore, isPending, loadMore, count } = useDocuments({
+ *     ...dataset,
+ *     documentType,
+ *     search,
+ *     batchSize: 10,
+ *     orderings: [{field: '_createdAt', direction: 'desc'}],
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       <p>Total documents: {count}</p>
+ *       <ol>
+ *         {data.map((docHandle) => (
+ *           <li key={docHandle.documentId}>
+ *            <Suspense fallback="Loading…">
+ *              <MyDocumentComponent docHandle={docHandle} />
+ *            </Suspense>
+ *           </li>
+ *         ))}
+ *       </ol>
+ *       {hasMore && (
+ *         <button onClick={loadMore}>
+ *           {isPending ? 'Loading...' : 'Load More'}
+ *         </button>
+ *       )}
+ *     </div>
+ *   )
+ * }
+ *
+ * // Usage:
+ * // const myDatasetHandle = createDatasetHandle({ projectId: 'p1', dataset: 'production' })
+ * // <DocumentList dataset={myDatasetHandle} documentType="post" search="Sanity" />
+ * ```
+ *
+ * @example Using `filter` and `params` options for narrowing a collection
+ * ```tsx
+ * import {useState} from 'react'
+ * import {useDocuments} from '@sanity/sdk-react'
+ *
+ * export default function FilteredAuthors() {
+ *   const [max, setMax] = useState(2)
+ *   const {data} = useDocuments({
+ *     documentType: 'author',
+ *     filter: 'length(books) <= $max',
+ *     params: {max},
+ *   })
+ *
+ *   return (
+ *     <>
+ *       <input
+ *         id="maxBooks"
+ *         type="number"
+ *         value={max}
+ *         onChange={e => setMax(e.currentTarget.value)}
+ *       />
+ *       {data.map(author => (
+ *         <Suspense key={author.documentId}>
+ *           <MyAuthorComponent documentHandle={author} />
+ *         </Suspense>
+ *       ))}
+ *     </>
+ *   )
+ * }
+ * ```
+ */
+export declare function useDocuments<
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+>({
+  batchSize,
+  params,
+  search,
+  filter,
+  orderings,
+  documentType,
+  ...options
+}: DocumentsOptions<TDocumentType, TDataset, TProjectId>): DocumentsResponse<
+  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 `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
+   * import {useDocumentSyncStatus, createDocumentHandle, type DocumentHandle} from '@sanity/sdk-react'
+   *
+   * // Define props including the DocumentHandle type
+   * interface SyncIndicatorProps {
+   *   doc: DocumentHandle
+   * }
+   *
+   * function SyncIndicator({doc}: SyncIndicatorProps) {
+   *   const isSynced = useDocumentSyncStatus(doc)
+   *
+   *   return (
+   *     <div className={`sync-status ${isSynced ? 'synced' : 'pending'}`}>
+   *       {isSynced ? '✓ Synced' : 'Saving changes...'}
+   *     </div>
+   *   )
+   * }
+   *
+   * // Usage:
+   * // const doc = createDocumentHandle({ documentId: 'doc1', documentType: 'myType' })
+   * // <SyncIndicator doc={doc} />
+   * ```
+   */
+  (doc: DocumentHandle): boolean
+}
+
+/**
+ * @beta
+ * @function
+ */
+export declare const useDocumentSyncStatus: UseDocumentSyncStatus
+
+/**
+ * @beta
+ * 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<SanityDocumentResult<TDocumentType, TDataset, TProjectId>>,
+) => Promise<ActionsResult<SanityDocumentResult<TDocumentType, TDataset, TProjectId>>>
+
+/**
+ * @beta
+ * 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<SanityDocumentResult<TDocumentType, TDataset, TProjectId>, TPath>>,
+) => Promise<ActionsResult<SanityDocumentResult<TDocumentType, TDataset, TProjectId>>>
+
+/**
+ * @beta
+ * Edit an entire document with an explicit type `TData`.
+ *
+ * @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: DocumentOptions<undefined>,
+): (nextValue: Updater<TData>) => Promise<ActionsResult>
+
+/**
+ * @beta
+ * Edit a specific path within a document with an explicit type `TData`.
+ *
+ * @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: DocumentOptions<string>,
+): (nextValue: Updater<TData>) => Promise<ActionsResult>
+
+/**
+ * @internal
+ */
+export declare function useFrameConnection<
+  TFrameMessage extends FrameMessage,
+  TWindowMessage extends WindowMessage,
+>(options: UseFrameConnectionOptions<TWindowMessage>): FrameConnection<TFrameMessage>
+
+/**
+ * @internal
+ */
+export declare interface UseFrameConnectionOptions<TWindowMessage extends WindowMessage> {
+  name: string
+  connectTo: string
+  targetOrigin: string
+  onMessage?: {
+    [K in TWindowMessage['type']]: (
+      data: Extract<
+        TWindowMessage,
+        {
+          type: K
+        }
+      >['data'],
+    ) => void
+  }
+  heartbeat?: boolean
+  onStatus?: (status: ComlinkStatus) => void
+}
+
+/**
+ * @internal
+ * A React hook that returns a function for handling authentication callbacks.
+ *
+ * @remarks
+ * This hook provides access to the authentication store's callback handler,
+ * which processes auth redirects by extracting the session ID and fetching the
+ * authentication token. If fetching the long-lived token is successful,
+ * `handleAuthCallback` will return a Promise that resolves a new location that
+ * removes the short-lived token from the URL. Use this in combination with
+ * `history.replaceState` or your own router's `replace` function to update the
+ * current location without triggering a reload.
+ *
+ * @example
+ * ```tsx
+ * function AuthCallback() {
+ *   const handleAuthCallback = useHandleAuthCallback()
+ *   const router = useRouter() // Example router
+ *
+ *   useEffect(() => {
+ *     async function processCallback() {
+ *       // Handle the callback and get the cleaned URL
+ *       const newUrl = await handleAuthCallback(window.location.href)
+ *
+ *       if (newUrl) {
+ *         // Replace URL without triggering navigation
+ *         router.replace(newUrl, {shallow: true})
+ *       }
+ *     }
+ *
+ *     processCallback().catch(console.error)
+ *   }, [handleAuthCallback, router])
+ *
+ *   return <div>Completing login...</div>
+ * }
+ * ```
+ *
+ * @returns A callback handler function that processes OAuth redirects
+ * @public
+ */
+export declare const useHandleAuthCallback: () => (
+  locationHref?: string | undefined,
+) => Promise<string | false>
+
+/**
+ * @internal
+ */
+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>
+
+/**
+ * @internal
+ *
+ * This hook provides functionality to add and remove documents from favorites,
+ * and tracks the current favorite status of the document.
+ * @param documentHandle - The document handle containing document ID and type, like `{_id: '123', _type: 'book'}`
+ * @returns An object containing:
+ * - `favorite` - Function to add document to favorites
+ * - `unfavorite` - Function to remove document from favorites
+ * - `isFavorited` - Boolean indicating if document is currently favorited
+ * - `isConnected` - Boolean indicating if connection to Dashboard UI is established
+ *
+ * @example
+ * ```tsx
+ * function FavoriteButton(props: DocumentActionProps) {
+ *   const {documentId, documentType} = props
+ *   const {favorite, unfavorite, isFavorited, isConnected} = useManageFavorite({
+ *     documentId,
+ *     documentType
+ *   })
+ *
+ *   return (
+ *     <Button
+ *       disabled={!isConnected}
+ *       onClick={() => isFavorited ? unfavorite() : favorite()}
+ *       text={isFavorited ? 'Remove from favorites' : 'Add to favorites'}
+ *     />
+ *   )
+ * }
+ *
+ * // Wrap the component with Suspense since the hook may suspend
+ * function MyDocumentAction(props: DocumentActionProps) {
+ *   return (
+ *     <Suspense
+ *       fallback={
+ *         <Button
+ *           text="Loading..."
+ *           disabled
+ *         />
+ *       }
+ *     >
+ *       <FavoriteButton {...props} />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
+ */
+export declare function useManageFavorite({
+  documentId,
+  documentType,
+  projectId: paramProjectId,
+  dataset: paramDataset,
+  resourceId: paramResourceId,
+  resourceType,
+  schemaName,
+}: UseManageFavoriteProps): ManageFavorite
+
+declare interface UseManageFavoriteProps extends DocumentHandle {
+  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
+}
+
 /**
- * An example function that will be removed.
  * @public
+ *
+ * Hook that provides a function to navigate to a given document in its parent Studio.
+ *
+ * Uses the `projectId` and `dataset` properties of the {@link DocumentHandle} you provide to resolve the correct Studio.
+ * This will only work if you have deployed a studio with a workspace with this `projectId` / `dataset` combination.
+ *
+ * @remarks If you write your own Document Handle to pass to this hook (as opposed to a Document Handle generated by another hook),
+ * it must include values for `documentId`, `documentType`, `projectId`, and `dataset`.
+ *
+ * @category Documents
+ * @param documentHandle - The document handle for the document to navigate to
+ * @param preferredStudioUrl - The preferred studio url to navigate to if you have multiple
+ * studios with the same projectId and dataset
+ * @returns An object containing:
+ * - `navigateToStudioDocument` - Function that when called will navigate to the studio document
+ * - `isConnected` - Boolean indicating if connection to Dashboard is established
+ *
+ * @example
+ * ```ts
+ * import {useNavigateToStudioDocument, type DocumentHandle} from '@sanity/sdk-react'
+ *
+ * function MyComponent({documentHandle}: {documentHandle: DocumentHandle}) {
+ *   const {navigateToStudioDocument, isConnected} = useNavigateToStudioDocument(documentHandle)
+ *
+ *   return (
+ *     <button onClick={navigateToStudioDocument} disabled={!isConnected}>
+ *       Navigate to Studio Document
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export declare function useNavigateToStudioDocument(
+  documentHandle: DocumentHandle,
+  preferredStudioUrl?: string,
+): NavigateToStudioResult
+
+/**
+ * Retrieves pages of {@link DocumentHandle}s, narrowed by optional filters, text searches, and custom ordering,
+ * with support for traditional paginated interfaces. The number of document handles returned per page is customizable,
+ * while page navigation is handled via the included navigation functions.
+ *
+ * @beta
+ * @category Documents
+ * @param options - Configuration options for the paginated list
+ * @returns An object containing the list of document handles, pagination details, and functions to navigate between pages
+ *
+ * @remarks
+ * - 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 projectId and dataset in the options
+ *
+ * @example Paginated list of documents with navigation
+ * ```tsx
+ * import {
+ *   usePaginatedDocuments,
+ *   createDatasetHandle,
+ *   type DatasetHandle,
+ *   type DocumentHandle,
+ *   type SortOrderingItem,
+ *   useProjection
+ * } from '@sanity/sdk-react'
+ * import {Suspense} from 'react'
+ * import {ErrorBoundary} from 'react-error-boundary'
+ *
+ * // Define a component to display a single document row
+ * function MyTableRowComponent({doc}: {doc: DocumentHandle}) {
+ *   const {data} = useProjection<{title?: string}>({
+ *     ...doc,
+ *     projection: '{title}',
+ *   })
+ *
+ *   return (
+ *     <tr>
+ *       <td>{data?.title ?? 'Untitled'}</td>
+ *     </tr>
+ *   )
+ * }
+ *
+ * // Define props for the list component
+ * interface PaginatedDocumentListProps {
+ *   documentType: string
+ *   dataset?: DatasetHandle
+ * }
+ *
+ * function PaginatedDocumentList({documentType, dataset}: PaginatedDocumentListProps) {
+ *   const {
+ *     data,
+ *     isPending,
+ *     currentPage,
+ *     totalPages,
+ *     nextPage,
+ *     previousPage,
+ *     hasNextPage,
+ *     hasPreviousPage
+ *   } = usePaginatedDocuments({
+ *     ...dataset,
+ *     documentType,
+ *     pageSize: 10,
+ *     orderings: [{field: '_createdAt', direction: 'desc'}],
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       <table>
+ *         <thead>
+ *           <tr><th>Title</th></tr>
+ *         </thead>
+ *         <tbody>
+ *           {data.map(doc => (
+ *             <ErrorBoundary key={doc.documentId} fallback={<tr><td>Error loading document</td></tr>}>
+ *               <Suspense fallback={<tr><td>Loading...</td></tr>}>
+ *                 <MyTableRowComponent doc={doc} />
+ *               </Suspense>
+ *             </ErrorBoundary>
+ *           ))}
+ *         </tbody>
+ *       </table>
+ *       <div style={{opacity: isPending ? 0.5 : 1}}>
+ *         <button onClick={previousPage} disabled={!hasPreviousPage || isPending}>Previous</button>
+ *         <span>Page {currentPage} / {totalPages}</span>
+ *         <button onClick={nextPage} disabled={!hasNextPage || isPending}>Next</button>
+ *       </div>
+ *     </div>
+ *   )
+ * }
+ *
+ * // Usage:
+ * // const myDatasetHandle = createDatasetHandle({ projectId: 'p1', dataset: 'production' })
+ * // <PaginatedDocumentList dataset={myDatasetHandle} documentType="post" />
+ * ```
+ */
+export declare function usePaginatedDocuments<
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+>({
+  documentType,
+  filter,
+  pageSize,
+  params,
+  orderings,
+  search,
+  ...options
+}: PaginatedDocumentsOptions<TDocumentType, TDataset, TProjectId>): PaginatedDocumentsResponse<
+  TDocumentType,
+  TDataset,
+  TProjectId
+>
+
+/**
+ * @public
+ */
+declare type UsePerspective = {
+  (perspectiveHandle: PerspectiveHandle): string | string[]
+}
+
+/**
+ * @public
+ *
+ * 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.
+ *
+ * @example
+ * ```tsx
+ * import {usePerspective, useQuery} from '@sanity/sdk-react'
+
+ * const perspective = usePerspective({perspective: 'rxg1346', projectId: 'abc123', dataset: 'production'})
+ * const {data} = useQuery<Movie[]>('*[_type == "movie"]', {
+ *   perspective: perspective,
+ * })
+ * ```
+ *
+ * @returns The perspective for the given perspective handle.
  */
-export declare function main(): void
+export declare const usePerspective: UsePerspective
+
+/**
+ * @beta
+ *
+ * Returns the preview values of a document (specified via a `DocumentHandle`),
+ * including the document’s `title`, `subtitle`, `media`, and `status`. These values are live and will update in realtime.
+ * To reduce unnecessary network requests for resolving the preview values, an optional `ref` can be passed to the hook so that preview
+ * resolution will only occur if the `ref` is intersecting the current viewport.
+ *
+ * @category Documents
+ * @param options - The document handle for the document you want to resolve preview values for, and an optional ref
+ * @returns The preview values for the given document and a boolean to indicate whether the resolution is pending
+ *
+ * @example Combining with useDocuments to render a collection of document previews
+ * ```
+ * // PreviewComponent.jsx
+ * export default function PreviewComponent({ document }) {
+ *   const { data: { title, subtitle, media }, isPending } = usePreview({ document })
+ *   return (
+ *     <article style={{ opacity: isPending ? 0.5 : 1}}>
+ *       {media?.type === 'image-asset' ? <img src={media.url} alt='' /> : ''}
+ *       <h2>{title}</h2>
+ *       <p>{subtitle}</p>
+ *     </article>
+ *   )
+ * }
+ *
+ * // DocumentList.jsx
+ * const { data } = useDocuments({ filter: '_type == "movie"' })
+ * return (
+ *   <div>
+ *     <h1>Movies</h1>
+ *     <ul>
+ *       {data.map(movie => (
+ *         <li key={movie._id}>
+ *           <Suspense fallback='Loading…'>
+ *             <PreviewComponent document={movie} />
+ *           </Suspense>
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   </div>
+ * )
+ * ```
+ */
+export declare function usePreview({ref, ...docHandle}: UsePreviewOptions): UsePreviewResults
+
+/**
+ * @beta
+ * @category Types
+ */
+export declare interface UsePreviewOptions 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>
+}
+
+/**
+ * @beta
+ * @category Types
+ */
+export declare interface UsePreviewResults {
+  /** The results of resolving the document’s preview values */
+  data: PreviewValue
+  /** True when preview values are being refreshed */
+  isPending: boolean
+}
+
+declare type UseProject = {
+  /**
+   *
+   * Returns metadata for a given project
+   *
+   * @category Projects
+   * @param projectId - The ID of the project to retrieve metadata for
+   * @returns The metadata for the project
+   * @example
+   * ```tsx
+   *  function ProjectMetadata({ projectId }: { projectId: string }) {
+   *    const project = useProject(projectId)
+   *
+   *    return (
+   *      <figure style={{ backgroundColor: project.metadata.color || 'lavender'}}>
+   *        <h1>{project.displayName}</h1>
+   *      </figure>
+   *    )
+   *  }
+   * ```
+   */
+  (projectHandle?: ProjectHandle): SanityProject
+}
+
+/**
+ * @public
+ * @function
+ */
+export declare const useProject: UseProject
+
+/**
+ * @public
+ *
+ * Returns the projected values of a document based on the provided projection string.
+ * These values are live and will update in realtime.
+ * To optimize network requests, an optional `ref` can be passed to only resolve the projection
+ * when the referenced element is intersecting the viewport.
+ *
+ * @category Documents
+ * @remarks
+ * 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.
+ */
+/**
+ * @beta
+ * 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 {useProjection, 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 } = useProjection({
+ *     ...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 useProjection<
+  TProjection extends ValidProjection = ValidProjection,
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+>(
+  options: UseProjectionOptions<TProjection, TDocumentType, TDataset, TProjectId>,
+): UseProjectionResults<SanityProjectionResult<TProjection, TDocumentType, TDataset, TProjectId>>
+
+/**
+ * @beta
+ * Fetch a projection with an explicitly defined return type `TData`.
+ *
+ * @param options - Options including the document handle properties (`documentId`, etc.) and the `projection`.
+ * @returns The projected data, cast to the explicit type `TData`.
+ *
+ * @example Explicitly typing the projection result
+ * ```tsx
+ * import {useProjection, type DocumentHandle} from '@sanity/sdk-react'
+ * import {useRef} from 'react'
+ *
+ * interface SimpleBookPreview {
+ *   title?: string;
+ *   authorName?: string;
+ * }
+ *
+ * type BookPreviewProps = {
+ *   doc: DocumentHandle
+ * }
+ *
+ * function BookPreview({ doc }: BookPreviewProps) {
+ *   const ref = useRef(null)
+ *   const { data } = useProjection<SimpleBookPreview>({
+ *     ...doc,
+ *     ref,
+ *     projection: `{ title, 'authorName': author->name }`
+ *   })
+ *
+ *   return (
+ *     <div ref={ref}>
+ *       <h3>{data.title ?? 'No Title'}</h3>
+ *       <p>By: {data.authorName ?? 'Unknown'}</p>
+ *     </div>
+ *   )
+ * }
+ *
+ * // Usage:
+ * // import {createDocumentHandle} from '@sanity/sdk-react'
+ * // const doc = createDocumentHandle({ documentId: 'abc', documentType: 'book' })
+ * // <Suspense fallback='Loading...'>
+ * //   <BookPreview doc={doc} />
+ * // </Suspense>
+ * ```
+ */
+export declare function useProjection<TData extends object>(
+  options: UseProjectionOptions,
+): UseProjectionResults<TData>
+
+/**
+ * @public
+ * @category Types
+ */
+export declare interface UseProjectionOptions<
+  TProjection extends ValidProjection = ValidProjection,
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+> extends DocumentHandle<TDocumentType, TDataset, TProjectId> {
+  /** The GROQ projection string */
+  projection: TProjection
+  /** Optional parameters for the projection query */
+  params?: Record<string, unknown>
+  /** Optional ref to track viewport intersection for lazy loading */
+  ref?: React.RefObject<unknown>
+}
+
+/**
+ * @public
+ * @category Types
+ */
+export declare interface UseProjectionResults<TData> {
+  /** The projected data */
+  data: TData
+  /** True if the projection is currently being resolved */
+  isPending: boolean
+}
+
+declare type UseProjects = {
+  /**
+   *
+   * Returns metadata for each project you have access to.
+   *
+   * @category Projects
+   * @returns An array of metadata (minus the projects’ members) for each project
+   * @example
+   * ```tsx
+   * const projects = useProjects()
+   *
+   * return (
+   *   <select>
+   *     {projects.map((project) => (
+   *       <option key={project.id}>{project.displayName}</option>
+   *     ))}
+   *   </select>
+   * )
+   * ```
+   */
+  (): ProjectWithoutMembers[]
+}
+
+/**
+ * @public
+ * @function
+ */
+export declare const useProjects: UseProjects
+
+/**
+ * @beta
+ * 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: QueryOptions<TQuery, TDataset, TProjectId>,
+): {
+  /** The query result, typed based on the GROQ query string */
+  data: SanityQueryResult<TQuery, TDataset, TProjectId>
+  /** True if a query transition is in progress */
+  isPending: boolean
+}
+
+/**
+ * @beta
+ * Executes a GROQ query with an explicitly provided result type `TData`.
+ *
+ * @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
+ * import {useQuery} from '@sanity/sdk-react'
+ *
+ * interface CustomMovieTitle {
+ *   movieTitle?: string
+ * }
+ *
+ * function FirstMovieTitle() {
+ *   // Provide the explicit type TData
+ *   const {data, isPending} = useQuery<CustomMovieTitle>({
+ *     query: '*[_type == "movie"][0]{ "movieTitle": title }'
+ *   })
+ *
+ *   return (
+ *     <h1 style={{ opacity: isPending ? 0.5 : 1 }}>
+ *       {data?.movieTitle ?? 'No title found'}
+ *     </h1>
+ *   )
+ * }
+ * ```
+ */
+export declare function useQuery<TData>(options: QueryOptions): {
+  /** The query result, cast to the provided type TData */
+  data: TData
+  /** True if another query is resolving in the background (suspense handles the initial loading state) */
+  isPending: boolean
+}
+
+/**
+ * @internal
+ * Hook for managing document interaction history in Sanity Studio.
+ * This hook provides functionality to record document interactions.
+ * @category History
+ * @param documentHandle - The document handle containing document ID and type, like `{_id: '123', _type: 'book'}`
+ * @returns An object containing:
+ * - `recordEvent` - Function to record document interactions
+ * - `isConnected` - Boolean indicating if connection to Studio is established
+ *
+ * @example
+ * ```tsx
+ * function MyDocumentAction(props: DocumentActionProps) {
+ *   const {documentId, documentType, resourceType, resourceId} = props
+ *   const {recordEvent, isConnected} = useRecordDocumentHistoryEvent({
+ *     documentId,
+ *     documentType,
+ *     resourceType,
+ *     resourceId,
+ *   })
+ *
+ *   return (
+ *     <Button
+ *       disabled={!isConnected}
+ *       onClick={() => recordEvent('viewed')}
+ *       text={'Viewed'}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+export declare function useRecordDocumentHistoryEvent({
+  documentId,
+  documentType,
+  resourceType,
+  resourceId,
+  schemaName,
+}: UseRecordDocumentHistoryEventProps): DocumentInteractionHistory
+
+/**
+ * @internal
+ */
+declare interface UseRecordDocumentHistoryEventProps extends DocumentHandle {
+  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
+}
+
+/**
+ * @public
+ * @category Types
+ */
+export declare interface UsersResult {
+  /**
+   * The users fetched.
+   */
+  data: SanityUser[]
+  /**
+   * Whether there are more users to fetch.
+   */
+  hasMore: boolean
+  /**
+   * Whether a users request is currently in progress
+   */
+  isPending: boolean
+  /**
+   * Load more users.
+   */
+  loadMore: () => void
+}
+
+/**
+ * Retrieves the current Sanity instance or finds a matching instance from the hierarchy
+ *
+ * @public
+ *
+ * @category Platform
+ * @param config - Optional configuration to match against when finding an instance
+ * @returns The current or matching Sanity instance
+ *
+ * @remarks
+ * This hook accesses the nearest Sanity instance from the React context. When provided with
+ * a configuration object, it traverses up the instance hierarchy to find the closest instance
+ * that matches the specified configuration using shallow comparison of properties.
+ *
+ * The hook must be used within a component wrapped by a `ResourceProvider` or `SanityApp`.
+ *
+ * Use this hook when you need to:
+ * - Access the current SanityInstance from context
+ * - Find a specific instance with matching project/dataset configuration
+ * - Access a parent instance with specific configuration values
+ *
+ * @example Get the current instance
+ * ```tsx
+ * // Get the current instance from context
+ * const instance = useSanityInstance()
+ * console.log(instance.config.projectId)
+ * ```
+ *
+ * @example Find an instance with specific configuration
+ * ```tsx
+ * // Find an instance matching the given project and dataset
+ * const instance = useSanityInstance({
+ *   projectId: 'abc123',
+ *   dataset: 'production'
+ * })
+ *
+ * // Use instance for API calls
+ * const fetchDocument = (docId) => {
+ *   // Instance is guaranteed to have the matching config
+ *   return client.fetch(`*[_id == $id][0]`, { id: docId })
+ * }
+ * ```
+ *
+ * @example Match partial configuration
+ * ```tsx
+ * // Find an instance with specific auth configuration
+ * const instance = useSanityInstance({
+ *   auth: { requireLogin: true }
+ * })
+ * ```
+ *
+ * @throws Error if no SanityInstance is found in context
+ * @throws Error if no matching instance is found for the provided config
+ */
+export declare const useSanityInstance: (config?: SanityConfig) => SanityInstance
+
+/**
+ * Hook that fetches studio workspaces and organizes them by projectId:dataset
+ * @internal
+ */
+export declare function useStudioWorkspacesByProjectIdDataset(): StudioWorkspacesResult
+
+/**
+ *
+ * @public
+ *
+ * Retrieves the users for a given resource (either a project or an organization).
+ *
+ * @category Users
+ * @param params - The resource type, project ID, and the limit of users to fetch
+ * @returns A list of users, a boolean indicating whether there are more users to fetch, and a function to load more users
+ *
+ * @example
+ * ```
+ * const { data, hasMore, loadMore, isPending } = useUsers({
+ *   resourceType: 'organization',
+ *   organizationId: 'my-org-id',
+ *   batchSize: 10,
+ * })
+ *
+ * return (
+ *   <div>
+ *     {data.map(user => (
+ *       <figure key={user.sanityUserId}>
+ *         <img src={user.profile.imageUrl} alt='' />
+ *         <figcaption>{user.profile.displayName}</figcaption>
+ *         <address>{user.profile.email}</address>
+ *       </figure>
+ *     ))}
+ *     {hasMore && <button onClick={loadMore}>{isPending ? 'Loading...' : 'Load More'</button>}
+ *   </div>
+ * )
+ * ```
+ */
+export declare function useUsers(options?: GetUsersOptions): UsersResult
+
+/**
+ * Hook that verifies the current projects belongs to the organization ID specified in the dashboard context.
+ *
+ * @public
+ * @param disabled - When true, disables verification and skips project verification API calls
+ * @returns Error message if the project doesn't match the organization ID, or null if all match or verification isn't needed
+ *
+ * @example
+ * ```tsx
+ * function OrgVerifier() {
+ *   const error = useVerifyOrgProjects()
+ *
+ *   if (error) {
+ *     return <div className="error">{error}</div>
+ *   }
+ *
+ *   return <div>Organization projects verified!</div>
+ * }
+ * ```
+ */
+export declare function useVerifyOrgProjects(
+  disabled?: boolean,
+  projectIds?: string[],
+): string | null
+
+/**
+ * @internal
+ * Hook to wrap a Comlink node in a React hook.
+ * Our store functionality takes care of the lifecycle of the node,
+ * as well as sharing a single node between invocations if they share the same name.
+ *
+ * Generally not to be used directly, but to be used as a dependency of
+ * Comlink-powered hooks like `useManageFavorite`.
+ */
+export declare function useWindowConnection<
+  TWindowMessage extends WindowMessage,
+  TFrameMessage extends FrameMessage,
+>({
+  name,
+  connectTo,
+  onMessage,
+  onStatus,
+}: UseWindowConnectionOptions<TFrameMessage>): WindowConnection<TWindowMessage>
+
+/**
+ * @internal
+ */
+export declare interface UseWindowConnectionOptions<TMessage extends FrameMessage> {
+  name: string
+  connectTo: string
+  onMessage?: Record<TMessage['type'], WindowMessageHandler<TMessage>>
+  onStatus?: (status: ComlinkStatus) => void
+}
+
+/**
+ * @internal
+ */
+export declare interface WindowConnection<TMessage extends WindowMessage> {
+  sendMessage: <TType extends TMessage['type']>(
+    type: TType,
+    data?: Extract<
+      TMessage,
+      {
+        type: TType
+      }
+    >['data'],
+  ) => void
+  fetch: <TResponse>(
+    type: string,
+    data?: MessageData,
+    options?: {
+      signal?: AbortSignal
+      suppressWarnings?: boolean
+      responseTimeout?: number
+    },
+  ) => Promise<TResponse>
+}
+
+/**
+ * @internal
+ */
+export declare type WindowMessageHandler<TFrameMessage extends FrameMessage> = (
+  event: TFrameMessage['data'],
+) => TFrameMessage['response']
+
+declare interface WorkspacesByProjectIdDataset {
+  [key: `${string}:${string}`]: DashboardResource[]
+}
+
+export * from '@sanity/sdk'
 
 export {}