import * as _$react from "react"; import { CSSProperties, Component, ComponentProps, ComponentType, Dispatch, ElementType, ErrorInfo, FC, FocusEvent, FocusEventHandler, FormEvent, FormEventHandler, HTMLAttributes, HTMLProps, KeyboardEvent, MutableRefObject, PropsWithChildren, PureComponent, ReactElement, ReactNode, Ref, RefAttributes, RefObject, SVGProps, SetStateAction } from "react"; import * as _$_sanity_types0 from "@sanity/types"; import { ArraySchemaType, AssetMetadataType, AssetSource, AssetSourceSpec, BlockDecoratorDefinition, BlockListDefinition, BlockStyleDefinition, BooleanSchemaType, ConditionalProperty, CrossDatasetReferenceSchemaType, CrossDatasetReferenceValue, CrossDatasetType, CurrentUser, DeprecatedProperty, FieldGroup, File as File$1, FileAsset, FileSchemaType, FileValue, FormNodeValidation, GeopointValue, GlobalDocumentReferenceType, I18nTextRecord, Image, ImageAsset, ImageSchemaType, ImageUrlFitMode, ImageValue, IndexTuple, InitialValueProperty, InitialValueResolverContext, IntrinsicTypeName, KeyedObject, KeyedSegment, MendozaEffectPair, NumberSchemaType, ObjectField, ObjectFieldType, ObjectSchemaType, PatchOperations, Path, PathSegment, PortableTextBlock, PortableTextObject, PortableTextTextBlock, PrepareViewOptions, PreviewValue, Reference, ReferenceSchemaType, ReferenceValue, Role, RuleClass, SanityDocument, SanityDocumentLike, Schema, SchemaType, SchemaTypeDefinition, SearchStrategy, SlugSchemaType, SlugValue, SortOrdering, StrictVersionLayeringOptions, StringSchemaType, TextSchemaType, TransactionLogEventWithEffects, TransactionLogEventWithMutations, UploadState, User, ValidationMarker } from "@sanity/types"; import { BifurClient } from "@sanity/bifur-client"; import { ClientConfig, ClientPerspective, QueryParams, ReconnectEvent, ReleaseDocument, ReleaseDocument as ReleaseDocument$1, ReleaseType, ResetEvent, SanityClient, SanityDocument as SanityDocument$1, SingleActionResult, SingleMutationResult, StackablePerspective, WelcomeBackEvent, WelcomeEvent } from "@sanity/client"; import * as _$_sanity_ui0 from "@sanity/ui"; import { AvatarPosition, AvatarProps, AvatarSize, AvatarStatus, BadgeProps, BadgeTone, BoxProps, ButtonProps, ButtonTone, CardProps, DialogProps, HotkeysProps, MenuButtonProps, MenuItem, Placement, PopoverProps, ResponsivePaddingProps, ResponsiveWidthProps, Text, TextProps, ThemeColorSchemeKey, ToastParams, TooltipProps } from "@sanity/ui"; import { FlatNamespace, KeyPrefix, Namespace, TFunction, TFunction as TFunction$1, i18n as i18n$1 } from "i18next"; import { MonoTypeOperatorFunction, Observable, OperatorFunction, Subject } from "rxjs"; import { IntentLinkProps, IntentParameters, Router, RouterState, SearchParam } from "sanity/router"; import { ScrollToOptions } from "@tanstack/react-virtual"; import * as _$_sanity_telemetry0 from "@sanity/telemetry"; import { DRAFTS_FOLDER, DraftId, PublishedId, VERSION_FOLDER, getDraftId, getPublishedId, getVersionFromId, getVersionId, isDraftId, isPublishedId, isVersionId } from "/home/runner/work/sanity/sanity/node_modules/.pnpm/@sanity+client@7.22.0/node_modules/@sanity/client/dist/csm.js"; import * as _$sanity__singletons0 from "sanity/_singletons"; import { DocumentDivergencesContextValue, DocumentLimitUpsellContextValue, FeedbackContext, FeedbackContextValue, FieldActionsContextValue, HoveredFieldContextValue, LocaleContextValue, SchedulesContext, SingleDocReleaseContextValue } from "sanity/_singletons"; import { Mutation } from "@sanity/mutator"; import { CanvasResource, FrameMessages, MediaResource, StudioResource, WindowMessages } from "@sanity/message-protocol"; import { DocumentHandle } from "@sanity/sdk"; import { FallbackNs } from "react-i18next"; import { BrowserHistory, HashHistory, History, MemoryHistory } from "history"; import { RootTheme, ThemeColorSchemeKey as ThemeColorSchemeKey$1 } from "/home/runner/work/sanity/sanity/node_modules/.pnpm/@sanity+ui@3.1.14_@emotion+is-prop-valid@1.4.0_@sanity+styled-components@6.1.24_react-d_528b1f4be90cc37f64b725ea29f6a91b/node_modules/@sanity/ui/dist/theme.mjs"; import { EditorSelection, HotkeyOptions, InvalidValueResolution, OnCopyFn, OnPasteResultOrPromise, PasteData, Patch, PortableTextEditor, RangeDecoration, RangeDecorationOnMovedDetails, RenderBlockFunction } from "@portabletext/editor"; import { ColorHueKey, ColorTintKey, ColorTints } from "@sanity/color"; import { Subscriber } from "nano-pubsub"; import { ArrayDiff, BooleanDiff, Diff, ItemDiff, NullDiff, NumberDiff, ObjectDiff, StringDiff, StringSegmentChanged, StringSegmentUnchanged, TypeChangeDiff } from "@sanity/diff"; import * as _$styled_components0 from "styled-components"; import { CSSProperties as CSSProperties$1, ExecutionProps } from "styled-components"; import { ThrottleSettings } from "lodash-es/throttle.js"; import { DEFAULT_ANNOTATIONS, DEFAULT_DECORATORS } from "@sanity/schema"; import * as _$styled_components_dist_types0 from "/home/runner/work/sanity/sanity/node_modules/.pnpm/@sanity+styled-components@6.1.24_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@sanity/styled-components/dist/types.js"; import { PortableTextMemberSchemaTypes } from "@portabletext/sanity-bridge"; import { ImageUrlBuilder, ImageUrlBuilder as ImageUrlBuilder$1 } from "@sanity/image-url"; import { MarkdownShortcutsPluginProps } from "@portabletext/plugin-markdown-shortcuts"; import { PasteLinkPluginProps } from "@portabletext/plugin-paste-link"; import { TypographyPluginProps } from "@portabletext/plugin-typography"; import { Node } from "@sanity/comlink"; interface CreateSanityMediaLibrarySourceProps { i18nKey?: string; icon?: React.ComponentType; libraryId: string | null; name?: string; } /** * Create a new image asset source for the Media Library * * @beta */ declare function createSanityMediaLibraryImageSource(props: CreateSanityMediaLibrarySourceProps): AssetSource; /** * Create a new file asset source for the Media Library * * @beta */ declare function createSanityMediaLibraryFileSource(props: CreateSanityMediaLibrarySourceProps): AssetSource; interface SharedProps$1 { children?: ReactNode; header: string; width: ResponsiveWidthProps['width']; } interface DialogProps$2 extends SharedProps$1 { type: 'dialog'; id?: string; autofocus?: boolean; onClose?: () => void; } interface PopoverProps$3 extends SharedProps$1 { type: 'popover'; legacy_referenceElement: HTMLElement | null; onClose: () => void; } /** * @beta * Creates a dialog or a popover for editing content. * Handles presence and virtual scrolling. */ declare function EditPortal(props: PopoverProps$3 | DialogProps$2): React.JSX.Element; interface SharedProps { children?: ReactNode; header: string; width: ResponsiveWidthProps['width']; } interface DialogProps$1 extends SharedProps { type: 'dialog'; id?: string; autofocus?: boolean; onClose?: () => void; } interface PopoverProps$2 extends SharedProps { type: 'popover'; id?: string; legacy_referenceElement: HTMLElement | null; onClose: () => void; } /** * @beta * Creates a dialog or a popover for editing content. * Handles presence and virtual scrolling. * * When multiple dialogs are open, only the top-most dialog is visible. * Non-top dialogs are hidden via CSS while preserving their state. */ declare function EnhancedObjectDialog(props: PopoverProps$2 | DialogProps$1): React.JSX.Element; /** * Returns whether the given version name (e.g. from `getVersionFromId`) is an * agent bundle name (starts with `agent-`). * * @internal */ declare function isAgentBundleName(versionName: unknown): boolean; /** * Display overrides for an agent bundle version chip. * * @internal */ type AgentVersionDisplay = { displayName: string; tone: BadgeTone; }; /** * Filters a list of version document IDs and provides display metadata for * agent bundles. * * - Other users' `agent-*` versions are removed from the returned list. * - The current user's `agent-*` versions are kept and can be resolved to * display overrides via `getVersionDisplay`. * - Non-agent versions pass through unchanged. * - While the SSE connection is loading, only the currently active agent * bundle (if any) is kept; all others are hidden until ownership is confirmed. * * Call this hook once and thread the results down — don't call it per-item. * * @internal */ declare function useAgentVersionDisplay(versionIds: string[], activeBundleId?: string): { /** Version IDs with other users' agent bundles removed. */filteredVersionIds: string[]; /** * Returns display overrides for a version document ID if it's the current * user's agent bundle, or `null` for all other versions. */ getVersionDisplay: (versionDocumentId: string) => AgentVersionDisplay | null; }; /** * Login methods that may be used for Studio authentication. * * @public */ type LoginMethod = 'dual' | 'cookie' | 'token'; /** * Login methods that acknowledge cookieless authentication tokens. * * @internal * @hidden */ type CookielessCompatibleLoginMethod = Extract; /** * Authentication options * * @public */ interface AuthConfig { /** * Login method to use for the studio. Can be one of: * - `dual` (default) - attempt to use cookies where possible, falling back to * storing authentication token in `localStorage` otherwise * - `cookie` - explicitly disable `localStorage` method, relying only on cookies. May fail due * to cookies being treated as third-party cookies in some browsers, thus the default is `dual`. * - `token` - explicitly disable cookies, relying only on `localStorage` method */ loginMethod?: LoginMethod; /** * Whether to append the providers specified in `providers` with the default providers from the * API, or replace the default providers with the ones specified. * * @deprecated Use the function form of `providers` instead for more control */ mode?: 'append' | 'replace'; /** * If true, the "Choose login provider" (eg "Google, "GitHub", "E-mail/password") screen * will be skipped if only a single provider is configured in the `providers` array - * instead it will redirect unauthenticated users straight to the authentication URL. */ redirectOnSingle?: boolean; /** * Array of authentication providers to use, or a function that takes an array of default * authentication providers (fetched from the Sanity API) and should return a new list of * providers. This can be used to selectively replace, add or remove providers from the * list of choices. * * @remarks If a static array of providers is provided, the `mode` property is taken into account * when determining what to do with it - `append` will append the providers to the default set * of providers, while `replace` will replace the default providers with the ones specified. * * If not set, the default providers will be used. */ providers?: AuthProvider[] | ((prev: AuthProvider[]) => AuthProvider[] | Promise); /** * The API hostname for requests. Should usually be left undefined, * but can be set if using custom cname for API domain. */ apiHost?: string; } /** * A provider of authentication. * * By default, a list of providers for a project will be fetched from the * {@link https://api.sanity.io/v1/auth/providers | Sanity API}, but you may choose to limit this * list by explicitly defining the providers you want to allow, or add additional custom providers * that conforms to the authentication provider specification outlined in * {@link https://www.sanity.io/docs/third-party-login | the documentation}. * * @public */ interface AuthProvider { /** * URL-friendly identifier/name for the provider, eg `github` */ name: string; /** * Human friendly title for the provider, eg `GitHub` */ title: string; /** * URL for the authentication endpoint that will trigger the authentication flow */ url: string; /** * URL for a logo to display next to the provider in the login screen */ logo?: string; } type AuthProbeResult = { authenticated: false; } | { authenticated: true; id: string; }; /** * The interface used by the Studio that produces a `SanityClient` and * `CurrentUser` that gets passed to the resulting `Workspace`s and `Source`s. * * NOTE: This interface is primarily for internal use. Refer to * `createAuthStore` instead. * * @beta * @hidden */ interface AuthStore { /** * Emits `AuthState`s. This should update when the user's auth state changes. * E.g. After a login, a new `AuthState` could be emitted with a non-null * `currentUser` and `authenticated: true` * * NOTE: all auth store implementations should emit on subscribe using * something like shareReplay(1) to ensure all new subscribers get an * `AuthState` value on subscribe */ state: Observable; /** * Emits auth tokens, or `null` if not configured to use them or they do not exist */ token?: Observable; /** * Custom auth stores are expected to implement a UI that initiates the user's * authentication. For the typical case in `createAuthStore`, this means * loading the providers and showing them as options to the user. */ LoginComponent?: ComponentType; /** * Custom auth stores can implement a function that runs when the user logs * out. The implementation is expected to remove all credentials both locally * and on the server. */ logout?: () => Promise; /** * Custom auth stores can implement a function that is designated to run when * the Studio loads (e.g. to trade a session ID for a token in cookie-less * mode). Within the Studio, this is called within the `AuthBoundary`. */ handleCallbackUrl?: () => Promise; } /** * The unit an `AuthStore` emits to determine the user's authentication state. * * @beta * @hidden */ interface AuthState { /** * Similar to a logged-in flag. This state is used in places like the * `AuthBoundary` to determine whether or not it should render the * `NotAuthenticatedComponent`. Implementers may choose to set this to `true` * while also also emitting a `currentUser` of `null` if a `null` user is * accepted (e.g. a project that doesn't require a login) */ authenticated: boolean; /** * The value of the user logged in or `null` if none is provided */ currentUser: CurrentUser | null; /** * A client that is expected to be pre-configured to allow for any downstream * requests in the Studio */ client: SanityClient; } /** * @beta * @hidden */ type LoginComponentProps = { projectId: string; /** @deprecated use redirectPath instead */ basePath: string; redirectPath?: string; } | { projectId: string; redirectPath: string; /** @deprecated use redirectPath instead */ basePath?: string; }; /** * Result returned from `handleCallbackUrl` describing what happened during * the auth callback flow. Used for telemetry, diagnostics, and error handling * in the AuthBoundary. * * @internal */ interface HandleCallbackResult { /** The login method configured for this auth store (e.g. `'cookie'` or `'token'`). */ loginMethod: LoginMethod; /** * Which auth flow was taken: * - `'already-authenticated'`: No sid in hash - user was already authenticated or not. * - `'exchange'`: sid was present, went through /auth/exchange + probe flow. */ flow: 'already-authenticated' | 'exchange'; /** Whether the auth flow completed successfully. */ success: boolean; /** Total wall-clock time for the callback handling, in milliseconds. */ durationMs: number; /** Time spent on the /auth/exchange call specifically. Only set for `'exchange'` flow. */ exchangeDurationMs?: number; /** Time spent on the /users/me probe calls. Only set for `'exchange'` flow. */ probeDurationMs?: number; /** Which auth method was selected by the probes. Only set when `success` is `true` and flow is `'exchange'`. */ authMethod?: 'cookie' | 'token'; /** Human-readable reason for failure. Only set when `success` is `false`. */ failureReason?: string; /** * Structured error for the AuthBoundary to render appropriate UI. * Only set when `success` is `false` and flow is `'exchange'`. * * - `'cookie-blocked'`: cookie-only mode and the cookie probe failed. * The browser likely has strict cookie policies. * - `'auth-failed'`: all probe methods failed. The user should retry. */ error?: { type: 'cookie-blocked' | 'auth-failed'; message: string; }; } /** @internal */ interface AuthStoreOptions extends AuthConfig { clientFactory?: (options: ClientConfig) => SanityClient; projectId: string; dataset: string; /** * Retrieves the session ID from the URL hash for the auth callback flow. * Called by `handleCallbackUrl` to obtain the session ID that is exchanged * for a token or cookie. * @internal */ getSessionId: () => string | undefined; /** * Extracts and consumes a `#token=…` fragment from the URL hash. * Called at init to pick up hash tokens and on `hashchange` events. * @internal */ consumeHashToken: () => string | undefined; } /** * @internal */ declare function _createAuthStore({ clientFactory: clientFactoryOption, projectId, dataset, apiHost, loginMethod, getSessionId, consumeHashToken, ...providerOptions }: AuthStoreOptions): AuthStore; /** * Public options for `createAuthStore`. The `getSessionId` and `consumeHashToken` * dependencies are wired automatically using the default implementations. * @internal */ type CreateAuthStoreOptions = Omit; /** * @internal */ declare const createAuthStore: (options: CreateAuthStoreOptions) => AuthStore; /** @internal */ interface MockAuthStoreOptions { currentUser: CurrentUser | null; client: SanityClient; } /** * Creates a mock `AuthStore` (for testing) that emits an `AuthState` derived * from the `client` and `currentUser` given. * * @internal */ declare function createMockAuthStore({ client, currentUser }: MockAuthStoreOptions): AuthStore; /** @internal */ declare function getProviderTitle(provider?: string): string | undefined; /** * Duck-type check for whether or not this looks like an auth store * * @param maybeStore - Item to check if matches the AuthStore interface * @returns True if auth store, false otherwise * @internal */ declare function isAuthStore(maybeStore: unknown): maybeStore is AuthStore; /** * Check whether the provided login method is compatible with cookieless auth, e.g. whether any * authentication token found in localStorage should be acknowledged. * * @internal */ declare function isCookielessCompatibleLoginMethod(loginMethod: LoginMethod): loginMethod is CookielessCompatibleLoginMethod; /** @internal */ interface ConnectionStatusStore { connectionStatus$: Observable; } /** @internal */ type ConnectingStatus = { type: 'connecting'; }; /** @internal */ type ErrorStatus = { type: 'error'; error: Error; attemptNo: number; isOffline: boolean; retryAt: Date; }; /** @internal */ type RetryingStatus = { type: 'retrying'; }; /** @internal */ type ConnectedStatus = { type: 'connected'; lastHeartbeat: Date; }; /** @internal */ declare const CONNECTING: ConnectingStatus; /** @internal */ type ConnectionStatus = ConnectingStatus | ErrorStatus | ConnectedStatus | RetryingStatus; /** @internal */ declare const onRetry: () => void; /** @internal */ interface ConnectionStatusStoreOptions { bifur: BifurClient; } /** * This is the beginning of what should be the data store tracking connection status in the Sanity studio. * * @internal */ declare function createConnectionStatusStore({ bifur }: ConnectionStatusStoreOptions): ConnectionStatusStore; /** @internal */ interface CorsOriginErrorOptions { projectId?: string; isStaging: boolean; } /** @internal */ declare class CorsOriginError extends Error { projectId?: string; isStaging: boolean; constructor({ projectId, isStaging }: CorsOriginErrorOptions); } /** @internal */ type BetaBadgeProps = Omit; /** @internal */ declare function BetaBadge(props: BetaBadgeProps & Omit, 'ref'>): _$react.JSX.Element; /** @internal */ type CommandListElementType = 'input' | 'list'; /** @internal */ type CommandListGetItemDisabledCallback = (virtualIndex: number) => boolean; /** @internal */ type CommandListGetItemKeyCallback = (virtualIndex: number) => number | string; /** @internal */ type CommandListGetItemSelectedCallback = (virtualIndex: number) => boolean; /** @internal */ type CommandListItemContext = { activeIndex: number | null; disabled?: boolean; selected?: boolean; virtualIndex: number; }; /** @internal */ type CommandListRenderItemCallback = (item: T, context: CommandListItemContext) => ReactNode; /** @internal */ interface CommandListHandle { focusInputElement: () => void; focusListElement: () => void; getTopIndex: () => number; scrollToIndex: (index: number) => void; } /** @internal */ interface CommandListProps extends ResponsivePaddingProps { /** The data attribute to apply to any active virtual list items */ activeItemDataAttr?: string; /** `aria-label` to apply to the virtual list container element */ ariaLabel: string; /** Whether `aria-multiselectable` is enabled on the virtual list container element */ ariaMultiselectable?: boolean; /** Automatically focus the input or virtual list */ autoFocus?: CommandListElementType; /** Whether the virtual list can receive focus */ canReceiveFocus?: boolean; /** Pixel offset of the virtual list focus ring. Negative values will cause the focus ring to appear inset */ focusRingOffset?: number; /** Force a fixed height for all virtual list children and skip measurement (faster). */ fixedHeight?: boolean; /** Custom function to map disabled items */ getItemDisabled?: CommandListGetItemDisabledCallback; /** Custom function to map virtual list items to custom keys */ getItemKey?: CommandListGetItemKeyCallback; /** Custom function to map selected items */ getItemSelected?: CommandListGetItemSelectedCallback; /** Scroll alignment of the initial active index */ initialScrollAlign?: ScrollToOptions['align']; /** Initial active index on mount */ initialIndex?: number; /** Input element to associate with this virtual list. Associated inputs will receive focus and handle key events */ inputElement?: HTMLInputElement | null; /** Estimated height for each list item */ itemHeight: number; /** Virtual list item values, accessible to all rendered item components */ items: T[]; /** Callback fired when the virtual list is within `onEndReachedIndexThreshold` of rendered content */ onEndReached?: () => void; /** Number of items from the end of the virtual list before which `onEndReached` is triggered */ onEndReachedIndexOffset?: number; /** Only show selection state when the virtual list is active (is hovered or has focus) */ onlyShowSelectionWhenActive?: boolean; /** Number of items to render above and below the visible area*/ overscan?: number; /** Rendered component in virtual lists */ renderItem: CommandListRenderItemCallback; /** `data-testid` to apply to outermost container */ testId?: string; /** Allow wraparound keyboard navigation between first and last items */ wrapAround?: boolean; } /** * Renders a Command List with support for the following: * * - Keyboard navigation (↑ / ↓ / ENTER) to children with a specified container (`childContainerRef`) * - Focus redirection when clicking child elements * - Pointer blocking when navigating with arrow keys (to ensure that only one active state is visible at any given time) * - ARIA attributes to define a `combobox` input that controls a separate `listbox` * * @internal */ declare const CommandList: _$react.NamedExoticComponent & _$react.RefAttributes>; type BaseButtonProps = Pick & { size?: 'default' | 'large'; radius?: 'full'; }; type ButtonWithText = { text: string; tooltipProps?: TooltipProps$1 | null; icon?: ButtonProps['icon']; }; type IconButton = { text?: undefined; icon?: ButtonProps['icon']; /** * When using a button with an icon, tooltipProps are required to enforce consistency in UI. */ tooltipProps: TooltipProps$1 | null; }; /** @internal */ type ButtonProps$1 = BaseButtonProps & (ButtonWithText | IconButton); /** * Customized Sanity UI