@actview/floating-ui 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Floating UI contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_deprecated-inner.d.ts

@@ -0,0 +1,82 @@
+import { type Derivable, type DetectOverflowOptions, type SideObject } from '@floating-ui/dom';
+import { type Ref } from '@actview/core';
+import type { ElementProps, FloatingRootContext, Middleware } from './types';
+export interface InnerProps extends DetectOverflowOptions {
+    /**
+     * A ref which contains an array of HTML elements.
+     * @default empty list
+     */
+    listRef: Ref<Array<HTMLElement | null>>;
+    /**
+     * The index of the active (focused or highlighted) item in the list.
+     * @default 0
+     */
+    index: number;
+    /**
+     * Callback invoked when the fallback state changes.
+     */
+    onFallbackChange?: null | ((fallback: boolean) => void) | undefined;
+    /**
+     * The offset to apply to the floating element.
+     * @default 0
+     */
+    offset?: number | undefined;
+    /**
+     * A ref which contains the overflow of the floating element.
+     */
+    overflowRef?: Ref<SideObject | null> | undefined;
+    /**
+     * An optional ref containing an HTMLElement. This may be used as the
+     * scrolling container instead of the floating element — for instance,
+     * to position inner elements as direct children without being interfered by
+     * scrolling layout.
+     */
+    scrollRef?: Ref<HTMLElement | null> | undefined;
+    /**
+     * The minimum number of items that should be visible in the list.
+     * @default 4
+     */
+    minItemsVisible?: number | undefined;
+    /**
+     * The threshold for the reference element's overflow in pixels.
+     * @default 0
+     */
+    referenceOverflowThreshold?: number | undefined;
+}
+/**
+ * Positions the floating element such that an inner element inside of it is
+ * anchored to the reference element.
+ * @see https://floating-ui.com/docs/inner
+ * @deprecated
+ */
+export declare const inner: (props: InnerProps | Derivable<InnerProps>) => Middleware;
+export interface UseInnerOffsetProps {
+    /**
+     * Whether the Hook is enabled, including all internal Effects and event
+     * handlers.
+     * @default true
+     */
+    enabled?: boolean | undefined;
+    /**
+     * A ref which contains the overflow of the floating element.
+     */
+    overflowRef: Ref<SideObject | null>;
+    /**
+     * An optional ref containing an HTMLElement. This may be used as the
+     * scrolling container instead of the floating element — for instance,
+     * to position inner elements as direct children without being interfered by
+     * scrolling layout.
+     */
+    scrollRef?: Ref<HTMLElement | null> | undefined;
+    /**
+     * Callback invoked when the offset changes.
+     */
+    onChange: (offset: number | ((offset: number) => number)) => void;
+}
+/**
+ * Changes the `inner` middleware's `offset` upon a `wheel` event to
+ * expand the floating element's height, revealing more list items.
+ * @see https://floating-ui.com/docs/inner
+ * @deprecated
+ */
+export declare function useInnerOffset(context: FloatingRootContext, props: UseInnerOffsetProps): ElementProps;

package/dist/components/Composite.d.ts

@@ -0,0 +1,109 @@
+import { type Ref } from '@actview/core';
+import type { Dimensions } from '../types';
+/**
+ * actview 版（upstream 为 React 组件）。
+ *
+ * 与 upstream 的差异：
+ * - `React.forwardRef` → `defineComponent`（`ref` 作为 prop 透传）
+ * - `React.useState` → `ref()`；`activeIndex` 为 `computed`
+ *   （`props.activeIndex` 响应式读取，未受控时用内部 ref）
+ * - `onNavigate` 为普通函数（闭包读 `props.onNavigate`）
+ * - `render` prop 的元素形态用 VNode props 合并实现 `cloneElement` 语义
+ *   （actview VNode 的 `ref` 为独立字段，需单独合并）
+ * - `useEffectEvent` 不再需要（props 响应式读取即最新）
+ * - 无 React 合成事件：`event: KeyboardEvent`；`elementsRef.value`（.value）
+ */
+type BivariantCallback<T extends (...args: any[]) => any> = {
+    bivariance(...args: Parameters<T>): ReturnType<T>;
+}['bivariance'];
+type RenderProp = any | ((props: Record<string, unknown>) => any);
+export interface CompositeProps {
+    /**
+     * Determines the element to render.
+     * @example
+     * ```jsx
+     * <Composite render={<ul />} />
+     * <Composite render={(htmlProps) => <ul {...htmlProps} />} />
+     * ```
+     */
+    render?: RenderProp | undefined;
+    /**
+     * Determines the orientation of the composite.
+     */
+    orientation?: 'horizontal' | 'vertical' | 'both' | undefined;
+    /**
+     * Determines whether focus should loop around when navigating past the first
+     * or last item.
+     */
+    loop?: boolean | undefined;
+    /**
+     * Whether the direction of the composite’s navigation is in RTL layout.
+     */
+    rtl?: boolean | undefined;
+    /**
+     * Determines the number of columns there are in the composite
+     * (i.e. it’s a grid).
+     */
+    cols?: number | undefined;
+    /**
+     * Determines which items are disabled. The `disabled` or `aria-disabled`
+     * attributes are used by default.
+     */
+    disabledIndices?: number[] | ((index: number) => boolean) | undefined;
+    /**
+     * Determines which item is active. Used to externally control the active
+     * item.
+     */
+    activeIndex?: number | undefined;
+    /**
+     * Called when the user navigates to a new item. Used to externally control
+     * the active item.
+     */
+    onNavigate?: BivariantCallback<(index: number) => void> | undefined;
+    /**
+     * Only for `cols > 1`, specify sizes for grid items.
+     * `{ width: 2, height: 2 }` means an item is 2 columns wide and 2 rows tall.
+     */
+    itemSizes?: Dimensions[] | undefined;
+    /**
+     * Only relevant for `cols > 1` and items with different sizes, specify if
+     * the grid is dense (as defined in the CSS spec for grid-auto-flow).
+     */
+    dense?: boolean | undefined;
+    ref?: Ref<HTMLElement | null> | ((el: HTMLElement | null) => void) | undefined;
+    [key: string]: unknown;
+}
+/**
+ * Creates a single tab stop whose items are navigated by arrow keys, which
+ * provides list navigation outside of floating element contexts.
+ *
+ * This is useful to enable navigation of a list of items that aren’t part of a
+ * floating element. A menubar is an example of a composite, with each reference
+ * element being an item.
+ * @see https://floating-ui.com/docs/Composite
+ */
+export declare const Composite: {
+    __setup: (props: CompositeProps) => () => JSX.Element;
+    name?: string;
+} & ((props: CompositeProps) => () => JSX.Element);
+export interface CompositeItemProps {
+    /**
+     * Determines the element to render.
+     * @example
+     * ```jsx
+     * <CompositeItem render={<li />} />
+     * <CompositeItem render={(htmlProps) => <li {...htmlProps} />} />
+     * ```
+     */
+    render?: RenderProp | undefined;
+    ref?: Ref<HTMLElement | null> | ((el: HTMLElement | null) => void) | undefined;
+    [key: string]: unknown;
+}
+/**
+ * @see https://floating-ui.com/docs/Composite
+ */
+export declare const CompositeItem: {
+    __setup: (props: CompositeItemProps) => () => any;
+    name?: string;
+} & ((props: CompositeItemProps) => () => any);
+export {};

package/dist/components/FloatingArrow.d.ts

@@ -0,0 +1,66 @@
+import { type Ref } from '@actview/core';
+import type { FloatingContext } from '../types';
+/**
+ * actview 版（upstream 为 React 组件）。
+ *
+ * 与 upstream 的差异：
+ * - `React.forwardRef` → `defineComponent`（`ref` 作为 prop 透传给 svg）
+ * - `React.useState` → `ref()`；`useModernLayoutEffect` → `watch`
+ * - context 字段为 `Ref`：`placement.value` / `elements.floating.value` /
+ *   `middlewareData.value.{arrow,shift}`
+ * - `useId` 返回 `Ref<string | undefined>`（clipPathId.value）
+ * - `style` 在渲染闭包内解构（props 响应式）
+ */
+export interface FloatingArrowProps {
+    /**
+     * The floating context.
+     */
+    context: Omit<FloatingContext, 'refs'> & {
+        refs: any;
+    };
+    /**
+     * Width of the arrow.
+     * @default 14
+     */
+    width?: number | undefined;
+    /**
+     * Height of the arrow.
+     * @default 7
+     */
+    height?: number | undefined;
+    /**
+     * The corner radius (rounding) of the arrow tip.
+     * @default 0 (sharp)
+     */
+    tipRadius?: number | undefined;
+    /**
+     * Forces a static offset over dynamic positioning under a certain condition.
+     * If the shift() middleware causes the popover to shift, this value will be
+     * ignored.
+     */
+    staticOffset?: string | number | null | undefined;
+    /**
+     * Custom path string.
+     */
+    d?: string | undefined;
+    /**
+     * Stroke (border) color of the arrow.
+     */
+    stroke?: string | undefined;
+    /**
+     * Stroke (border) width of the arrow.
+     */
+    strokeWidth?: number | undefined;
+    ref?: Ref<SVGSVGElement | null> | ((el: SVGSVGElement | null) => void) | undefined;
+    style?: Record<string, unknown> | undefined;
+    fill?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Renders a pointing arrow triangle.
+ * @see https://floating-ui.com/docs/FloatingArrow
+ */
+export declare const FloatingArrow: {
+    __setup: (props: FloatingArrowProps) => () => JSX.Element | null;
+    name?: string;
+} & ((props: FloatingArrowProps) => () => JSX.Element | null);

package/dist/components/FloatingDelayGroup.d.ts

@@ -0,0 +1,70 @@
+import { type Ref } from '@actview/core';
+import type { FloatingRootContext } from '../types';
+/**
+ * actview 版（upstream 为 React 组件）。
+ *
+ * 与 upstream 的差异：
+ * - `React.createContext` → actview 官方 `createContext`（`.use()` 返回 `Ref<T>`）
+ * - `React.useReducer` → `ref()` + `setState`（Partial merge，.value 替换触发渲染）
+ * - `useModernLayoutEffect` → `watch`；effect cleanup → `onWatcherCleanup`
+ * - `useDelayGroupContext` / `useDelayGroup` 返回 `Ref`（渲染期读 .value）；
+ *   `id` 为 `computed`（floatingId 挂载后才有值）
+ */
+type Delay = number | Partial<{
+    open: number | undefined;
+    close: number | undefined;
+}>;
+interface GroupState {
+    delay: Delay;
+    initialDelay: Delay;
+    currentId: any;
+    timeoutMs: number;
+    isInstantPhase: boolean;
+}
+interface GroupContext extends GroupState {
+    setCurrentId: (currentId: any) => void;
+    setState: (next: Partial<GroupState>) => void;
+}
+/**
+ * @deprecated
+ * Use the return value of `useDelayGroup()` instead.
+ */
+export declare const useDelayGroupContext: () => Ref<GroupContext>;
+export interface FloatingDelayGroupProps {
+    children?: any;
+    /**
+     * The delay to use for the group.
+     */
+    delay: Delay;
+    /**
+     * An optional explicit timeout to use for the group, which represents when
+     * grouping logic will no longer be active after the close delay completes.
+     * This is useful if you want grouping to “last” longer than the close delay,
+     * for example if there is no close delay at all.
+     */
+    timeoutMs?: number | undefined;
+}
+/**
+ * Provides context for a group of floating elements that should share a
+ * `delay`.
+ * @see https://floating-ui.com/docs/FloatingDelayGroup
+ */
+export declare const FloatingDelayGroup: {
+    __setup: (props: FloatingDelayGroupProps) => () => JSX.Element;
+    name?: string;
+} & ((props: FloatingDelayGroupProps) => () => JSX.Element);
+interface UseGroupOptions {
+    /**
+     * Whether delay grouping should be enabled.
+     * @default true
+     */
+    enabled?: boolean | undefined;
+    id?: any;
+}
+/**
+ * Enables grouping when called inside a component that's a child of a
+ * `FloatingDelayGroup`.
+ * @see https://floating-ui.com/docs/FloatingDelayGroup
+ */
+export declare function useDelayGroup(context: FloatingRootContext, options?: UseGroupOptions): Ref<GroupContext>;
+export {};

package/dist/components/FloatingFocusManager.d.ts

@@ -0,0 +1,92 @@
+import { type Ref } from '@actview/core';
+import type { FloatingRootContext } from '../types';
+export interface FloatingFocusManagerProps {
+    children: any;
+    /**
+     * The floating context returned from `useFloatingRootContext`.
+     */
+    context: FloatingRootContext;
+    /**
+     * Whether or not the focus manager should be disabled. Useful to delay focus
+     * management until after a transition completes or some other conditional
+     * state.
+     * @default false
+     */
+    disabled?: boolean | Ref<boolean> | undefined;
+    /**
+     * The order in which focus cycles.
+     * @default ['content']
+     */
+    order?: Array<'reference' | 'floating' | 'content'> | undefined;
+    /**
+     * Which element to initially focus. Can be either a number (tabbable index as
+     * specified by the `order`) or a ref.
+     * @default 0
+     */
+    initialFocus?: number | boolean | Ref<HTMLElement | null> | undefined;
+    /**
+     * Determines if the focus guards are rendered. If not, focus can escape into
+     * the address bar/console/browser UI, like in native dialogs.
+     * @default true
+     */
+    guards?: boolean | undefined;
+    /**
+     * Determines if focus should be returned to the reference element once the
+     * floating element closes/unmounts (or if that is not available, the
+     * previously focused element). This prop is ignored if the floating element
+     * lost focus.
+     * It can be also set to a ref to explicitly control the element to return focus to.
+     * @default true
+     */
+    returnFocus?: boolean | Ref<HTMLElement | null> | ((closeType: string) => boolean | HTMLElement | null | void) | undefined;
+    /**
+     * Determines if focus should be restored to the nearest tabbable element if
+     * focus inside the floating element is lost (such as due to the removal of
+     * the currently focused element from the DOM).
+     * @default false
+     */
+    restoreFocus?: boolean | 'popup' | undefined;
+    /**
+     * Determines if focus is “modal”, meaning focus is fully trapped inside the
+     * floating element and outside content cannot be accessed. This includes
+     * screen reader virtual cursors.
+     * @default true
+     */
+    modal?: boolean | undefined;
+    /**
+     * If your focus management is modal and there is no explicit close button
+     * available, you can use this prop to render a visually-hidden dismiss
+     * button at the start and end of the floating element. This allows
+     * touch-based screen readers to escape the floating element due to lack of
+     * an `esc` key.
+     * @default undefined
+     */
+    visuallyHiddenDismiss?: boolean | string | undefined;
+    /**
+     * Determines whether `focusout` event listeners that control whether the
+     * floating element should be closed if the focus moves outside of it are
+     * attached to the reference and floating elements. This affects non-modal
+     * focus management.
+     * @default true
+     */
+    closeOnFocusOut?: boolean | undefined;
+    /**
+     * Determines whether outside elements are `inert` when `modal` is enabled.
+     * This enables pointer modality without a backdrop.
+     * @default false
+     */
+    outsideElementsInert?: boolean | undefined;
+    /**
+     * Returns a list of elements that should be considered part of the
+     * floating element.
+     */
+    getInsideElements?: (() => Element[]) | undefined;
+}
+/**
+ * Provides focus management for the floating element.
+ * @see https://floating-ui.com/docs/FloatingFocusManager
+ */
+export declare const FloatingFocusManager: {
+    __setup: (props: FloatingFocusManagerProps) => () => JSX.Element;
+    name?: string;
+} & ((props: FloatingFocusManagerProps) => () => JSX.Element);

package/dist/components/FloatingList.d.ts

@@ -0,0 +1,43 @@
+import { type Ref } from '@actview/core';
+interface FloatingListContextValue {
+    register: (node: Node) => void;
+    unregister: (node: Node) => void;
+    map: Map<Node, number | null>;
+    elementsRef: Ref<Array<HTMLElement | null>>;
+    labelsRef?: Ref<Array<string | null>> | undefined;
+}
+export declare const FloatingListContext: import("@actview/core").Context<FloatingListContextValue>;
+interface FloatingListProps {
+    children?: any;
+    /**
+     * A ref to the list of HTML elements, ordered by their index.
+     * `useListNavigation`'s `listRef` prop.
+     */
+    elementsRef: Ref<Array<HTMLElement | null>>;
+    /**
+     * A ref to the list of element labels, ordered by their index.
+     * `useTypeahead`'s `listRef` prop.
+     */
+    labelsRef?: Ref<Array<string | null>> | undefined;
+}
+/**
+ * Provides context for a list of items within the floating element.
+ * @see https://floating-ui.com/docs/FloatingList
+ */
+export declare const FloatingList: {
+    __setup: (props: FloatingListProps) => () => JSX.Element;
+    name?: string;
+} & ((props: FloatingListProps) => () => JSX.Element);
+export interface UseListItemProps {
+    label?: string | null | undefined;
+}
+/**
+ * Used to register a list item and its index (DOM position) in the
+ * `FloatingList`.
+ * @see https://floating-ui.com/docs/FloatingList#uselistitem
+ */
+export declare function useListItem(props?: UseListItemProps): {
+    ref: (node: HTMLElement | null) => void;
+    index: Ref<number>;
+};
+export {};

package/dist/components/FloatingOverlay.d.ts

@@ -0,0 +1,18 @@
+export interface FloatingOverlayProps {
+    /**
+     * Whether the overlay should lock scrolling on the document body.
+     * @default false
+     */
+    lockScroll?: boolean | undefined;
+    [key: string]: unknown;
+}
+/**
+ * Provides base styling for a fixed overlay element to dim content or block
+ * pointer events behind a floating element.
+ * It's a regular `<div>`, so it can be styled via any CSS solution you prefer.
+ * @see https://floating-ui.com/docs/FloatingOverlay
+ */
+export declare const FloatingOverlay: {
+    __setup: (props: FloatingOverlayProps) => () => JSX.Element;
+    name?: string;
+} & ((props: FloatingOverlayProps) => () => JSX.Element);

package/dist/components/FloatingPortal.d.ts

@@ -0,0 +1,63 @@
+import { type Ref } from '@actview/core';
+import type { OpenChangeReason } from '../types';
+type FocusManagerState = {
+    modal: boolean;
+    open: boolean;
+    onOpenChange(open: boolean, event?: Event, reason?: OpenChangeReason): void;
+    domReference: Element | null;
+    closeOnFocusOut: boolean;
+} | null;
+type SetFocusManagerState = (value: FocusManagerState | ((prev: FocusManagerState) => FocusManagerState)) => void;
+interface PortalContextValue {
+    preserveTabOrder: boolean;
+    portalNode: HTMLElement | null;
+    setFocusManagerState: SetFocusManagerState;
+    beforeInsideRef: Ref<HTMLSpanElement | null>;
+    afterInsideRef: Ref<HTMLSpanElement | null>;
+    beforeOutsideRef: Ref<HTMLSpanElement | null>;
+    afterOutsideRef: Ref<HTMLSpanElement | null>;
+}
+export interface UseFloatingPortalNodeProps {
+    id?: string | undefined;
+    root?: HTMLElement | ShadowRoot | null | Ref<HTMLElement | ShadowRoot | null> | undefined;
+}
+/**
+ * @see https://floating-ui.com/docs/FloatingPortal#usefloatingportalnode
+ */
+export declare function useFloatingPortalNode(props?: UseFloatingPortalNodeProps): Ref<HTMLElement | null>;
+export interface FloatingPortalProps {
+    children?: any;
+    /**
+     * Optionally selects the node with the id if it exists, or create it and
+     * append it to the specified `root` (by default `document.body`).
+     */
+    id?: string | undefined;
+    /**
+     * Specifies the root node the portal container will be appended to.
+     */
+    root?: HTMLElement | ShadowRoot | null | Ref<HTMLElement | ShadowRoot | null> | undefined;
+    /**
+     * When using non-modal focus management using `FloatingFocusManager`, this
+     * will preserve the tab order context based on the React tree instead of the
+     * DOM tree.
+     */
+    preserveTabOrder?: boolean | undefined;
+    /**
+     * Sets the ARIA role of the portal's aria-owns owner element (base-ui 变体).
+     */
+    portalOwnerRole?: string | undefined;
+}
+/**
+ * Portals the floating element into a given container element — by default,
+ * outside of the app root and into the body.
+ * This is necessary to ensure the floating element can appear outside any
+ * potential parent containers that cause clipping (such as `overflow: hidden`),
+ * while retaining its location in the React tree.
+ * @see https://floating-ui.com/docs/FloatingPortal
+ */
+export declare const FloatingPortal: {
+    __setup: (props: FloatingPortalProps) => () => JSX.Element;
+    name?: string;
+} & ((props: FloatingPortalProps) => () => JSX.Element);
+export declare const usePortalContext: () => Ref<PortalContextValue | null>;
+export {};

package/dist/components/FloatingTree.d.ts

@@ -0,0 +1,45 @@
+import { type Ref } from '@actview/core';
+import type { FloatingTreeType, ReferenceType } from '../types';
+/**
+ * Returns the parent node id for nested floating elements, if available.
+ * Returns `null` for top-level floating elements.
+ */
+export declare const useFloatingParentNodeId: () => string | null;
+/**
+ * Returns the nearest floating tree context, if available.
+ */
+export declare const useFloatingTree: <RT extends ReferenceType = ReferenceType>() => FloatingTreeType<RT> | null;
+/**
+ * Registers a node into the `FloatingTree`, returning its id.
+ * @see https://floating-ui.com/docs/FloatingTree
+ */
+export declare function useFloatingNodeId(customParentId?: string): Ref<string | undefined>;
+export interface FloatingNodeProps {
+    children?: any;
+    id: string | undefined;
+}
+/**
+ * Provides parent node context for nested floating elements.
+ * @see https://floating-ui.com/docs/FloatingTree
+ */
+export declare const FloatingNode: {
+    __setup: (props: FloatingNodeProps) => () => JSX.Element;
+    name?: string;
+} & ((props: FloatingNodeProps) => () => JSX.Element);
+export interface FloatingTreeProps {
+    children?: any;
+}
+/**
+ * Provides context for nested floating elements when they are not children of
+ * each other on the DOM.
+ * This is not necessary in all cases, except when there must be explicit communication between parent and child floating elements. It is necessary for:
+ * - The `bubbles` option in the `useDismiss()` Hook
+ * - Nested virtual list navigation
+ * - Nested floating elements that each open on hover
+ * - Custom communication between parent and child floating elements
+ * @see https://floating-ui.com/docs/FloatingTree
+ */
+export declare const FloatingTree: {
+    __setup: (props: FloatingTreeProps) => () => JSX.Element;
+    name?: string;
+} & ((props: FloatingTreeProps) => () => JSX.Element);

package/dist/components/FocusGuard.d.ts

@@ -0,0 +1,19 @@
+import { type Ref } from '@actview/core';
+/**
+ * actview 版（upstream 为 React 组件）。
+ *
+ * 与 upstream 的差异：
+ * - `React.forwardRef` → `defineComponent`（`ref` 作为 prop 透传给底层 span）
+ * - `React.useState` → `ref()` + `onMounted`（Safari 检测）
+ * - `React.CSSProperties` → `Record<string, string | number>`
+ */
+export declare const HIDDEN_STYLES: Record<string, string | number>;
+export interface FocusGuardProps {
+    children?: any;
+    ref?: Ref<HTMLSpanElement | null> | ((el: HTMLSpanElement | null) => void) | undefined;
+    [key: string]: unknown;
+}
+export declare const FocusGuard: {
+    __setup: (props: FocusGuardProps) => () => JSX.Element;
+    name?: string;
+} & ((props: FocusGuardProps) => () => JSX.Element);