@sanity/ui 3.0.0-static.32 → 3.0.0-static.34

package/dist/portalProvider-DgNIVviV.d.ts

@@ -0,0 +1,575 @@
+import { AlignItems, BoxStyleProps, ButtonStyleProps, CardStyleProps, DisplayStyleProps, FlexDirection, FlexWrap, GapStyleProps, InputStyleProps, JustifyContent, MaxWidth, PaddingStyleProps, RadiusStyleProps, ResponsiveProp, ShadowStyleProps, TextOverflowStyleProps, TextStyleProps, Width } from "@sanity/ui/css";
+import { CardTone, ColorScheme, ContainerWidth, ElementTone, FontTextSize, FontWeight, Space } from "@sanity/ui/theme";
+import { ComponentClass, ComponentProps, ElementType, ExoticComponent, ForwardedRef, FunctionComponent, HTMLAttributes, JSX, ReactElement, ReactNode, ReactPortal, Ref, RefAttributes } from "react";
+/**
+* Assign properties from `U` to `T`, excluding properties that already exist in `T`.
+*
+* @public
+*/
+type Assign<T extends {}, U extends {}> = Omit<T, keyof U> & U;
+/** @public */
+type EmptyProps = {};
+/** @public */
+type TagType = keyof JSX.IntrinsicElements;
+/** @public */
+type ComponentType$1<P = any> = FunctionComponent<P> | ComponentClass<P> | ExoticComponent<P>;
+/** @public */
+type ElementType$1<P> = TagType | ComponentType$1<P>;
+/** @public */
+type Props<P extends EmptyProps, E extends ElementType$1<P>> = Assign<E extends TagType ? JSX.IntrinsicElements[E] : ComponentProps<E>, P & {
+  as?: E;
+}>;
+/**
+* Placement of floating UI elements.
+*
+* @public
+*/
+type Placement = "top" | "top-start" | "top-end" | "right" | "right-start" | "right-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end";
+/** @public */
+type Delay = number | Partial<{
+  open: number;
+  close: number;
+}>;
+/** @public */
+declare const DEFAULT_HOTKEYS_ELEMENT = "kbd";
+/** @public */
+interface HotkeysOwnProps extends GapStyleProps, RadiusStyleProps {
+  fontSize?: ResponsiveProp<FontTextSize>;
+  padding?: ResponsiveProp<Space>;
+  keys?: string[];
+}
+/** @public */
+type HotkeysElementType = "kbd" | ComponentType$1;
+/** @public */
+type HotkeysProps<E extends HotkeysElementType = HotkeysElementType> = Props<HotkeysOwnProps, E>;
+/**
+* Represent hotkeys (a keyboard combination) with semantic `<kbd>` elements.
+*
+* @public
+*/
+declare function Hotkeys<E extends HotkeysElementType = typeof DEFAULT_HOTKEYS_ELEMENT>(props: HotkeysProps<E>): React.JSX.Element | undefined;
+/** @public */
+declare const DEFAULT_MENU_ELEMENT = "div";
+/** @public */
+type MenuOwnProps = PaddingStyleProps & {
+  "gap"?: ResponsiveProp<Space>;
+  "onClickOutside"?: (event: MouseEvent) => void;
+  "onEscape"?: () => void;
+  "onItemClick"?: () => void;
+  "onItemSelect"?: (index: number) => void;
+  "originElement"?: HTMLElement | null;
+  "registerElement"?: (el: HTMLElement) => () => void;
+  "shouldFocus"?: "first" | "last" | null;
+  "aria-labelledby"?: string;
+};
+/** @public */
+type MenuElementType = "div" | "span" | ComponentType$1;
+/** @public */
+type MenuProps<E extends MenuElementType = MenuElementType> = Props<MenuOwnProps, E>;
+/**
+* The `Menu` component is a building block for application menus.
+*
+* @public
+*/
+declare function Menu<E extends MenuElementType = typeof DEFAULT_MENU_ELEMENT>(props: MenuProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_MENU_DIVIDER_ELEMENT = "hr";
+/** @public */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+type MenuDividerOwnProps = {};
+/** @public */
+type MenuDividerElementType = "div" | "hr" | "span" | ComponentType$1;
+/** @public */
+type MenuDividerProps<E extends MenuDividerElementType = MenuDividerElementType> = Props<MenuDividerOwnProps, E>;
+/** @public */
+declare function MenuDivider<E extends MenuDividerElementType = typeof DEFAULT_MENU_DIVIDER_ELEMENT>(props: MenuDividerProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_BOX_ELEMENT = "div";
+/** @public */
+type BoxOwnProps = BoxStyleProps;
+/** @public */
+type BoxElementType = "a" | "article" | "aside" | "blockquote" | "body" | "button" | "details" | "div" | "header" | "fieldset" | "figure" | "figcaption" | "footer" | "form" | "html" | "iframe" | "kbd" | "label" | "legend" | "li" | "main" | "nav" | "ol" | "pre" | "section" | "span" | "summary" | "ul" | ComponentType$1;
+/** @public */
+type BoxProps<E extends BoxElementType = BoxElementType> = Props<BoxOwnProps, E>;
+/**
+* The `Box` component is a basic layout wrapper component which provides utility properties
+* for flex, margins and padding.
+*
+* @public
+*/
+declare function Box<E extends BoxElementType = typeof DEFAULT_BOX_ELEMENT>(props: BoxProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_CARD_ELEMENT = "div";
+/** @public */
+interface CardOwnProps extends BoxOwnProps, CardStyleProps {
+  /**
+  * Do not use in production.
+  * @beta
+  */
+  __unstable_checkered?: boolean;
+  /**
+  * Do not use in production.
+  * @beta
+  */
+  __unstable_focusRing?: boolean;
+  disabled?: boolean;
+  pressed?: boolean;
+  selected?: boolean;
+  target?: string;
+}
+/** @public */
+type CardElementType = BoxElementType;
+/** @public */
+type CardProps<E extends CardElementType = CardElementType> = Props<CardOwnProps, E>;
+/**
+* The `Card` component acts much like a `Box`, but with a background and foreground color.
+* Components within a `Card` inherit its colors.
+*
+* @public
+*/
+declare function Card<E extends CardElementType = typeof DEFAULT_CARD_ELEMENT>(props: CardProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_LAYER_ELEMENT = "div";
+/** @public */
+type LayerOwnProps = CardOwnProps & {
+  /** A callback that fires when the layer becomes the top layer when it was not the top layer before. */
+  onActivate?: (props: {
+    activeElement: HTMLElement | null;
+  }) => void;
+  zOffset?: ResponsiveProp<number>;
+};
+/** @public */
+type LayerElementType = CardElementType;
+/** @public */
+type LayerProps<E extends LayerElementType = LayerElementType> = Props<LayerOwnProps, E>;
+/** @public */
+declare function Layer<E extends LayerElementType = typeof DEFAULT_LAYER_ELEMENT>(props: LayerProps<E>): React.JSX.Element;
+/**
+* @beta
+*/
+type PopoverMargins = [number, number, number, number];
+/** @beta */
+type PopoverUpdateCallback = () => void;
+/** @public */
+type PopoverWidth = Exclude<ContainerWidth, "auto">;
+/** @public */
+declare const DEFAULT_POPOVER_ELEMENT = "div";
+/** @public */
+type PopoverOwnProps = Omit<LayerOwnProps, "maxWidth"> & {
+  /** @beta */
+  __unstable_margins?: PopoverMargins;
+  /**
+  * Whether the popover should animate in and out.
+  *
+  * @beta
+  * @defaultValue false
+  */
+  animate?: boolean;
+  arrow?: boolean;
+  children?: ReactElement<{
+    ref: ForwardedRef<HTMLElement>;
+  }>;
+  /**
+  * When `true`, prevent overflow within the current boundary:
+  * - by flipping on its side axis
+  * - by resizing
+  *
+  * Note that:
+  * - setting `preventOverflow` to `true` also prevents overflow on its side axis
+  * - setting `matchReferenceWidth` to `true` also causes the popover to resize
+  *
+  * @defaultValue false
+  */
+  constrainSize?: boolean;
+  content?: ReactNode;
+  disabled?: boolean;
+  fallbackPlacements?: Placement[];
+  floatingBoundary?: HTMLElement | null;
+  /**
+  * When `true`, set the maximum width to match the reference element, and also prevent overflow within
+  * the current boundary by resizing.
+  *
+  * Note that setting `constrainSize` to `true` also causes the popover to resize
+  *
+  * @defaultValue false
+  */
+  matchReferenceWidth?: boolean;
+  /**
+  * When true, blocks all pointer interaction with elements beneath the popover until closed.
+  *
+  * @beta
+  * @defaultValue false
+  */
+  modal?: boolean;
+  open?: boolean;
+  placement?: Placement;
+  /**
+  * When 'flip' (default), the placement is determined from the initial placement and the
+  * fallback placements in order. Whichever fits in the viewport first.
+  *
+  * When 'autoPlacement', the initial placement and all fallback placements are evaluated
+  * and the placement with the most viewport space available.
+  *
+  * Option is only relevant if either `constrainSize` or `preventOverflow` is `true`
+  */
+  placementStrategy?: "flip" | "autoPlacement";
+  /** Whether or not to render the popover in a portal element. */
+  portal?: boolean | string;
+  preventOverflow?: boolean;
+  referenceBoundary?: HTMLElement | null;
+  /**
+  * When defined, the popover will be positioned relative to this element.
+  * The children of the popover won't be rendered.
+  */
+  referenceElement?: HTMLElement | null;
+  /** @beta */
+  updateRef?: Ref<PopoverUpdateCallback | undefined>;
+  width?: ResponsiveProp<MaxWidth>;
+};
+/** @public */
+type PopoverElementType = "div" | ComponentType$1;
+/** @public */
+type PopoverProps<E extends PopoverElementType = PopoverElementType> = Props<PopoverOwnProps, E>;
+/**
+* The `Popover` component is used to display some content on top of another.
+*
+* @public
+*/
+declare function Popover<E extends PopoverElementType = typeof DEFAULT_POPOVER_ELEMENT>(props: PopoverProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_MENU_GROUP_ELEMENT = "button";
+/** @public */
+type MenuGroupOwnProps = RadiusStyleProps & {
+  disabled?: boolean;
+  fontSize?: ResponsiveProp<FontTextSize>;
+  gap?: ResponsiveProp<Space>;
+  icon?: ElementType | ReactNode;
+  menu?: Omit<MenuProps<typeof DEFAULT_MENU_ELEMENT>, "onClickOutside" | "onEscape" | "onItemClick" | "onKeyDown" | "onMouseEnter" | "registerElement" | "shouldFocus" | "onBlurCapture">;
+  padding?: ResponsiveProp<Space>;
+  popover?: Omit<PopoverProps, "content" | "open">;
+  text?: ReactNode;
+  tone?: ElementTone;
+};
+/** @public */
+type MenuGroupElementType = "button" | ComponentType$1;
+/** @public */
+type MenuGroupProps<E extends MenuGroupElementType = MenuGroupElementType> = Props<MenuGroupOwnProps, E>;
+/** @public */
+declare function MenuGroup<E extends MenuGroupElementType = typeof DEFAULT_MENU_GROUP_ELEMENT>(props: MenuGroupProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_MENU_ITEM_ELEMENT = "button";
+/** @public */
+type MenuItemOwnProps = GapStyleProps & PaddingStyleProps & RadiusStyleProps & {
+  disabled?: boolean;
+  fontSize?: ResponsiveProp<FontTextSize>;
+  hotkeys?: string[];
+  icon?: ElementType | ReactNode;
+  iconRight?: ElementType | ReactNode;
+  pressed?: boolean;
+  selected?: boolean;
+  text?: ReactNode;
+  tone?: ElementTone;
+};
+/** @public */
+type MenuItemElementType = "button" | "a" | ComponentType$1;
+/** @public */
+type MenuItemProps<E extends MenuItemElementType = MenuItemElementType> = Omit<Props<MenuItemOwnProps, E>, "role">;
+/** @public */
+declare function MenuItem<E extends MenuItemElementType = typeof DEFAULT_MENU_ITEM_ELEMENT>(props: MenuItemProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_TAB_ELEMENT = "button";
+/** @public */
+type TabOwnProps = {
+  /**
+  * The `id` of the corresponding `TabPanel` component.
+  */
+  "aria-controls": string;
+  "id": string;
+  "icon"?: ElementType | ReactNode;
+  "focused"?: boolean;
+  "fontSize"?: ResponsiveProp<FontTextSize>;
+  "label"?: ReactNode;
+  "padding"?: ResponsiveProp<Space>;
+  "selected"?: boolean;
+  "tone"?: ElementTone;
+};
+/** @public */
+type TabElementType = "button" | ComponentType$1;
+/** @public */
+type TabProps<E extends TabElementType = TabElementType> = Props<TabOwnProps, E>;
+/** @public */
+declare function Tab<E extends TabElementType = typeof DEFAULT_TAB_ELEMENT>(props: TabProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_FLEX_ELEMENT = "div";
+/** @public */
+type FlexOwnProps = Omit<BoxOwnProps, "align" | "display" | "flexDirection" | "flexWrap"> & {
+  align?: ResponsiveProp<AlignItems>;
+  direction?: ResponsiveProp<FlexDirection>;
+  justify?: ResponsiveProp<JustifyContent>;
+  wrap?: ResponsiveProp<FlexWrap>;
+};
+/** @public */
+type FlexElementType = BoxElementType;
+/** @public */
+type FlexProps<E extends FlexElementType = FlexElementType> = Props<FlexOwnProps, E>;
+/**
+* The `Flex` component is a wrapper component for flexible elements (`Box`, `Card` and `Flex`).
+*
+* @public
+*/
+declare function Flex<E extends FlexElementType = typeof DEFAULT_FLEX_ELEMENT>(props: FlexProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_TAB_LIST_ELEMENT = "div";
+/** @public */
+type TabListChild = ReactElement<Props<TabProps, "button">> | null | undefined | false;
+/** @public */
+type TabListOwnProps = Omit<FlexOwnProps, "as" | "height"> & {
+  children: TabListChild[];
+};
+/** @public */
+type TabListElementType = "div" | "span" | ComponentType$1;
+/** @public */
+type TabListProps<E extends TabListElementType = TabListElementType> = Props<TabListOwnProps, E>;
+/** @public */
+declare function TabList<E extends TabListElementType = typeof DEFAULT_TAB_LIST_ELEMENT>(props: TabListProps<E>): React.JSX.Element;
+/**
+* @internal
+*/
+declare function _isEnterToClickElement(element: HTMLElement): boolean;
+/**
+* @internal
+*/
+declare function isHTMLElement(node: unknown): node is HTMLElement;
+/**
+* @internal
+*/
+declare function isHTMLAnchorElement(element: unknown): element is HTMLAnchorElement;
+/**
+* @internal
+*/
+declare function isHTMLInputElement(element: unknown): element is HTMLInputElement;
+/**
+* @internal
+*/
+declare function isHTMLButtonElement(element: unknown): element is HTMLButtonElement;
+/**
+* @internal
+*/
+declare function isHTMLSelectElement(element: unknown): element is HTMLSelectElement;
+/**
+* @internal
+*/
+declare function isHTMLTextAreaElement(element: unknown): element is HTMLTextAreaElement;
+/**
+* @internal
+*/
+declare function containsOrEqualsElement(element: HTMLElement, node: Node): boolean;
+/**
+* Returns true if a dark color scheme is preferred, false if a light color scheme is preferred or the preference is not known.
+*
+* @param getServerSnapshot - Only called during server-side rendering, and hydration if using hydrateRoot. Since the server environment doesn't have access to the DOM, we can't determine the current value of the media query and we assume `(prefers-color-scheme: light)` since it's the most common scheme (https://dev/reference/react/useSyncExternalStore#adding-support-for-server-rendering)
+*
+* If you persist the detected preference in a cookie or a header then you may implement your own server snapshot to read it.
+* Chrome supports reading the `prefers-color-scheme` media query from a header if the server response: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Sec-CH-Prefers-Color-Scheme
+* @example https://gist.github.com/stipsan/13c0cccf8dfc34f4b44bb1b984baf7df
+*
+* @public
+*/
+declare function usePrefersDark(getServerSnapshot?: () => boolean): boolean;
+/** @public */
+declare const DEFAULT_TEXT_ELEMENT = "div";
+/** @public */
+type TextOwnProps = TextStyleProps & TextOverflowStyleProps;
+/** @public */
+type TextElementType = "div" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "label" | "li" | "p" | "span" | ComponentType$1;
+/** @public */
+type TextProps<E extends TextElementType = TextElementType> = Props<TextOwnProps, E>;
+/**
+* The `Text` component is an agile, themed typographic element.
+*
+* @public
+*/
+declare function Text<E extends TextElementType = typeof DEFAULT_TEXT_ELEMENT>(props: TextProps<E>): React.JSX.Element;
+/** @public */
+type ButtonTextAlign = "left" | "right" | "center";
+/** @public */
+declare const DEFAULT_BUTTON_ELEMENT = "button";
+/** @public */
+type ButtonOwnProps = ButtonStyleProps & DisplayStyleProps & GapStyleProps & PaddingStyleProps & {
+  "align"?: BoxStyleProps["alignItems"];
+  "data-ui"?: string;
+  "disabled"?: boolean;
+  "fontSize"?: ResponsiveProp<FontTextSize>;
+  "icon"?: ElementType | ReactNode;
+  "iconRight"?: ElementType | ReactNode;
+  "justify"?: BoxStyleProps["justifyContent"];
+  /** @beta Do not use in production, as this might change.*/
+  "loading"?: boolean;
+  "selected"?: boolean;
+  "textAlign"?: ButtonTextAlign;
+  "muted"?: boolean;
+  "target"?: string;
+  "text"?: ReactNode;
+  "textOverflow"?: TextOwnProps["textOverflow"];
+  "textWeight"?: TextOwnProps["weight"];
+  "width"?: ResponsiveProp<Width>;
+};
+/** @public */
+type ButtonElementType = "a" | "button" | "label" | ComponentType$1;
+/** @public */
+type ButtonProps<E extends ButtonElementType = ButtonElementType> = Props<ButtonOwnProps, E>;
+/** @public */
+declare function Button<E extends ButtonElementType = typeof DEFAULT_BUTTON_ELEMENT>(props: ButtonProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_GRID_ELEMENT = "div";
+/** @public */
+type GridOwnProps = Omit<BoxOwnProps, "display">;
+/** @public */
+type GridElementType = BoxElementType;
+/** @public */
+type GridProps<E extends GridElementType = GridElementType> = Props<GridOwnProps, E>;
+/**
+* The `Grid` component is for building 2-dimensional layers (based on CSS grid).
+*
+* @public
+*/
+declare function Grid<E extends GridElementType = typeof DEFAULT_GRID_ELEMENT>(props: GridProps<E>): React.JSX.Element;
+/** @public */
+interface LayerProviderProps {
+  children?: ReactNode;
+  zOffset?: ResponsiveProp<number>;
+}
+/** @public */
+declare function LayerProvider(props: LayerProviderProps): React.JSX.Element;
+/** @public */
+declare const DEFAULT_SPINNER_ELEMENT = "div";
+/** @public */
+type SpinnerOwnProps = {
+  muted?: boolean;
+  size?: ResponsiveProp<FontTextSize>;
+};
+/** @public */
+type SpinnerElementType = "div" | "span" | ComponentType$1;
+/** @public */
+type SpinnerProps<E extends SpinnerElementType = SpinnerElementType> = Props<SpinnerOwnProps, E>;
+/**
+* Indicate that something is loading for an indeterminate amount of time.
+*
+* @public
+*/
+declare function Spinner<E extends SpinnerElementType = typeof DEFAULT_SPINNER_ELEMENT>(props: SpinnerProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_STACK_ELEMENT = "div";
+/** @public */
+type StackOwnProps = Omit<BoxOwnProps, "align" | "alignItems" | "columns" | "gridTemplateColumns" | "direction" | "display" | "flexDirection" | "flexWrap" | "gapX" | "gapY" | "justify" | "justifyContent" | "rows" | "gridTemplateRows">;
+/** @public */
+type StackElementType = BoxElementType;
+/** @public */
+type StackProps<E extends StackElementType = StackElementType> = Props<StackOwnProps, E>;
+/**
+* The `Stack` component is used to place elements on top of each other.
+*
+* @public
+*/
+declare function Stack<E extends StackElementType = typeof DEFAULT_STACK_ELEMENT>(props: StackProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_TEXT_INPUT_ELEMENT = "input";
+/** @public */
+type TextInputClearButtonProps = Omit<ButtonProps<"button">, "as" | "onClick" | "onMouseDown">;
+/** @public */
+type TextInputOwnProps = InputStyleProps & {
+  /**
+  * @beta
+  */
+  __unstable_disableFocusRing?: boolean;
+  /**
+  * @beta
+  */
+  clearButton?: boolean | TextInputClearButtonProps;
+  customValidity?: string;
+  icon?: ElementType | ReactNode;
+  iconRight?: ElementType | ReactNode;
+  /**
+  * @beta
+  */
+  onClear?: () => void;
+  prefix?: ReactNode;
+  suffix?: ReactNode;
+  weight?: FontWeight;
+};
+/** @public */
+type TextInputElementType = "input" | ComponentType$1;
+/** @public */
+type TextInputProps<E extends TextInputElementType = TextInputElementType> = Props<TextInputOwnProps, E>;
+/**
+* Single line text input.
+*
+* @public
+*/
+declare function TextInput<E extends TextInputElementType = typeof DEFAULT_TEXT_INPUT_ELEMENT>(props: TextInputProps<E>): React.JSX.Element;
+/** @public */
+declare const DEFAULT_TOOLTIP_ELEMENT = "div";
+/** @public */
+type TooltipOwnProps = LayerOwnProps & RadiusStyleProps & ShadowStyleProps & {
+  /**
+  * Whether the tooltip should animate in and out.
+  *
+  * @beta
+  * @defaultValue false
+  */
+  animate?: boolean;
+  arrow?: boolean;
+  boundaryElement?: HTMLElement | null;
+  children?: ReactElement<HTMLAttributes<HTMLElement> & RefAttributes<HTMLElement>>;
+  content?: ReactNode;
+  /**
+  * Adds a delay to open or close the tooltip.
+  *
+  * If only a `number` is passed, it will be used for both opening and closing.
+  *
+  * If an object `{open: number; close:number}` is passed, it can be used to set different delays for each action.
+  *
+  * @public
+  * @defaultValue 0
+  */
+  delay?: Delay;
+  disabled?: boolean;
+  fallbackPlacements?: Placement[];
+  placement?: Placement;
+  /** Whether or not to render the tooltip in a portal element. */
+  portal?: boolean | string;
+  scheme?: ColorScheme;
+  tone?: CardTone;
+};
+/** @public */
+type TooltipElementType = "div" | "span" | ComponentType$1;
+/** @public */
+type TooltipProps<E extends TooltipElementType = TooltipElementType> = Props<TooltipOwnProps, E>;
+/**
+* Tooltips display information when hovering, focusing or tapping.
+*
+* @public
+*/
+declare function Tooltip<E extends TooltipElementType = typeof DEFAULT_TOOLTIP_ELEMENT>(props: TooltipProps<E>): React.JSX.Element;
+/** @public */
+interface PortalProps {
+  children: ReactNode;
+  /**
+  * @beta This API might change. DO NOT USE IN PRODUCTION.
+  */
+  __unstable_name?: string;
+}
+/** @public */
+declare function Portal(props: PortalProps): ReactPortal | null;
+/** @public */
+interface PortalProviderProps {
+  children: ReactNode;
+  element?: HTMLElement | null;
+  /**
+  * @beta
+  */
+  __unstable_elements?: Record<string, HTMLElement | null | undefined>;
+}
+/** @public */
+declare function PortalProvider(props: PortalProviderProps): React.JSX.Element;
+export { Assign, Box, BoxElementType, BoxOwnProps, BoxProps, Button, ButtonElementType, ButtonOwnProps, ButtonProps, ButtonTextAlign, Card, CardElementType, CardOwnProps, CardProps, ComponentType$1 as ComponentType, DEFAULT_BOX_ELEMENT, DEFAULT_BUTTON_ELEMENT, DEFAULT_CARD_ELEMENT, DEFAULT_FLEX_ELEMENT, DEFAULT_GRID_ELEMENT, DEFAULT_HOTKEYS_ELEMENT, DEFAULT_LAYER_ELEMENT, DEFAULT_MENU_DIVIDER_ELEMENT, DEFAULT_MENU_ELEMENT, DEFAULT_MENU_GROUP_ELEMENT, DEFAULT_MENU_ITEM_ELEMENT, DEFAULT_POPOVER_ELEMENT, DEFAULT_SPINNER_ELEMENT, DEFAULT_STACK_ELEMENT, DEFAULT_TAB_ELEMENT, DEFAULT_TAB_LIST_ELEMENT, DEFAULT_TEXT_ELEMENT, DEFAULT_TEXT_INPUT_ELEMENT, DEFAULT_TOOLTIP_ELEMENT, Delay, ElementType$1 as ElementType, EmptyProps, Flex, FlexElementType, FlexOwnProps, FlexProps, Grid, GridElementType, GridOwnProps, GridProps, Hotkeys, HotkeysElementType, HotkeysOwnProps, HotkeysProps, Layer, LayerElementType, LayerOwnProps, LayerProps, LayerProvider, LayerProviderProps, Menu, MenuDivider, MenuDividerElementType, MenuDividerOwnProps, MenuDividerProps, MenuElementType, MenuGroup, MenuGroupElementType, MenuGroupOwnProps, MenuGroupProps, MenuItem, MenuItemElementType, MenuItemOwnProps, MenuItemProps, MenuOwnProps, MenuProps, Placement, Popover, PopoverElementType, PopoverMargins, PopoverOwnProps, PopoverProps, PopoverUpdateCallback, PopoverWidth, Portal, PortalProps, PortalProvider, PortalProviderProps, Props, Spinner, SpinnerElementType, SpinnerOwnProps, SpinnerProps, Stack, StackElementType, StackOwnProps, StackProps, Tab, TabElementType, TabList, TabListChild, TabListElementType, TabListOwnProps, TabListProps, TabOwnProps, TabProps, TagType, Text, TextElementType, TextInput, TextInputClearButtonProps, TextInputElementType, TextInputOwnProps, TextInputProps, TextOwnProps, TextProps, Tooltip, TooltipElementType, TooltipOwnProps, TooltipProps, _isEnterToClickElement, containsOrEqualsElement, isHTMLAnchorElement, isHTMLButtonElement, isHTMLElement, isHTMLInputElement, isHTMLSelectElement, isHTMLTextAreaElement, usePrefersDark };