bits-ui 1.0.0-next.90 → 1.0.0-next.92

package/dist/bits/navigation-menu/navigation-menu.svelte.d.ts

@@ -1,135 +1,98 @@
-import { Previous } from "runed";
-import type { ReadableBoxedValues, WritableBoxedValues } from "../../internal/box.svelte.js";
-import type { Direction, Orientation } from "../../shared/index.js";
-import type { BitsKeyboardEvent, BitsMouseEvent, BitsPointerEvent, ElementRef, WithRefProps } from "../../internal/types.js";
-import { noop } from "../../internal/noop.js";
+/**
+ * Based on Radix UI's Navigation Menu
+ * https://www.radix-ui.com/docs/primitives/components/navigation-menu
+ */
+import { type AnyFn, type ReadableBox, type ReadableBoxedValues, type WithRefProps, type WritableBox, type WritableBoxedValues } from "svelte-toolbelt";
+import { Context } from "runed";
+import { type Snippet } from "svelte";
+import { SvelteMap } from "svelte/reactivity";
+import { type Direction, type Orientation } from "../../shared/index.js";
+import type { BitsFocusEvent, BitsKeyboardEvent, BitsMouseEvent, BitsPointerEvent } from "../../internal/types.js";
 import { useRovingFocus } from "../../internal/use-roving-focus.svelte.js";
-type NavigationMenuRootStateProps = WithRefProps & ReadableBoxedValues<{
-    delayDuration: number;
-    skipDelayDuration: number;
-    orientation: Orientation;
-    dir: Direction;
-}> & WritableBoxedValues<{
-    value: string;
-}>;
-declare class NavigationMenuRootState {
-    #private;
-    id: NavigationMenuRootStateProps["id"];
-    rootRef: NavigationMenuRootStateProps["ref"];
-    delayDuration: NavigationMenuRootStateProps["delayDuration"];
-    skipDelayDuration: NavigationMenuRootStateProps["skipDelayDuration"];
-    orientation: NavigationMenuRootStateProps["orientation"];
-    dir: NavigationMenuRootStateProps["dir"];
-    value: NavigationMenuRootStateProps["value"];
-    previousValue: Previous<string>;
-    openTimer: number;
-    closeTimer: number;
-    skipDelayTimer: number;
-    isOpenDelayed: boolean;
-    constructor(props: NavigationMenuRootStateProps);
-    handleClose(): void;
-    onTriggerEnter(itemValue: string): void;
-    onTriggerLeave(): void;
-    onContentEnter(): void;
-    onContentLeave(): void;
-    onItemSelect(itemValue: string): void;
-    onItemDismiss(): void;
-    props: {
-        readonly id: string;
-        readonly "aria-label": "Main";
-        readonly "data-orientation": "horizontal" | "vertical";
-        readonly dir: Direction;
-        readonly "data-navigation-menu-root": "";
-    };
-}
-type NavigationMenuMenuStateProps = ReadableBoxedValues<{
-    rootNavigationId: string;
+type NavigationMenuProviderStateProps = ReadableBoxedValues<{
     dir: Direction;
     orientation: Orientation;
 }> & WritableBoxedValues<{
+    rootNavigationMenuRef: HTMLElement | null;
     value: string;
+    previousValue: string;
 }> & {
-    isRoot: boolean;
+    isRootMenu: boolean;
     onTriggerEnter: (itemValue: string) => void;
     onTriggerLeave?: () => void;
     onContentEnter?: () => void;
     onContentLeave?: () => void;
     onItemSelect: (itemValue: string) => void;
     onItemDismiss: () => void;
-    previousValue: Previous<string>;
 };
-declare class NavigationMenuMenuState {
-    isRoot: NavigationMenuMenuStateProps["isRoot"];
-    rootNavigationId: NavigationMenuMenuStateProps["rootNavigationId"];
-    dir: NavigationMenuMenuStateProps["dir"];
-    orientation: NavigationMenuMenuStateProps["orientation"];
-    value: NavigationMenuMenuStateProps["value"];
-    previousValue: NavigationMenuMenuStateProps["previousValue"];
-    onTriggerEnter: NavigationMenuMenuStateProps["onTriggerEnter"];
-    onTriggerLeave: NavigationMenuMenuStateProps["onTriggerLeave"];
-    onContentEnter: NavigationMenuMenuStateProps["onContentEnter"];
-    onContentLeave: NavigationMenuMenuStateProps["onContentLeave"];
-    onItemSelect: NavigationMenuMenuStateProps["onItemSelect"];
-    onItemDismiss: NavigationMenuMenuStateProps["onItemDismiss"];
-    viewportNode: HTMLElement | null;
-    indicatorTrackNode: HTMLElement | null;
-    viewportContentId: import("svelte-toolbelt").ReadableBox<string | undefined>;
-    root: NavigationMenuRootState;
-    triggerRefs: Set<ElementRef>;
-    constructor(props: NavigationMenuMenuStateProps, root: NavigationMenuRootState);
-    registerTrigger(ref: ElementRef): void;
-    deRegisterTrigger(ref: ElementRef): void;
-    getTriggerNodes(): HTMLElement[];
+declare class NavigationMenuProviderState {
+    readonly opts: NavigationMenuProviderStateProps;
+    indicatorTrackRef: WritableBox<HTMLElement | null>;
+    viewportRef: WritableBox<HTMLElement | null>;
+    viewportContent: SvelteMap<string, NavigationMenuItemState>;
+    onTriggerEnter: NavigationMenuProviderStateProps["onTriggerEnter"];
+    onTriggerLeave: () => void;
+    onContentEnter: () => void;
+    onContentLeave: () => void;
+    onItemSelect: NavigationMenuProviderStateProps["onItemSelect"];
+    onItemDismiss: NavigationMenuProviderStateProps["onItemDismiss"];
+    constructor(opts: NavigationMenuProviderStateProps);
 }
-type NavigationMenuSubStateProps = WithRefProps & ReadableBoxedValues<{
+type NavigationMenuRootStateProps = WithRefProps<WritableBoxedValues<{
+    value: string;
+}> & ReadableBoxedValues<{
+    dir: Direction;
     orientation: Orientation;
-}> & WritableBoxedValues<{
+    delayDuration: number;
+    skipDelayDuration: number;
+}>>;
+declare class NavigationMenuRootState {
+    #private;
+    readonly opts: NavigationMenuRootStateProps;
+    provider: NavigationMenuProviderState;
+    previousValue: WritableBox<string>;
+    isDelaySkipped: WritableBox<boolean>;
+    constructor(opts: NavigationMenuRootStateProps);
+    setValue: (newValue: string) => void;
+    props: {
+        readonly id: string;
+        readonly "data-orientation": "horizontal" | "vertical";
+        readonly dir: Direction;
+        readonly "data-navigation-menu-root": "";
+        readonly "data-navigation-menu": "";
+    };
+}
+type NavigationMenuSubStateProps = WithRefProps<WritableBoxedValues<{
     value: string;
-}>;
+}> & ReadableBoxedValues<{
+    orientation: Orientation;
+}>>;
 declare class NavigationMenuSubState {
-    id: NavigationMenuSubStateProps["id"];
-    isRoot: boolean;
-    rootNavigationId: NavigationMenuMenuStateProps["rootNavigationId"];
-    dir: NavigationMenuMenuStateProps["dir"];
-    orientation: NavigationMenuMenuStateProps["orientation"];
-    value: NavigationMenuMenuStateProps["value"];
-    previousValue: Previous<string>;
-    onTriggerLeave: NavigationMenuMenuStateProps["onTriggerLeave"];
-    onContentEnter: NavigationMenuMenuStateProps["onContentEnter"];
-    onContentLeave: NavigationMenuMenuStateProps["onContentLeave"];
-    viewportNode: HTMLElement | null;
-    indicatorTrackNode: HTMLElement | null;
-    viewportContentId: import("svelte-toolbelt").ReadableBox<string | undefined>;
-    root: NavigationMenuRootState;
-    triggerRefs: Set<ElementRef>;
-    ref: NavigationMenuSubStateProps["ref"];
-    constructor(props: NavigationMenuSubStateProps, root: NavigationMenuRootState);
-    onTriggerEnter(itemValue: string): void;
-    onItemSelect(itemValue: string): void;
-    registerTrigger(ref: ElementRef): void;
-    deRegisterTrigger(ref: ElementRef): void;
-    getTriggerNodes(): HTMLElement[];
+    readonly opts: NavigationMenuSubStateProps;
+    readonly context: NavigationMenuProviderState;
+    previousValue: WritableBox<string>;
+    constructor(opts: NavigationMenuSubStateProps, context: NavigationMenuProviderState);
+    setValue: (newValue: string) => void;
     props: {
         readonly id: string;
         readonly "data-orientation": "horizontal" | "vertical";
         readonly "data-navigation-menu-sub": "";
+        readonly "data-navigation-menu": "";
     };
 }
-type NavigationMenuListStateProps = WithRefProps & WritableBoxedValues<{
-    indicatorTrackRef: HTMLElement | null;
-}>;
+type NavigationMenuListStateProps = WithRefProps;
 declare class NavigationMenuListState {
-    #private;
-    readonly menu: NavigationMenuMenuState | NavigationMenuSubState;
-    indicatorTrackRef: NavigationMenuListStateProps["indicatorTrackRef"];
-    indicatorTrackId: import("svelte-toolbelt").WritableBox<string>;
+    readonly opts: NavigationMenuListStateProps;
+    readonly context: NavigationMenuProviderState;
+    wrapperId: WritableBox<string>;
+    wrapperRef: WritableBox<HTMLElement | null>;
+    listTriggers: HTMLElement[];
     rovingFocusGroup: ReturnType<typeof useRovingFocus>;
-    constructor(props: NavigationMenuListStateProps, menu: NavigationMenuMenuState | NavigationMenuSubState);
-    indicatorTrackProps: {
+    wrapperMounted: boolean;
+    constructor(opts: NavigationMenuListStateProps, context: NavigationMenuProviderState);
+    registerTrigger(trigger: HTMLElement | null): () => void;
+    wrapperProps: {
         readonly id: string;
-        readonly style: {
-            readonly position: "relative";
-        };
     };
     props: {
         readonly id: string;
@@ -140,69 +103,79 @@ declare class NavigationMenuListState {
 type NavigationMenuItemStateProps = WithRefProps<ReadableBoxedValues<{
     value: string;
 }>>;
-declare class NavigationMenuItemState {
+export declare class NavigationMenuItemState {
     #private;
-    id: NavigationMenuItemStateProps["id"];
-    value: NavigationMenuItemStateProps["value"];
+    readonly opts: NavigationMenuItemStateProps;
+    readonly listContext: NavigationMenuListState;
     contentNode: HTMLElement | null;
     triggerNode: HTMLElement | null;
-    focusProxyRef: import("svelte-toolbelt").WritableBox<HTMLElement | null>;
     focusProxyNode: HTMLElement | null;
-    focusProxyId: import("svelte-toolbelt").WritableBox<string>;
-    restoreContentTabOrder: typeof noop;
+    restoreContentTabOrder: AnyFn;
     wasEscapeClose: boolean;
-    menu: NavigationMenuMenuState | NavigationMenuSubState;
-    list: NavigationMenuListState;
-    constructor(props: NavigationMenuItemStateProps, list: NavigationMenuListState, menu: NavigationMenuMenuState | NavigationMenuSubState);
-    handleContentEntry(side?: "start" | "end"): void;
-    handleContentExit(): void;
+    contentId: string | undefined;
+    triggerId: string | undefined;
+    contentChildren: ReadableBox<Snippet | undefined>;
+    contentChild: ReadableBox<Snippet<[{
+        props: Record<string, unknown>;
+    }]> | undefined>;
+    contentProps: ReadableBox<Record<string, unknown>>;
+    constructor(opts: NavigationMenuItemStateProps, listContext: NavigationMenuListState);
     onEntryKeydown: (side?: "start" | "end") => void;
     onFocusProxyEnter: (side?: "start" | "end") => void;
-    onContentFocusOutside: () => void;
     onRootContentClose: () => void;
+    onContentFocusOutside: () => void;
     props: {
         readonly id: string;
         readonly "data-navigation-menu-item": "";
     };
 }
 type NavigationMenuTriggerStateProps = WithRefProps & ReadableBoxedValues<{
-    disabled: boolean;
+    disabled: boolean | null | undefined;
 }>;
 declare class NavigationMenuTriggerState {
-    #private;
-    focusProxyMounted: boolean;
-    menu: NavigationMenuMenuState | NavigationMenuSubState;
-    item: NavigationMenuItemState;
-    disabled: NavigationMenuTriggerStateProps["disabled"];
-    hasPointerMoveOpened: import("svelte-toolbelt").WritableBox<boolean>;
+    readonly opts: NavigationMenuTriggerStateProps;
+    focusProxyId: WritableBox<string>;
+    focusProxyRef: WritableBox<HTMLElement | null>;
+    context: NavigationMenuProviderState;
+    itemContext: NavigationMenuItemState;
+    listContext: NavigationMenuListState;
+    hasPointerMoveOpened: WritableBox<boolean>;
     wasClickClose: boolean;
     open: boolean;
-    constructor(props: NavigationMenuTriggerStateProps, item: NavigationMenuItemState);
-    onpointerenter(_: BitsPointerEvent): void;
-    onpointermove(e: BitsPointerEvent): void;
-    onpointerleave(e: BitsPointerEvent): void;
-    onclick(_: BitsPointerEvent): void;
-    onkeydown(e: BitsKeyboardEvent): void;
+    focusProxyMounted: boolean;
+    constructor(opts: NavigationMenuTriggerStateProps, context: {
+        provider: NavigationMenuProviderState;
+        item: NavigationMenuItemState;
+        list: NavigationMenuListState;
+    });
+    onpointerenter: (_: BitsPointerEvent<HTMLButtonElement>) => void;
+    onpointermove: BitsPointerEventHandler<HTMLElement>;
+    onpointerleave: BitsPointerEventHandler<HTMLElement>;
+    onclick: (_: BitsMouseEvent<HTMLButtonElement>) => void;
+    onkeydown: (e: BitsKeyboardEvent<HTMLButtonElement>) => void;
+    focusProxyOnFocus: (e: BitsFocusEvent) => void;
     props: {
         readonly id: string;
-        readonly disabled: true | undefined;
+        readonly disabled: boolean | null | undefined;
         readonly "data-disabled": "" | undefined;
         readonly "data-state": "open" | "closed";
+        readonly "data-value": string;
         readonly "aria-expanded": "true" | "false";
         readonly "aria-controls": string | undefined;
-        readonly "data-value": string;
-        readonly onpointerenter: (_: BitsPointerEvent) => void;
-        readonly onpointermove: (e: BitsPointerEvent) => void;
-        readonly onpointerleave: (e: BitsPointerEvent) => void;
-        readonly onclick: (_: BitsPointerEvent) => void;
-        readonly onkeydown: (e: BitsKeyboardEvent) => void;
         readonly "data-navigation-menu-trigger": "";
+        readonly onpointermove: BitsPointerEventHandler<HTMLElement>;
+        readonly onpointerleave: BitsPointerEventHandler<HTMLElement>;
+        readonly onpointerenter: (_: BitsPointerEvent<HTMLButtonElement>) => void;
+        readonly onclick: (_: BitsMouseEvent<HTMLButtonElement>) => void;
+        readonly onkeydown: (e: BitsKeyboardEvent<HTMLButtonElement>) => void;
     };
-    visuallyHiddenProps: {
+    focusProxyProps: {
         readonly id: string;
-        readonly "aria-hidden": "true";
-        readonly tabIndex: 0;
-        readonly onfocus: (e: FocusEvent) => void;
+        readonly tabindex: 0;
+        readonly onfocus: (e: BitsFocusEvent) => void;
+    };
+    restructureSpanProps: {
+        readonly "aria-owns": string | undefined;
     };
 }
 type NavigationMenuLinkStateProps = WithRefProps & ReadableBoxedValues<{
@@ -210,105 +183,133 @@ type NavigationMenuLinkStateProps = WithRefProps & ReadableBoxedValues<{
     onSelect: (e: Event) => void;
 }>;
 declare class NavigationMenuLinkState {
-    #private;
-    active: NavigationMenuLinkStateProps["active"];
-    onSelect: NavigationMenuLinkStateProps["onSelect"];
-    content?: NavigationMenuContentState;
-    item: NavigationMenuItemState;
-    constructor(props: NavigationMenuLinkStateProps, item: NavigationMenuItemState, content?: NavigationMenuContentState);
-    onclick(e: BitsMouseEvent): void;
-    onkeydown(e: BitsKeyboardEvent): void;
+    readonly opts: NavigationMenuLinkStateProps;
+    readonly context: {
+        provider: NavigationMenuProviderState;
+        item: NavigationMenuItemState;
+    };
+    isFocused: boolean;
+    constructor(opts: NavigationMenuLinkStateProps, context: {
+        provider: NavigationMenuProviderState;
+        item: NavigationMenuItemState;
+    });
+    onclick: (e: BitsMouseEvent<HTMLAnchorElement>) => void;
+    onkeydown: (e: BitsKeyboardEvent) => void;
+    onfocus: (_: BitsFocusEvent) => void;
+    onblur: (_: BitsFocusEvent) => void;
     props: {
         readonly id: string;
         readonly "data-active": "" | undefined;
         readonly "aria-current": "page" | undefined;
-        readonly "data-list-link": "" | undefined;
-        readonly onclick: (e: BitsMouseEvent) => void;
-        readonly onfocus: (_: FocusEvent) => void;
-        readonly onkeydown: ((e: BitsKeyboardEvent) => void) | undefined;
+        readonly "data-focused": "" | undefined;
+        readonly onclick: (e: BitsMouseEvent<HTMLAnchorElement>) => void;
+        readonly onkeydown: (e: BitsKeyboardEvent) => void;
+        readonly onfocus: (_: BitsFocusEvent) => void;
+        readonly onblur: (_: BitsFocusEvent) => void;
+        readonly "data-navigation-menu-link": "";
     };
 }
 type NavigationMenuIndicatorStateProps = WithRefProps;
 declare class NavigationMenuIndicatorState {
-    id: NavigationMenuIndicatorStateProps["id"];
-    menu: NavigationMenuMenuState | NavigationMenuSubState;
-    activeTrigger: HTMLElement | null;
+    context: NavigationMenuProviderState;
+    isVisible: boolean;
+    constructor(context: NavigationMenuProviderState);
+}
+declare class NavigationMenuIndicatorImplState {
+    readonly opts: NavigationMenuIndicatorStateProps;
+    context: NavigationMenuProviderState;
+    listContext: NavigationMenuListState;
     position: {
         size: number;
         offset: number;
     } | null;
     isHorizontal: boolean;
     isVisible: boolean;
-    indicatorRef: NavigationMenuIndicatorStateProps["ref"];
-    constructor(props: NavigationMenuIndicatorStateProps, menu: NavigationMenuMenuState | NavigationMenuSubState);
+    activeTrigger: HTMLElement | null;
+    shouldRender: boolean;
+    constructor(opts: NavigationMenuIndicatorStateProps, context: {
+        provider: NavigationMenuProviderState;
+        list: NavigationMenuListState;
+    });
     handlePositionChange: () => void;
     props: {
-        readonly "aria-hidden": "true" | undefined;
+        readonly id: string;
         readonly "data-state": "hidden" | "visible";
         readonly "data-orientation": "horizontal" | "vertical";
         readonly style: {
             readonly left: number;
-            readonly width: string | undefined;
-            readonly transform: string | undefined;
+            readonly width: string;
+            readonly transform: string;
             readonly position: "absolute";
         } | {
             readonly top: number;
-            readonly height: string | undefined;
-            readonly transform: string | undefined;
+            readonly height: string;
+            readonly transform: string;
             readonly position: "absolute";
         };
         readonly "data-navigation-menu-indicator": "";
     };
 }
-type NavigationMenuContentStateProps = WithRefProps & ReadableBoxedValues<{
-    forceMount: boolean;
-    isMounted: boolean;
-}>;
-type MotionAttribute = "to-start" | "to-end" | "from-start" | "from-end";
+type NavigationMenuContentStateProps = WithRefProps;
 declare class NavigationMenuContentState {
-    id: NavigationMenuContentStateProps["id"];
-    forceMount: NavigationMenuContentStateProps["forceMount"];
-    isMounted: NavigationMenuContentStateProps["isMounted"];
-    contentRef: NavigationMenuContentStateProps["ref"];
-    menu: NavigationMenuMenuState | NavigationMenuSubState;
-    item: NavigationMenuItemState;
+    readonly opts: NavigationMenuContentStateProps;
+    context: NavigationMenuProviderState;
+    itemContext: NavigationMenuItemState;
+    listContext: NavigationMenuListState;
+    open: boolean;
+    mounted: boolean;
+    value: string;
+    isLastActiveValue: boolean;
+    constructor(opts: NavigationMenuContentStateProps, context: {
+        provider: NavigationMenuProviderState;
+        item: NavigationMenuItemState;
+        list: NavigationMenuListState;
+    });
+    onpointerenter: (_: BitsPointerEvent) => void;
+    onpointerleave: BitsPointerEventHandler<HTMLElement>;
+    props: {
+        readonly id: string;
+        readonly onpointerenter: (_: BitsPointerEvent) => void;
+        readonly onpointerleave: BitsPointerEventHandler<HTMLElement>;
+    };
+}
+type MotionAttribute = "to-start" | "to-end" | "from-start" | "from-end";
+type NavigationMenuContentImplStateProps = WithRefProps;
+declare class NavigationMenuContentImplState {
+    readonly opts: NavigationMenuContentImplStateProps;
+    readonly itemContext: NavigationMenuItemState;
+    context: NavigationMenuProviderState;
+    listContext: NavigationMenuListState;
     prevMotionAttribute: MotionAttribute | null;
     motionAttribute: MotionAttribute | null;
-    open: boolean;
-    isPresent: boolean;
-    constructor(props: NavigationMenuContentStateProps, item: NavigationMenuItemState);
-    onFocusOutside(e: Event): void;
-    onInteractOutside(e: Event): void;
-    onEscapeKeydown: (e: KeyboardEvent) => void;
-    onkeydown(e: BitsKeyboardEvent): void;
+    constructor(opts: NavigationMenuContentImplStateProps, itemContext: NavigationMenuItemState);
+    onFocusOutside: (e: Event) => void;
+    onInteractOutside: (e: PointerEvent) => void;
+    onkeydown: (e: BitsKeyboardEvent) => void;
+    onEscapeKeydown: (_: KeyboardEvent) => void;
     props: {
         readonly id: string;
         readonly "aria-labelledby": string | undefined;
-        readonly "data-motion": MotionAttribute | null;
-        readonly "data-state": "open" | "closed";
+        readonly "data-motion": MotionAttribute | undefined;
         readonly "data-orientation": "horizontal" | "vertical";
-        readonly "data-navigation-menu-content": "";
-        readonly style: {
-            readonly pointerEvents: "none" | undefined;
-        };
+        readonly "data-state": "open" | "closed";
         readonly onkeydown: (e: BitsKeyboardEvent) => void;
+        readonly "data-navigation-menu-content": "";
     };
 }
-type NavigationMenuViewportStateProps = WithRefProps;
 declare class NavigationMenuViewportState {
-    id: NavigationMenuViewportStateProps["id"];
-    menu: NavigationMenuMenuState | NavigationMenuSubState;
+    readonly opts: NavigationMenuViewportImplStateProps;
+    readonly context: NavigationMenuProviderState;
+    open: boolean;
     size: {
         width: number;
         height: number;
     } | null;
-    open: boolean;
+    contentNode: HTMLElement | null;
+    viewportWidth: string | undefined;
+    viewportHeight: string | undefined;
     activeContentValue: string;
-    viewportRef: NavigationMenuViewportStateProps["ref"];
-    contentNode: HTMLElement | null | undefined;
-    constructor(props: NavigationMenuViewportStateProps, menu: NavigationMenuMenuState | NavigationMenuSubState);
-    onpointerenter(_: BitsPointerEvent): void;
-    onpointerleave(e: BitsPointerEvent): void;
+    constructor(opts: NavigationMenuViewportImplStateProps, context: NavigationMenuProviderState);
     props: {
         readonly id: string;
         readonly "data-state": "open" | "closed";
@@ -318,16 +319,23 @@ declare class NavigationMenuViewportState {
             readonly "--bits-navigation-menu-viewport-width": string | undefined;
             readonly "--bits-navigation-menu-viewport-height": string | undefined;
         };
-        readonly onpointerenter: (_: BitsPointerEvent) => void;
-        readonly onpointerleave: (e: BitsPointerEvent) => void;
+        readonly onpointerenter: () => void;
+        readonly onpointerleave: () => void;
     };
 }
+type NavigationMenuViewportImplStateProps = WithRefProps;
+export declare const NavigationMenuItemContext: Context<NavigationMenuItemState>;
 export declare function useNavigationMenuRoot(props: NavigationMenuRootStateProps): NavigationMenuRootState;
+export declare function useNavigationMenuProvider(props: NavigationMenuProviderStateProps): NavigationMenuProviderState;
+export declare function useNavigationMenuSub(props: NavigationMenuSubStateProps): NavigationMenuSubState;
 export declare function useNavigationMenuList(props: NavigationMenuListStateProps): NavigationMenuListState;
 export declare function useNavigationMenuItem(props: NavigationMenuItemStateProps): NavigationMenuItemState;
+export declare function useNavigationMenuIndicatorImpl(props: NavigationMenuIndicatorStateProps): NavigationMenuIndicatorImplState;
 export declare function useNavigationMenuTrigger(props: NavigationMenuTriggerStateProps): NavigationMenuTriggerState;
 export declare function useNavigationMenuContent(props: NavigationMenuContentStateProps): NavigationMenuContentState;
-export declare function useNavigationMenuViewport(props: NavigationMenuViewportStateProps): NavigationMenuViewportState;
-export declare function useNavigationMenuIndicator(props: NavigationMenuIndicatorStateProps): NavigationMenuIndicatorState;
 export declare function useNavigationMenuLink(props: NavigationMenuLinkStateProps): NavigationMenuLinkState;
+export declare function useNavigationMenuContentImpl(props: NavigationMenuContentImplStateProps, itemState?: NavigationMenuItemState): NavigationMenuContentImplState;
+export declare function useNavigationMenuViewport(props: NavigationMenuViewportImplStateProps): NavigationMenuViewportState;
+export declare function useNavigationMenuIndicator(): NavigationMenuIndicatorState;
+type BitsPointerEventHandler<T extends HTMLElement = HTMLElement> = (e: BitsPointerEvent<T>) => void;
 export {};