@fluentui/react-nav 9.4.2 → 9.4.4

package/dist/index.d.cts

@@ -0,0 +1,1114 @@
+import type { ARIAButtonSlotProps } from '@fluentui/react-aria';
+import type { ButtonProps } from '@fluentui/react-button';
+import type { ButtonSlots } from '@fluentui/react-button';
+import type { ButtonState } from '@fluentui/react-button';
+import type { ComponentProps } from '@fluentui/react-utilities';
+import type { ComponentState } from '@fluentui/react-utilities';
+import type { DividerProps } from '@fluentui/react-divider';
+import { DividerSlots } from '@fluentui/react-divider';
+import type { DividerState } from '@fluentui/react-divider';
+import type { DrawerBodyProps } from '@fluentui/react-drawer';
+import type { DrawerBodySlots } from '@fluentui/react-drawer';
+import type { DrawerBodyState } from '@fluentui/react-drawer';
+import type { DrawerFooterProps } from '@fluentui/react-drawer';
+import type { DrawerFooterSlots } from '@fluentui/react-drawer';
+import type { DrawerFooterState } from '@fluentui/react-drawer';
+import type { DrawerHeaderProps } from '@fluentui/react-drawer';
+import type { DrawerHeaderSlots } from '@fluentui/react-drawer';
+import type { DrawerHeaderState } from '@fluentui/react-drawer';
+import type { DrawerProps } from '@fluentui/react-drawer';
+import type { DrawerSlots } from '@fluentui/react-drawer';
+import type { DrawerState } from '@fluentui/react-drawer';
+import type { EventData } from '@fluentui/react-utilities';
+import type { EventHandler } from '@fluentui/react-utilities';
+import type { ForwardRefComponent } from '@fluentui/react-utilities';
+import type { InlineDrawerSlots } from '@fluentui/react-drawer';
+import type { JSXElement } from '@fluentui/react-utilities';
+import type { MenuButtonProps } from '@fluentui/react-button';
+import type { PresenceMotionSlotProps } from '@fluentui/react-motion';
+import * as React_2 from 'react';
+import type { Slot } from '@fluentui/react-utilities';
+import type { SlotClassNames } from '@fluentui/react-utilities';
+import type { ToggleButtonProps } from '@fluentui/react-button';
+import type { TooltipProps } from '@fluentui/react-tooltip';
+
+/**
+ * AppItem component - Application item in the navigation menu.
+ */
+export declare const AppItem: ForwardRefComponent<AppItemProps>;
+
+export declare type AppItemBaseProps = AppItemProps;
+
+export declare type AppItemBaseState = Omit<AppItemState, 'density'>;
+
+export declare const appItemClassNames: SlotClassNames<AppItemSlots>;
+
+/**
+ * AppItem Props
+ */
+export declare type AppItemProps = ComponentProps<AppItemSlots> & {
+    href?: string;
+};
+
+export declare type AppItemSlots = {
+    /**
+     * The root element of the AppItem.
+     */
+    root: NonNullable<Slot<ARIAButtonSlotProps<'a'>>>;
+    /**
+     * Icon that renders before the content.
+     */
+    icon?: Slot<'span'>;
+};
+
+/**
+ * State used in rendering AppItem
+ */
+export declare type AppItemState = ComponentState<AppItemSlots> & {
+    /**
+     * The density of the NavItem
+     *
+     * @default 'medium'
+     */
+    density: NavDensity;
+};
+
+/**
+ * AppItemStatic component - Static application item in the navigation menu.
+ */
+export declare const AppItemStatic: ForwardRefComponent<AppItemStaticProps>;
+
+export declare type AppItemStaticBaseProps = AppItemStaticProps;
+
+export declare type AppItemStaticBaseState = Omit<AppItemStaticState, 'density'>;
+
+export declare const appItemStaticClassNames: SlotClassNames<AppItemStaticSlots>;
+
+/**
+ * AppItemStatic Props
+ */
+export declare type AppItemStaticProps = ComponentProps<AppItemStaticSlots>;
+
+export declare type AppItemStaticSlots = {
+    /**
+     * The root element of the AppItemStatic.
+     */
+    root: Slot<'div'>;
+    /**
+     * Icon that renders before the content.
+     */
+    icon?: Slot<'span'>;
+};
+
+/**
+ * State used in rendering AppItemStatic
+ */
+export declare type AppItemStaticState = ComponentState<AppItemStaticSlots> & {
+    /**
+     * The density of the Nav
+     *
+     * @default 'medium'
+     */
+    density: NavDensity;
+};
+
+/**
+ * Hamburger component - a button that toggles a menu or navigation drawer.
+ */
+export declare const Hamburger: ForwardRefComponent<HamburgerProps>;
+
+export declare const hamburgerClassNames: SlotClassNames<ButtonSlots>;
+
+/**
+ * Hamburger Props
+ */
+export declare type HamburgerProps = ButtonProps;
+
+/**
+ * State used in rendering Hamburger
+ */
+export declare type HamburgerState = ButtonState;
+
+/**
+ * Nav - A component that provides up to two levels of nesting for navigation.
+ */
+export declare const Nav: ForwardRefComponent<NavProps>;
+
+export declare type NavBaseProps = Omit<NavProps, 'density'>;
+
+export declare type NavBaseState = Omit<NavState, 'density' | 'tabbable'>;
+
+/**
+ * NavCategory component - a category in the navigation menu that can contain multiple items.
+ */
+export declare const NavCategory: ForwardRefComponent<NavCategoryProps>;
+
+declare type NavCategoryContextValue = {
+    open: boolean;
+    value: NavItemValue;
+};
+
+export declare type NavCategoryContextValues = {
+    categoryValue: NavCategoryContextValue;
+};
+
+/**
+ * A Nav Category Item provides provides a clickable accordion like header that exposes
+ * a list of NavSubItems to take users to a new destination.
+ */
+export declare const NavCategoryItem: ForwardRefComponent<NavCategoryItemProps>;
+
+/**
+ * Base NavCategoryItemProps, excluding design/animation-specific props.
+ */
+export declare type NavCategoryItemBaseProps = ComponentProps<Partial<NavCategoryItemBaseSlots>>;
+
+/**
+ * Base slots for NavCategoryItem, excluding design/animation-specific slots.
+ */
+export declare type NavCategoryItemBaseSlots = Omit<NavCategoryItemSlots, 'expandIconMotion'>;
+
+/**
+ * State used in rendering NavCategoryItem, excluding design/animation-specific state.
+ */
+export declare type NavCategoryItemBaseState = ComponentState<NavCategoryItemBaseSlots> & Pick<NavCategoryItemState, 'open' | 'value' | 'selected'>;
+
+export declare const navCategoryItemClassNames: SlotClassNames<NavCategoryItemSlots>;
+
+declare type NavCategoryItemContextValue = {
+    open: boolean;
+    value: NavItemValue;
+};
+
+export declare type NavCategoryItemContextValues = {
+    navCategoryItem: NavCategoryItemContextValue;
+};
+
+/**
+ * navCategoryItem Props
+ */
+export declare type NavCategoryItemProps = ComponentProps<Partial<NavCategoryItemSlots>>;
+
+export declare const NavCategoryItemProvider: React_2.Provider<NavCategoryItemContextValue>;
+
+export declare type NavCategoryItemSlots = {
+    /**
+     * The root element
+     */
+    root: NonNullable<Slot<'button'>>;
+    /**
+     * Icon that renders before the content.
+     * Should be specific to each Category
+     */
+    icon?: Slot<'span'>;
+    /**
+     * Expand icon slot rendered after the content to indicate an open and closed state.
+     */
+    expandIcon: NonNullable<Slot<'span'>>;
+    /**
+     * Expand icon motion slot.
+     */
+    expandIconMotion?: Slot<PresenceMotionSlotProps>;
+};
+
+/**
+ * State used in rendering NavCategoryItem
+ */
+export declare type NavCategoryItemState = ComponentState<NavCategoryItemSlots> & NavCategoryItemContextValue & {
+    /**
+     * If this navCategoryItem is selected
+     */
+    selected: boolean;
+    /**
+     * The density of the NavItem
+     *
+     * @default 'medium'
+     */
+    density: NavDensity;
+};
+
+/**
+ * NavCategory Props
+ */
+export declare type NavCategoryProps = {
+    /**
+     * Required value that identifies this item inside an Nav component.
+     */
+    value: NavItemValue;
+    /**
+     * Children of the NavCategory
+     */
+    children?: React_2.ReactNode | null;
+};
+
+export declare const NavCategoryProvider: React_2.Provider<NavCategoryContextValue>;
+
+/**
+ * State used in rendering NavCategory
+ */
+export declare type NavCategoryState = NavCategoryContextValue & Required<NavCategoryProps>;
+
+export declare const navClassNames: SlotClassNames<NavSlots>;
+
+export declare type NavContextValue = Pick<NavProps, 'onNavItemSelect' | 'selectedValue' | 'selectedCategoryValue' | 'density'> & {
+    /** A callback to allow a navItem to register itself with the navItem list. */
+    onRegister: RegisterNavItemEventHandler;
+    /** A callback to allow a navItem to unregister itself with the navItem list. */
+    onUnregister: RegisterNavItemEventHandler;
+    /**
+     * A callback to allow a navItem to select itself when pressed.
+     */
+    onSelect: EventHandler<OnNavItemSelectData>;
+    /**
+     * Gets the registered navItem data along with current and previous selected values.
+     */
+    getRegisteredNavItems: () => {
+        selectedValue?: NavItemValue;
+        selectedCategoryValue?: NavItemValue;
+        previousSelectedValue?: NavItemValue;
+        registeredNavItems: Record<string, NavItemRegisterData>;
+    };
+    /**
+     * Callback used by NavCategoryItem to request a change on it's own opened state
+     * Should be used to toggle NavCategoryItem's open state
+     */
+    onRequestNavCategoryItemToggle: EventHandler<OnNavItemSelectData>;
+    /**
+     * The list of opened panels by index
+     */
+    openCategories: NavItemValue[];
+    /**
+     * Indicates if Nav supports multiple open Categories at the same time.
+     * @default true, indicating that multiple categories can be open at the same time.
+     */
+    multiple: boolean;
+    /**
+     * Setting this to true enables tab AND arrow navigation.
+     * @default false
+     */
+    tabbable: boolean;
+};
+
+/**
+ * Context values used in rendering navItemList.
+ */
+export declare type NavContextValues = {
+    /**
+     * The context of the navItem list available to each navItem.
+     */
+    nav: NavContextValue;
+};
+
+/***
+ * Indicates the vertical density of the Nav content.
+ * This does not affect horizontal spacing.
+ */
+export declare type NavDensity = 'small' | 'medium';
+
+/**
+ * NavDivider component - a divider used within navigation components to separate items.
+ */
+export declare const NavDivider: ForwardRefComponent<NavDividerProps>;
+
+export declare const navDividerClassNames: SlotClassNames<DividerSlots>;
+
+/**
+ * NavDivider Props
+ */
+export declare type NavDividerProps = DividerProps;
+
+/**
+ * State used in rendering NavDivider
+ */
+export declare type NavDividerState = DividerState;
+
+/**
+ * NavDrawer component - a component that provides a drawer for navigation items.
+ */
+export declare const NavDrawer: ForwardRefComponent<NavDrawerProps>;
+
+/**
+ * NavDrawerBody component
+ */
+export declare const NavDrawerBody: ForwardRefComponent<NavDrawerBodyProps>;
+
+export declare const navDrawerBodyClassNames: SlotClassNames<NavDrawerBodySlots>;
+
+/**
+ * NavDrawerBody Props
+ */
+export declare type NavDrawerBodyProps = DrawerBodyProps;
+
+export declare type NavDrawerBodySlots = DrawerBodySlots;
+
+/**
+ * State used in rendering NavDrawerBody
+ */
+export declare type NavDrawerBodyState = DrawerBodyState;
+
+export declare const navDrawerClassNames: SlotClassNames<Omit<InlineDrawerSlots, 'surfaceMotion'>>;
+
+/**
+ * NavDrawerFooter component
+ */
+export declare const NavDrawerFooter: ForwardRefComponent<NavDrawerFooterProps>;
+
+export declare const navDrawerFooterClassNames: SlotClassNames<NavDrawerFooterSlots>;
+
+/**
+ * NavDrawerFooter Props
+ */
+export declare type NavDrawerFooterProps = DrawerFooterProps;
+
+export declare type NavDrawerFooterSlots = DrawerFooterSlots;
+
+/**
+ * State used in rendering NavDrawerFooter
+ */
+export declare type NavDrawerFooterState = DrawerFooterState;
+
+/**
+ * NavDrawerHeader component
+ */
+export declare const NavDrawerHeader: ForwardRefComponent<NavDrawerHeaderProps>;
+
+export declare const navDrawerHeaderClassNames: SlotClassNames<NavDrawerHeaderSlots>;
+
+/**
+ * NavDrawerHeader Props
+ */
+export declare type NavDrawerHeaderProps = DrawerHeaderProps;
+
+export declare type NavDrawerHeaderSlots = DrawerHeaderSlots;
+
+/**
+ * State used in rendering NavDrawerHeader
+ */
+export declare type NavDrawerHeaderState = DrawerHeaderState;
+
+/**
+ * NavDrawer Props
+ */
+export declare type NavDrawerProps = ComponentProps<NavDrawerSlots> & DrawerProps & NavProps & {
+    /**
+     * The component uses arrow navigation by default.
+     * Setting this to true enables tab AND arrow navigation.
+     * @default false
+     */
+    tabbable?: boolean;
+};
+
+/**
+ * NavDrawer slots
+ */
+export declare type NavDrawerSlots = DrawerSlots;
+
+/**
+ * State used in rendering NavDrawer
+ */
+export declare type NavDrawerState = DrawerState & NavContextValue & {
+    /**
+     * Analagous to size from DrawerBaseProps.
+     * Intended to be left unset in most cases.
+     * If left unset, it defaults to 260px.
+     */
+    size?: 'small' | 'medium' | 'large' | 'full';
+};
+
+/**
+ * NavItem component - a single item in the navigation menu.
+ */
+export declare const NavItem: ForwardRefComponent<NavItemProps>;
+
+export declare type NavItemBaseProps = NavItemProps;
+
+export declare type NavItemBaseState = Omit<NavItemState, 'density'>;
+
+export declare const navItemClassNames: SlotClassNames<NavItemSlots>;
+
+/**
+ * NavItem Props
+ */
+export declare type NavItemProps = ComponentProps<NavItemSlots> & {
+    /**
+     * Destination where the nav item points to.
+     */
+    href?: string;
+    /**
+     * The value that identifies this navCategoryItem when selected.
+     */
+    value: NavItemValue;
+};
+
+export declare type NavItemRegisterData = {
+    /**
+     * The value of the navItem.
+     */
+    value: NavItemValue;
+    /**
+     * The reference to the navItem HTML element.
+     */
+    ref: React_2.RefObject<HTMLElement | null>;
+};
+
+export declare type NavItemSlots = {
+    /**
+     * The root element of the NavItem.
+     */
+    root: NonNullable<Slot<ARIAButtonSlotProps<'a'>>>;
+    /**
+     * Icon that renders before the content.
+     */
+    icon?: Slot<'span'>;
+};
+
+/**
+ * State used in rendering NavItem
+ */
+export declare type NavItemState = ComponentState<NavItemSlots> & Pick<NavItemProps, 'value'> & {
+    /**
+     * If this navCategoryItem is selected
+     */
+    selected: boolean;
+    /**
+     * The density of the NavItem
+     *
+     * @default 'medium'
+     */
+    density: NavDensity;
+};
+
+/**
+ * Any value that identifies a specific Item.
+ */
+export declare type NavItemValue = string;
+
+/**
+ * Nav Props
+ */
+export declare type NavProps = ComponentProps<NavSlots> & {
+    /**
+     * The value of the navItem to be selected by default.
+     * Typically useful when the selectedValue is uncontrolled.
+     * Mutually exclusive with selectedValue.
+     * Empty string indicates no selection.
+     */
+    defaultSelectedValue?: NavItemValue;
+    /**
+     * The value of the navCategory to be selected by default.
+     * Typically useful when the selectedValue is uncontrolled.
+     * Mutually exclusive with selectedValue.
+     * Empty string indicates no selection.
+     */
+    defaultSelectedCategoryValue?: NavItemValue;
+    /**
+     * Set of categories that are opened by default.
+     * Typically useful when the openCategories is uncontrolled.
+     */
+    defaultOpenCategories?: NavItemValue[];
+    /**
+     * Controls the open categories.
+     * For use in controlled scenarios.
+     */
+    openCategories?: NavItemValue[];
+    /**
+     * Raised when a navItem is selected.
+     * If the navItem is child of a category, the categoryValue will be provided
+     */
+    onNavItemSelect?: EventHandler<OnNavItemSelectData>;
+    /**
+     * The value of the currently selected navItem.
+     * Mutually exclusive with defaultSelectedValue.
+     * @default undefined
+     */
+    selectedValue?: NavItemValue;
+    /**
+     * Indicates a category that has a selected child
+     * Will show the category as selected if it is closed.
+     * @default undefined
+     */
+    selectedCategoryValue?: NavItemValue;
+    /**
+     * Indicates if Nav supports multiple open Categories at the same time.
+     * @default true, indicating that multiple categories can be open at the same time.
+     */
+    multiple?: boolean;
+    /**
+     * Callback raised when a NavCategoryItem is toggled.
+     */
+    onNavCategoryItemToggle?: EventHandler<OnNavItemSelectData>;
+    /**
+     * The vertical density of the Nav and it's children
+     * @default 'medium'
+     */
+    density?: NavDensity;
+};
+
+export declare const NavProvider: React_2.Provider<NavContextValue | undefined>;
+
+/**
+ * NavSectionHeader component
+ */
+export declare const NavSectionHeader: ForwardRefComponent<NavSectionHeaderProps>;
+
+export declare const navSectionHeaderClassNames: SlotClassNames<NavSectionHeaderSlots>;
+
+/**
+ * NavSectionHeader Props
+ */
+export declare type NavSectionHeaderProps = ComponentProps<NavSectionHeaderSlots>;
+
+export declare type NavSectionHeaderSlots = {
+    root: Slot<'h2', 'h1' | 'h3' | 'h4' | 'h5' | 'h6' | 'div'>;
+};
+
+/**
+ * State used in rendering NavSectionHeader
+ */
+export declare type NavSectionHeaderState = ComponentState<NavSectionHeaderSlots>;
+
+export declare type NavSlots = {
+    root: NonNullable<Slot<'div'>>;
+};
+
+/**
+ * State used in rendering Nav
+ */
+export declare type NavState = ComponentState<NavSlots> & NavContextValue;
+
+/**
+ * NavSubItem component - a sub-item within a navigation structure.
+ */
+export declare const NavSubItem: ForwardRefComponent<NavSubItemProps>;
+
+export declare type NavSubItemBaseProps = NavSubItemProps;
+
+export declare type NavSubItemBaseState = Omit<NavSubItemState, 'density'>;
+
+export declare const navSubItemClassNames: SlotClassNames<NavSubItemSlots>;
+
+/**
+ * NavSubItemGroup component - a group of sub-items within a navigation structure.
+ */
+export declare const NavSubItemGroup: ForwardRefComponent<NavSubItemGroupProps>;
+
+export declare type NavSubItemGroupBaseProps = ComponentProps<NavSubItemGroupBaseSlots>;
+
+export declare type NavSubItemGroupBaseSlots = Omit<NavSubItemGroupSlots, 'collapseMotion'>;
+
+export declare type NavSubItemGroupBaseState = ComponentState<NavSubItemGroupBaseSlots> & Pick<NavSubItemGroupState, 'open'>;
+
+export declare const navSubItemGroupClassNames: SlotClassNames<Omit<NavSubItemGroupSlots, 'collapseMotion'>>;
+
+/**
+ * Context value for NavSubItemGroup
+ */
+declare type NavSubItemGroupCollapseMotionParams = {
+    /**
+     * The number of items in the NavSubItemGroup
+     */
+    items?: number;
+    /**
+     * The density of the NavItem
+     */
+    density?: NavDensity;
+};
+
+/**
+ * NavSubItemGroup Props
+ */
+export declare type NavSubItemGroupProps = ComponentProps<NavSubItemGroupSlots>;
+
+export declare type NavSubItemGroupSlots = {
+    /**
+     * The root element
+     */
+    root: NonNullable<Slot<'div'>>;
+    /**
+     * Collapse motion slot
+     */
+    collapseMotion?: Slot<PresenceMotionSlotProps<NavSubItemGroupCollapseMotionParams>>;
+};
+
+/**
+ * State used in rendering NavSubItemGroup
+ */
+export declare type NavSubItemGroupState = ComponentState<NavSubItemGroupSlots> & {
+    /**
+     * Internal open state, provided by context.
+     */
+    open: boolean;
+};
+
+/**
+ * NavSubItem Props
+ */
+export declare type NavSubItemProps = ComponentProps<NavSubItemSlots> & {
+    href?: string;
+    /**
+     * The value that identifies this NavSubItem when selected.
+     */
+    value: NavItemValue;
+};
+
+export declare type NavSubItemSlots = {
+    root: NonNullable<Slot<ARIAButtonSlotProps<'a'>>>;
+};
+
+/**
+ * State used in rendering NavSubItem
+ */
+export declare type NavSubItemState = ComponentState<NavSubItemSlots> & Pick<NavSubItemProps, 'value'> & {
+    /**
+     * If this NavSubItem is selected
+     */
+    selected: boolean;
+    /**
+     * The density of the NavItem
+     *
+     * @default 'medium'
+     */
+    density: NavDensity;
+};
+
+export declare type OnNavItemSelectData = EventData<'click', React_2.MouseEvent<HTMLButtonElement | HTMLAnchorElement>> & {
+    /**
+     * The value of the selected navItem.
+     * In the case of a category selection, this will be the value of the selected category.
+     */
+    value: NavItemValue;
+    /**
+     * The parent value of the selected navSubItem
+     * Null if not a child of a category
+     */
+    categoryValue?: NavItemValue;
+};
+
+export declare type RegisterNavItemEventHandler = (data: NavItemRegisterData) => void;
+
+/**
+ * Render the final JSX of AppItem
+ */
+export declare const renderAppItem_unstable: (state: AppItemState) => JSXElement;
+
+/**
+ * Render the final JSX of AppItemStatic
+ */
+export declare const renderAppItemStatic_unstable: (state: AppItemStaticState) => JSXElement;
+
+export declare const renderNav_unstable: (state: NavState, contextValues: NavContextValues) => JSXElement;
+
+/**
+ * Render the final JSX of NavCategory
+ */
+export declare const renderNavCategory_unstable: (state: NavCategoryState, contextValues: NavCategoryContextValues) => JSXElement;
+
+/**
+ * Render the final JSX of NavCategoryItem
+ */
+export declare const renderNavCategoryItem_unstable: (state: NavCategoryItemState, contextValues: NavCategoryItemContextValues) => JSXElement;
+
+export declare const renderNavDrawer_unstable: (state: NavDrawerState, contextValues: NavContextValues) => JSXElement;
+
+/**
+ * Render the final JSX of NavItem
+ */
+export declare const renderNavItem_unstable: (state: NavItemState) => JSXElement;
+
+/**
+ * Render the final JSX of NavSectionHeader
+ */
+export declare const renderNavSectionHeader_unstable: (state: NavSectionHeaderState) => JSXElement;
+
+/**
+ * Render the final JSX of NavSubItem
+ */
+export declare const renderNavSubItem_unstable: (state: NavSubItemState) => JSXElement;
+
+/**
+ * Render the final JSX of NavSubItemGroup
+ */
+export declare const renderNavSubItemGroup_unstable: (state: NavSubItemGroupState) => JSXElement;
+
+/**
+ * Render the final JSX of SplitNavItem
+ */
+export declare const renderSplitNavItem_unstable: (state: SplitNavItemState) => JSXElement;
+
+/**
+ * SplitNavItem component - TODO: add more docs
+ */
+export declare const SplitNavItem: ForwardRefComponent<SplitNavItemProps>;
+
+export declare const splitNavItemClassNames: SlotClassNames<SplitNavItemSlots>;
+
+/**
+ * SplitNavItem Props
+ */
+export declare type SplitNavItemProps = ComponentProps<SplitNavItemSlots>;
+
+export declare type SplitNavItemSlots = {
+    /**
+     * Root of the component, wrapping the children.
+     */
+    root: Slot<'div'>;
+    /**
+     * The NavItem Slot.
+     * Will behave as a SubNavItem if it's in an a SubGroup.
+     */
+    navItem?: NonNullable<Slot<NavItemProps & NavSubItemProps>>;
+    /**
+     * Basic button slot.
+     */
+    actionButton?: Slot<ButtonProps>;
+    /**
+     * Toggle button slot
+     */
+    toggleButton?: Slot<ToggleButtonProps>;
+    /**
+     * Menu button slot to stuff more things in when the other two aren't enough.
+     */
+    menuButton?: Slot<MenuButtonProps>;
+    /**
+     * Tooltip for the action button.
+     */
+    actionButtonTooltip?: Slot<TooltipProps>;
+    /**
+     * Tooltip for the toggle button.
+     */
+    toggleButtonTooltip?: Slot<TooltipProps>;
+    /**
+     * Tooltip for the menu button.
+     */
+    menuButtonTooltip?: Slot<TooltipProps>;
+};
+
+/**
+ * State used in rendering SplitNavItem
+ */
+export declare type SplitNavItemState = ComponentState<SplitNavItemSlots> & {
+    /**
+     * The density of the NavItem
+     *
+     * @default 'medium'
+     */
+    density: NavDensity;
+    /**
+     * A boolean that represents if the main item in the SplitNavItem is a SubNav item.
+     * If false, it's a NavItem.
+     */
+    isSubNav: boolean;
+};
+
+/**
+ * Create the state required to render AppItem.
+ *
+ * The returned state can be modified with hooks such as useAppItemStyles_unstable,
+ * before being passed to renderAppItem_unstable.
+ *
+ * @param props - props from this instance of AppItem
+ * @param ref - reference to root HTMLDivElement of AppItem
+ */
+export declare const useAppItem_unstable: (props: AppItemProps, ref: React_2.Ref<HTMLButtonElement | HTMLAnchorElement>) => AppItemState;
+
+/**
+ * Create the base state required to render AppItem.
+ *
+ * The returned state can be modified with hooks such as useAppItemStyles_unstable,
+ * before being passed to renderAppItem_unstable.
+ *
+ * @param props - props from this instance of AppItem
+ * @param ref - reference to root HTMLDivElement of AppItem
+ * @returns The base state of AppItem
+ */
+export declare const useAppItemBase_unstable: (props: AppItemBaseProps, ref: React_2.Ref<HTMLButtonElement | HTMLAnchorElement>) => AppItemBaseState;
+
+/**
+ * Create the state required to render AppItemStatic.
+ *
+ * The returned state can be modified with hooks such as useAppItemStaticStyles_unstable,
+ * before being passed to renderAppItemStatic_unstable.
+ *
+ * @param props - props from this instance of AppItemStatic
+ * @param ref - reference to root HTMLDivElement of AppItemStatic
+ */
+export declare const useAppItemStatic_unstable: (props: AppItemStaticProps, ref: React_2.Ref<HTMLDivElement>) => AppItemStaticState;
+
+export declare const useAppItemStaticBase_unstable: (props: AppItemStaticBaseProps, ref: React_2.Ref<HTMLDivElement>) => AppItemStaticBaseState;
+
+/**
+ * Apply styling to the AppItemStatic slots based on the state
+ */
+export declare const useAppItemStaticStyles_unstable: (state: AppItemStaticState) => AppItemStaticState;
+
+/**
+ * Apply styling to the AppItem slots based on the state
+ */
+export declare const useAppItemStyles_unstable: (state: AppItemState) => AppItemState;
+
+/**
+ * Given user props, defines default props for the Button, calls useButtonState and useChecked, and returns
+ * processed state.
+ * @param props - User provided props to the Button component.
+ * @param ref - User provided ref to be passed to the Button component.
+ */
+export declare const useHamburger_unstable: (props: HamburgerProps, ref: React_2.Ref<HTMLButtonElement | HTMLAnchorElement>) => HamburgerState;
+
+/**
+ * Apply styling to the Hamburger slots based on the state
+ */
+export declare const useHamburgerStyles_unstable: (state: HamburgerState) => HamburgerState;
+
+/**
+ * Create the state required to render Nav.
+ *
+ * The returned state can be modified with hooks such as useNavStyles,
+ * before being passed to renderNav.
+ *
+ * @param props - props from this instance of Nav
+ * @param ref - reference to root HTMLDivElement of Nav
+ */
+export declare const useNav_unstable: (props: NavProps, ref: React_2.Ref<HTMLDivElement>) => NavState;
+
+export declare const useNavBase_unstable: (props: NavBaseProps, ref: React_2.Ref<HTMLDivElement>) => NavBaseState;
+
+/**
+ * Create the state required to render NavCategory.
+ *
+ * The returned state can be modified with hooks such as useNavCategoryStyles_unstable,
+ * before being passed to renderNavCategory_unstable.
+ *
+ * @param props - props from this instance of NavCategory
+ * @param ref - reference to root HTMLDivElement of NavCategory
+ */
+export declare const useNavCategory_unstable: (props: NavCategoryProps, ref: React_2.Ref<HTMLDivElement>) => NavCategoryState;
+
+export declare const useNavCategoryContext_unstable: () => NavCategoryContextValue;
+
+export declare function useNavCategoryContextValues_unstable(state: NavCategoryState): NavCategoryContextValues;
+
+/**
+ * Create the state required to render NavCategoryItem.
+ *
+ * The returned state can be modified with hooks such as useNavCategoryItemStyles,
+ * before being passed to renderNavCategoryItem.
+ *
+ * @param props - props from this instance of NavCategoryItem
+ * @param ref - reference to root HTMLButtonElement of NavCategoryItem
+ */
+export declare const useNavCategoryItem_unstable: (props: NavCategoryItemProps, ref: React_2.Ref<HTMLButtonElement>) => NavCategoryItemState;
+
+/**
+ * Create the base state required to render NavCategoryItem.
+ *
+ * @param props - props from this instance of NavCategoryItem
+ * @param ref - reference to root HTMLButtonElement of NavCategoryItem
+ */
+export declare const useNavCategoryItemBase_unstable: (props: NavCategoryItemBaseProps, ref: React_2.Ref<HTMLButtonElement>) => NavCategoryItemBaseState;
+
+export declare const useNavCategoryItemContext_unstable: () => NavCategoryItemContextValue;
+
+export declare function useNavCategoryItemContextValues_unstable(state: NavCategoryItemState): NavCategoryItemContextValues;
+
+/**
+ * Apply styling to the NavCategoryItem slots based on the state
+ */
+export declare const useNavCategoryItemStyles_unstable: (state: NavCategoryItemState) => NavCategoryItemState;
+
+export declare const useNavContext_unstable: () => NavContextValue;
+
+export declare function useNavContextValues_unstable(state: NavState): NavContextValues;
+
+/**
+ * Create the state required to render NavDivider.
+ *
+ * The returned state can be modified with hooks such as useNavDividerStyles_unstable,
+ * before being passed to renderNavDivider_unstable.
+ *
+ * @param props - props from this instance of NavDivider
+ * @param ref - reference to root HTMLDivElement of NavDivider
+ */
+export declare const useNavDivider_unstable: (props: NavDividerProps, ref: React_2.Ref<HTMLElement>) => NavDividerState;
+
+/**
+ * Apply styling to the NavDivider slots based on the state
+ */
+export declare const useNavDividerStyles_unstable: (state: NavDividerState) => NavDividerState;
+
+/**
+ * Create the state required to render NavDrawer.
+ *
+ * The returned state can be modified with hooks such as useNavDrawerStyles_unstable,
+ * before being passed to renderNavDrawer_unstable.
+ *
+ * @param props - props from this instance of NavDrawer
+ * @param ref - reference to root HTMLDivElement of NavDrawer
+ */
+export declare const useNavDrawer_unstable: (props: NavDrawerProps, ref: React_2.Ref<HTMLDivElement>) => NavDrawerState;
+
+/**
+ * Create the state required to render NavDrawerBody.
+ *
+ * The returned state can be modified with hooks such as useNavDrawerBodyStyles_unstable,
+ * before being passed to renderNavDrawerBody_unstable.
+ *
+ * @param props - props from this instance of NavDrawerBody
+ * @param ref - reference to root HTMLDivElement of NavDrawerBody
+ */
+export declare const useNavDrawerBody_unstable: (props: NavDrawerBodyProps, ref: React_2.Ref<HTMLDivElement>) => NavDrawerBodyState;
+
+/**
+ * Apply styling to the NavDrawerBody slots based on the state
+ */
+export declare const useNavDrawerBodyStyles_unstable: (state: NavDrawerBodyState) => NavDrawerBodyState;
+
+/**
+ * Create the state required to render NavDrawerFooter.
+ *
+ * The returned state can be modified with hooks such as useNavDrawerFooterStyles_unstable,
+ * before being passed to renderNavDrawerFooter_unstable.
+ *
+ * @param props - props from this instance of NavDrawerFooter
+ * @param ref - reference to root HTMLDivElement of NavDrawerFooter
+ */
+export declare const useNavDrawerFooter_unstable: (props: NavDrawerFooterProps, ref: React_2.Ref<HTMLElement>) => NavDrawerFooterState;
+
+/**
+ * Apply styling to the NavDrawerFooter slots based on the state
+ */
+export declare const useNavDrawerFooterStyles_unstable: (state: NavDrawerFooterState) => NavDrawerFooterState;
+
+/**
+ * Create the state required to render NavDrawerHeader.
+ *
+ * The returned state can be modified with hooks such as useNavDrawerHeaderStyles_unstable,
+ * before being passed to renderNavDrawerHeader_unstable.
+ *
+ * @param props - props from this instance of NavDrawerHeader
+ * @param ref - reference to root HTMLDivElement of NavDrawerHeader
+ */
+export declare const useNavDrawerHeader_unstable: (props: NavDrawerHeaderProps, ref: React_2.Ref<HTMLElement>) => NavDrawerHeaderState;
+
+/**
+ * Apply styling to the NavDrawerHeader slots based on the state
+ */
+export declare const useNavDrawerHeaderStyles_unstable: (state: NavDrawerHeaderState) => NavDrawerHeaderState;
+
+/**
+ * Apply styling to the NavDrawer slots based on the state
+ */
+export declare const useNavDrawerStyles_unstable: (state: NavDrawerState) => NavDrawerState;
+
+/**
+ * Create the state required to render NavItem.
+ *
+ * The returned state can be modified with hooks such as useNavItemStyles_unstable,
+ * before being passed to renderNavItem_unstable.
+ *
+ * @param props - props from this instance of NavItem
+ * @param ref - reference to root HTMLAnchorElement of NavItem
+ */
+export declare const useNavItem_unstable: (props: NavItemProps, ref: React_2.Ref<HTMLButtonElement | HTMLAnchorElement>) => NavItemState;
+
+/**
+ * NavItemBaseState is the base state used in rendering NavItem,
+ * excluding any design-related properties such as `density`.
+ *
+ * @param props - props from this instance of NavItem
+ * @param ref - reference to root HTMLAnchorElement of NavItem
+ */
+export declare const useNavItemBase_unstable: (props: NavItemProps, ref: React_2.Ref<HTMLButtonElement | HTMLAnchorElement>) => NavItemBaseState;
+
+/**
+ * Apply styling to the NavItem slots based on the state
+ */
+export declare const useNavItemStyles_unstable: (state: NavItemState) => NavItemState;
+
+/**
+ * Create the state required to render NavSectionHeader.
+ *
+ * The returned state can be modified with hooks such as useNavSectionHeaderStyles_unstable,
+ * before being passed to renderNavSectionHeader_unstable.
+ *
+ * @param props - props from this instance of NavSectionHeader
+ * @param ref - reference to root HTMLDivElement of NavSectionHeader
+ */
+export declare const useNavSectionHeader_unstable: (props: NavSectionHeaderProps, ref: React_2.Ref<HTMLDivElement>) => NavSectionHeaderState;
+
+/**
+ * Apply styling to the NavSectionHeader slots based on the state
+ */
+export declare const useNavSectionHeaderStyles_unstable: (state: NavSectionHeaderState) => NavSectionHeaderState;
+
+/**
+ * Apply styling to the Nav slots based on the state
+ */
+export declare const useNavStyles_unstable: (state: NavState) => NavState;
+
+/**
+ * Create the state required to render NavSubItem.
+ *
+ * The returned state can be modified with hooks such as useNavSubItemStyles_unstable,
+ * before being passed to renderNavSubItem_unstable.
+ *
+ * @param props - props from this instance of NavSubItem
+ * @param ref - reference to root HTMLButtonElement of NavSubItem
+ */
+export declare const useNavSubItem_unstable: (props: NavSubItemProps, ref: React_2.Ref<HTMLButtonElement | HTMLAnchorElement>) => NavSubItemState;
+
+/**
+ * Base state used in rendering NavSubItem, excluding any design-related properties such as `density`.
+ *
+ * @param props - props from this instance of NavSubItem
+ * @param ref - reference to root HTMLButtonElement of NavSubItem
+ * @returns - The base state of NavSubItem
+ */
+export declare const useNavSubItemBase_unstable: (props: NavSubItemBaseProps, ref: React_2.Ref<HTMLButtonElement | HTMLAnchorElement>) => NavSubItemBaseState;
+
+/**
+ * Create the state required to render NavSubItemGroup.
+ *
+ * The returned state can be modified with hooks such as useNavSubItemGroupStyles_unstable,
+ * before being passed to renderNavSubItemGroup_unstable.
+ *
+ * @param props - props from this instance of NavSubItemGroup
+ * @param ref - reference to root HTMLDivElement of NavSubItemGroup
+ */
+export declare const useNavSubItemGroup_unstable: (props: NavSubItemGroupProps, ref: React_2.Ref<HTMLDivElement>) => NavSubItemGroupState;
+
+/**
+ * The base state used in rendering NavSubItemGroup, excluding any design-related properties such as motion props.
+ *
+ * @param props - props from this instance of NavSubItemGroup
+ * @param ref - reference to root HTMLDivElement of NavSubItemGroup
+ * @returns - The base state of NavSubItemGroup
+ */
+export declare const useNavSubItemGroupBase_unstable: (props: NavSubItemGroupBaseProps, ref: React_2.Ref<HTMLDivElement>) => NavSubItemGroupBaseState;
+
+/**
+ * Apply styling to the NavSubItemGroup slots based on the state
+ */
+export declare const useNavSubItemGroupStyles_unstable: (state: NavSubItemGroupState) => NavSubItemGroupState;
+
+/**
+ * Apply styling to the NavSubItem slots based on the state
+ */
+export declare const useNavSubItemStyles_unstable: (state: NavSubItemState) => NavSubItemState;
+
+/**
+ * Create the state required to render SplitNavItem.
+ *
+ * The returned state can be modified with hooks such as useSplitNavItemStyles_unstable,
+ * before being passed to renderSplitNavItem_unstable.
+ *
+ * @param props - props from this instance of SplitNavItem
+ * @param ref - reference to root HTMLDivElement of SplitNavItem
+ */
+export declare const useSplitNavItem_unstable: (props: SplitNavItemProps, ref: React_2.Ref<HTMLDivElement>) => SplitNavItemState;
+
+/**
+ * Apply styling to the SplitNavItem slots based on the state
+ */
+export declare const useSplitNavItemStyles_unstable: (state: SplitNavItemState) => SplitNavItemState;
+
+export { }