import type { Button } from '@fluentui/react-components';
import type { ComponentProps } from '@fluentui/react-components';
import type { ComponentState } from '@fluentui/react-components';
import type { DesignVersion } from '@fluentui-copilot/react-provider';
import type { ForwardRefComponent } from '@fluentui/react-components';
import type { InputListboxContextValues } from '@fluentui-copilot/react-input-listbox';
import type { InputListboxProps } from '@fluentui-copilot/react-input-listbox';
import type { InputListboxSlots } from '@fluentui-copilot/react-input-listbox';
import type { InputListboxState } from '@fluentui-copilot/react-input-listbox';
import type { JSXElement } from '@fluentui/react-utilities';
import type { MenuList } from '@fluentui/react-components';
import type { MenuPopover } from '@fluentui/react-components';
import type { MenuTrigger } from '@fluentui/react-components';
import { OptionOnSelectData } from '@fluentui-copilot/react-input-listbox';
import type { OptionProps } from '@fluentui-copilot/react-input-listbox';
import type { OptionState } from '@fluentui-copilot/react-input-listbox';
import type { OverflowProps } from '@fluentui/react-components';
import type { Persona } from '@fluentui/react-components';
import type { PositioningProps } from '@fluentui/react-components';
import * as React_2 from 'react';
import type { SearchBox } from '@fluentui/react-components';
import type { SkeletonItem } from '@fluentui/react-components';
import type { Slot } from '@fluentui/react-components';
import type { SlotClassNames } from '@fluentui/react-components';
import type { TabListContextValues } from '@fluentui/react-components';
import type { TabListProps } from '@fluentui/react-components';
import type { TabListSlots } from '@fluentui/react-components';
import type { TabListState } from '@fluentui/react-components';
import type { TabProps } from '@fluentui/react-components';
import type { TooltipProps } from '@fluentui/react-components';
import type { UseInputListboxFunctionality } from '@fluentui-copilot/react-input-listbox';
import type { UseInputListboxFunctionalityParams } from '@fluentui-copilot/react-input-listbox';

export declare const GROUNDING_MENU_GRID_AREAS: {
    commandBar: string;
    listbox: string;
};

export declare const GroundingCommandBar: ForwardRefComponent<GroundingCommandBarProps>;

export declare const GroundingCommandBarActions: ForwardRefComponent<GroundingCommandBarActionsProps>;

export declare const groundingCommandBarActionsClassNames: SlotClassNames<GroundingCommandBarActionsSlots>;

/**
 * GroundingCommandBarActions Props
 */
export declare type GroundingCommandBarActionsProps = ComponentProps<GroundingCommandBarActionsSlots> & {};

export declare type GroundingCommandBarActionsSlots = {
    root: Slot<'span'>;
};

/**
 * State used in rendering GroundingCommandBarActions
 */
export declare type GroundingCommandBarActionsState = ComponentState<GroundingCommandBarActionsSlots>;

export declare const groundingCommandBarClassNames: SlotClassNames<GroundingCommandBarSlots>;

export declare const GroundingCommandBarOverflowMenu: ForwardRefComponent<GroundingCommandBarOverflowMenuProps>;

export declare const GroundingCommandBarOverflowMenuClassNames: SlotClassNames<GroundingCommandBarOverflowMenuSlots>;

/**
 * GroundingCommandBarOverflowMenu Props
 */
export declare type GroundingCommandBarOverflowMenuProps = ComponentProps<GroundingCommandBarOverflowMenuSlots> & {
    onTabSelect?: TabListProps['onTabSelect'];
    /**
     * String to be used as the label of the overflowButtonLabel.
     * If undefined, or the provided function returns undefined, the default label will be used.
     * By default, if all tabs are overflowing, the label will be taken from the selected tab. Otherwise, the default label is '{x} more'
     * Return undefined when overflowCount is equal to the number of tabs to preserve this labelling behavior.
     */
    overflowButtonLabel?: (overflowCount: number) => string | undefined;
};

export declare type GroundingCommandBarOverflowMenuSlots = {
    root: NonNullable<Slot<'span'>>;
    menuTrigger?: Slot<typeof MenuTrigger>;
    menuButton?: Slot<typeof Button>;
    menuPopover?: Slot<typeof MenuPopover>;
    menuList?: Slot<typeof MenuList>;
};

/**
 * State used in rendering GroundingCommandBarOverflowMenu
 */
export declare type GroundingCommandBarOverflowMenuState = ComponentState<GroundingCommandBarOverflowMenuSlots> & {
    isOverflowing: boolean;
};

/**
 * GroundingCommandBar Props
 */
export declare type GroundingCommandBarProps = ComponentProps<GroundingCommandBarSlots> & {};

export declare type GroundingCommandBarSlots = {
    root: NonNullable<Slot<'div'>>;
};

/**
 * State used in rendering GroundingCommandBar
 */
export declare type GroundingCommandBarState = ComponentState<GroundingCommandBarSlots>;

export declare const GroundingCommandBarTab: ForwardRefComponent<GroundingCommandBarTabProps>;

export declare const groundingCommandBarTabClassNames: SlotClassNames<GroundingCommandBarTabSlots>;

export declare const GroundingCommandBarTabList: ForwardRefComponent<GroundingCommandBarTabListProps>;

export declare const groundingCommandBarTabListClassNames: SlotClassNames<GroundingCommandBarTabListSlots>;

/**
 * GroundingCommandBarTabList Props
 */
export declare type GroundingCommandBarTabListProps = ComponentProps<GroundingCommandBarTabListSlots> & TabListProps & Pick<OverflowProps, 'minimumVisible'> & {
    overflowPadding?: OverflowProps['padding'];
};

export declare type GroundingCommandBarTabListSlots = TabListSlots & {
    overflowMenu?: Slot<typeof GroundingCommandBarOverflowMenu>;
};

/**
 * State used in rendering GroundingCommandBarTabList
 */
export declare type GroundingCommandBarTabListState = ComponentState<GroundingCommandBarTabListSlots> & TabListState & Required<Pick<GroundingCommandBarTabListProps, 'overflowPadding' | 'minimumVisible'>>;

/**
 * GroundingCommandBarTab Props
 */
export declare type GroundingCommandBarTabProps = ComponentProps<Partial<GroundingCommandBarTabSlots>, 'tab'> & Pick<TabProps, 'value'>;

export declare type GroundingCommandBarTabSlots = {
    root: NonNullable<Slot<'span'>>;
    tab: NonNullable<Slot<TabSlot>>;
};

/**
 * State used in rendering GroundingCommandBarTab
 */
export declare type GroundingCommandBarTabState = ComponentState<GroundingCommandBarTabSlots> & {
    value: string;
    selected: boolean;
};

export declare const GroundingMenu: ForwardRefComponent<GroundingMenuProps>;

export declare const groundingMenuClassNames: SlotClassNames<GroundingMenuSlots>;

export declare const GroundingMenuError: ForwardRefComponent<GroundingMenuErrorProps>;

export declare const groundingMenuErrorClassNames: SlotClassNames<GroundingMenuErrorSlots>;

/**
 * GroundingMenuError Props
 */
export declare type GroundingMenuErrorProps = ComponentProps<GroundingMenuErrorSlots> & {};

export declare type GroundingMenuErrorSlots = {
    root: NonNullable<Slot<'div'>>;
    image?: Slot<'img'>;
    /**
     * In the vast majority of cases the heading should be present and it is an error to not set it.
     * If you're confident your scenario does not need a heading, it can be set to `null` explicitly to remove it.
     * In this case be careful to ensure the image or body content is accessible and provides the necessary context.
     */
    heading: Slot<'div'>;
    body?: Slot<'div'>;
};

/**
 * State used in rendering GroundingMenuError
 */
export declare type GroundingMenuErrorState = ComponentState<GroundingMenuErrorSlots>;

export declare const GroundingMenuItem: ForwardRefComponent<GroundingMenuItemProps>;

export declare const groundingMenuItemClassNames: Omit<SlotClassNames<GroundingMenuItemSlots>, 'submenuButtonTooltip'>;

/**
 * GroundingMenuItem Props
 */
export declare type GroundingMenuItemProps = ComponentProps<Partial<GroundingMenuItemSlots>, 'persona'> & Pick<OptionProps, 'disabled' | 'onOptionSelect' | 'value'> & DesignVersion;

export declare const GroundingMenuItemSkeleton: ForwardRefComponent<GroundingMenuItemSkeletonProps>;

export declare const groundingMenuItemSkeletonClassNames: SlotClassNames<GroundingMenuItemSkeletonSlots>;

/**
 * GroundingMenuItemSkeleton Props
 */
export declare type GroundingMenuItemSkeletonProps = ComponentProps<GroundingMenuItemSkeletonSlots> & {};

export declare type GroundingMenuItemSkeletonSlots = {
    root: Slot<'div'>;
    avatar?: Slot<typeof SkeletonItem>;
    primaryText?: Slot<typeof SkeletonItem>;
    secondaryText?: Slot<typeof SkeletonItem>;
};

/**
 * State used in rendering GroundingMenuItemSkeleton
 */
export declare type GroundingMenuItemSkeletonState = ComponentState<GroundingMenuItemSkeletonSlots>;

export declare type GroundingMenuItemSlots = {
    root: NonNullable<Slot<'div'>>;
    persona: NonNullable<Slot<typeof Persona>>;
    submenuButton?: Slot<typeof Button>;
    submenuButtonTooltip?: Slot<TooltipProps>;
};

/**
 * State used in rendering GroundingMenuItem
 */
export declare type GroundingMenuItemState = ComponentState<GroundingMenuItemSlots> & Pick<OptionState, 'disabled' | 'selected'> & Pick<Required<GroundingMenuItemProps>, 'designVersion'>;

export declare const GroundingMenuListbox: ForwardRefComponent<GroundingMenuListboxProps>;

export declare const groundingMenuListboxClassNames: SlotClassNames<GroundingMenuListboxSlots>;

/**
 * GroundingMenuListbox Props
 */
export declare type GroundingMenuListboxProps = InputListboxProps & ComponentProps<GroundingMenuListboxSlots> & {};

export declare type GroundingMenuListboxSlots = InputListboxSlots;

/**
 * State used in rendering GroundingMenuListbox
 */
export declare type GroundingMenuListboxState = InputListboxState & ComponentState<GroundingMenuListboxSlots>;

/**
 * GroundingMenu Props
 */
export declare type GroundingMenuProps = ComponentProps<GroundingMenuSlots> & {};

export declare const GroundingMenuSearchBox: ForwardRefComponent<GroundingMenuSearchBoxProps>;

export declare const groundingMenuSearchBoxClassNames: SlotClassNames<GroundingMenuSearchBoxSlots>;

declare type GroundingMenuSearchBoxExpandedData = {
    expanded: boolean;
};

/**
 * GroundingMenuSearchBox Props
 */
export declare type GroundingMenuSearchBoxProps = ComponentProps<Partial<GroundingMenuSearchBoxSlots>> & {
    /**
     * Whether the search box is visible or the collapsed button is visible.
     * @default false
     */
    expanded?: boolean;
    /**
     Whether or not the initial state of the search box is expanded when `expanded` is uncontrolled.
     @default false
     */
    defaultExpanded?: boolean;
    /**
     * Whether the search box should be focused when expanded from previously being collapsed.
     * If true, this will only focus the search box when the search box is expanded after previously being collapsed.
     * A search box that is expanded by default with the `expanded` prop will not be automatically focused.
     * @default true
     */
    focusSearchBoxOnExpand?: boolean;
    /**
     * Callback that will be triggered when the search box is expanded or collapsed
     * If the `expanded` prop is controlled by setting it to `true` or `false`, the search box will not automatically change.
     * In that case, this callback will still fire and indicate when the search box would have changed if `expanded` was uncontrolled.
     * @param newState The new expanded state.
     */
    onExpandedChange?: (newState: GroundingMenuSearchBoxExpandedData) => void;
    /**
     * By default, the search box will not automatically collapse if focus moves specifically to the GroundingCommandBarTabList.
     * Set this to `true` to override this behaviour and always (when uncontrolled) collapse the search box when blurred.
     * @default false
     */
    collapseOnUseTabs?: boolean;
};

export declare type GroundingMenuSearchBoxSlots = {
    root: NonNullable<Slot<'div'>>;
    expandButton?: Slot<typeof Button>;
    searchBox?: Slot<typeof SearchBox>;
};

/**
 * State used in rendering GroundingMenuSearchBox
 */
export declare type GroundingMenuSearchBoxState = ComponentState<GroundingMenuSearchBoxSlots> & Required<Pick<GroundingMenuSearchBoxProps, 'expanded'>>;

export declare type GroundingMenuSlots = {
    root: Slot<'div'>;
};

/**
 * State used in rendering GroundingMenu
 */
export declare type GroundingMenuState = ComponentState<GroundingMenuSlots>;

export declare const GroundingMenuSubmenuHeader: ForwardRefComponent<GroundingMenuSubmenuHeaderProps>;

export declare const groundingMenuSubmenuHeaderClassNames: SlotClassNames<Omit<GroundingMenuSubmenuHeaderSlots, 'backButtonTooltip'>>;

/**
 * GroundingMenuSubmenuHeader Props
 */
export declare type GroundingMenuSubmenuHeaderProps = ComponentProps<Partial<GroundingMenuSubmenuHeaderSlots>> & {};

export declare type GroundingMenuSubmenuHeaderSlots = {
    root: NonNullable<Slot<'div'>>;
    backButton?: Slot<typeof Button>;
    backButtonTooltip?: Slot<TooltipProps>;
    primaryText?: Slot<'div'>;
    secondaryText?: Slot<'div'>;
};

/**
 * State used in rendering GroundingMenuSubmenuHeader
 */
export declare type GroundingMenuSubmenuHeaderState = ComponentState<GroundingMenuSubmenuHeaderSlots>;

export { OptionOnSelectData }

/**
 * Render the final JSX of GroundingCommandBar
 */
export declare const renderGroundingCommandBar_unstable: (state: GroundingCommandBarState) => JSXElement;

/**
 * Render the final JSX of GroundingCommandBarActions
 */
export declare const renderGroundingCommandBarActions_unstable: (state: GroundingCommandBarActionsState) => JSXElement;

/**
 * Render the final JSX of GroundingCommandBarOverflowMenu
 */
export declare const renderGroundingCommandBarOverflowMenu_unstable: (state: GroundingCommandBarOverflowMenuState) => JSXElement;

/**
 * Render the final JSX of GroundingCommandBarTab
 */
export declare const renderGroundingCommandBarTab_unstable: (state: GroundingCommandBarTabState) => JSXElement;

/**
 * Render the final JSX of GroundingCommandBarTabList
 */
export declare const renderGroundingCommandBarTabList_unstable: (state: GroundingCommandBarTabListState, contextValues: TabListContextValues) => JSXElement;

/**
 * Render the final JSX of GroundingMenu
 */
export declare const renderGroundingMenu_unstable: (state: GroundingMenuState) => JSXElement;

/**
 * Render the final JSX of GroundingMenuError
 */
export declare const renderGroundingMenuError_unstable: (state: GroundingMenuErrorState) => JSXElement;

/**
 * Render the final JSX of GroundingMenuItem
 */
export declare const renderGroundingMenuItem_unstable: (state: GroundingMenuItemState) => JSXElement;

/**
 * Render the final JSX of GroundingMenuItemSkeleton
 */
export declare const renderGroundingMenuItemSkeleton_unstable: (state: GroundingMenuItemSkeletonState) => JSXElement;

/**
 * Render the final JSX of GroundingMenuListbox
 */
export declare const renderGroundingMenuListbox_unstable: (state: GroundingMenuListboxState, contextValues: InputListboxContextValues) => JSXElement;

/**
 * Render the final JSX of GroundingMenuSearchBox
 */
export declare const renderGroundingMenuSearchBox_unstable: (state: GroundingMenuSearchBoxState) => JSXElement;

/**
 * Render the final JSX of GroundingMenuSubmenuHeader
 */
export declare const renderGroundingMenuSubmenuHeader_unstable: (state: GroundingMenuSubmenuHeaderState) => JSXElement;

declare type TabSlot = ForwardRefComponent<Partial<TabProps>>;

/**
 * Create the state required to render GroundingCommandBar.
 *
 * The returned state can be modified with hooks such as useGroundingCommandBarStyles_unstable,
 * before being passed to renderGroundingCommandBar_unstable.
 *
 * @param props - props from this instance of GroundingCommandBar
 * @param ref - reference to root HTMLElement of GroundingCommandBar
 */
export declare const useGroundingCommandBar_unstable: (props: GroundingCommandBarProps, ref: React_2.Ref<HTMLDivElement>) => GroundingCommandBarState;

/**
 * Create the state required to render GroundingCommandBarActions.
 *
 * The returned state can be modified with hooks such as useGroundingCommandBarActionsStyles_unstable,
 * before being passed to renderGroundingCommandBarActions_unstable.
 *
 * @param props - props from this instance of GroundingCommandBarActions
 * @param ref - reference to root HTMLElement of GroundingCommandBarActions
 */
export declare const useGroundingCommandBarActions_unstable: (props: GroundingCommandBarActionsProps, ref: React_2.Ref<HTMLSpanElement>) => GroundingCommandBarActionsState;

/**
 * Apply styling to the GroundingCommandBarActions slots based on the state
 */
export declare const useGroundingCommandBarActionsStyles_unstable: (state: GroundingCommandBarActionsState) => GroundingCommandBarActionsState;

/**
 * Create the state required to render GroundingCommandBarOverflowMenu.
 *
 * The returned state can be modified with hooks such as useGroundingCommandBarOverflowMenuStyles_unstable,
 * before being passed to renderGroundingCommandBarOverflowMenu_unstable.
 *
 * @param props - props from this instance of GroundingCommandBarOverflowMenu
 * @param ref - reference to root HTMLElement of GroundingCommandBarOverflowMenu
 */
export declare const useGroundingCommandBarOverflowMenu_unstable: (props: GroundingCommandBarOverflowMenuProps, ref: React_2.Ref<HTMLSpanElement>) => GroundingCommandBarOverflowMenuState;

/**
 * Apply styling to the GroundingCommandBarOverflowMenu slots based on the state
 */
export declare const useGroundingCommandBarOverflowMenuStyles_unstable: (state: GroundingCommandBarOverflowMenuState) => GroundingCommandBarOverflowMenuState;

/**
 * Apply styling to the GroundingCommandBar slots based on the state
 */
export declare const useGroundingCommandBarStyles_unstable: (state: GroundingCommandBarState) => GroundingCommandBarState;

/**
 * Create the state required to render GroundingCommandBarTab.
 *
 * The returned state can be modified with hooks such as useGroundingCommandBarTabStyles_unstable,
 * before being passed to renderGroundingCommandBarTab_unstable.
 *
 * @param props - props from this instance of GroundingCommandBarTab
 * @param ref - reference to root HTMLElement of GroundingCommandBarTab
 */
export declare const useGroundingCommandBarTab_unstable: (props: GroundingCommandBarTabProps, ref: React_2.Ref<HTMLButtonElement>) => GroundingCommandBarTabState;

/**
 * Create the state required to render GroundingCommandBarTabList.
 *
 * The returned state can be modified with hooks such as useGroundingCommandBarTabListStyles_unstable,
 * before being passed to renderGroundingCommandBarTabList_unstable.
 *
 * @param props - props from this instance of GroundingCommandBarTabList
 * @param ref - reference to root HTMLElement of GroundingCommandBarTabList
 */
export declare const useGroundingCommandBarTabList_unstable: (props: GroundingCommandBarTabListProps, ref: React_2.Ref<HTMLDivElement>) => GroundingCommandBarTabListState;

/**
 * Apply styling to the GroundingCommandBarTabList slots based on the state
 */
export declare const useGroundingCommandBarTabListStyles_unstable: (state: GroundingCommandBarTabListState) => GroundingCommandBarTabListState;

/**
 * Apply styling to the GroundingCommandBarTab slots based on the state
 */
export declare const useGroundingCommandBarTabStyles_unstable: (state: GroundingCommandBarTabState) => GroundingCommandBarTabState;

/**
 * Create the state required to render GroundingMenu.
 *
 * The returned state can be modified with hooks such as useGroundingMenuStyles_unstable,
 * before being passed to renderGroundingMenu_unstable.
 *
 * @param props - props from this instance of GroundingMenu
 * @param ref - reference to root HTMLElement of GroundingMenu
 */
export declare const useGroundingMenu_unstable: (props: GroundingMenuProps, ref: React_2.Ref<HTMLDivElement>) => GroundingMenuState;

/**
 * Create the state required to render GroundingMenuError.
 *
 * The returned state can be modified with hooks such as useGroundingMenuErrorStyles_unstable,
 * before being passed to renderGroundingMenuError_unstable.
 *
 * @param props - props from this instance of GroundingMenuError
 * @param ref - reference to root HTMLElement of GroundingMenuError
 */
export declare const useGroundingMenuError_unstable: (props: GroundingMenuErrorProps, ref: React_2.Ref<HTMLDivElement>) => GroundingMenuErrorState;

/**
 * Apply styling to the GroundingMenuError slots based on the state
 */
export declare const useGroundingMenuErrorStyles_unstable: (state: GroundingMenuErrorState) => GroundingMenuErrorState;

export declare const useGroundingMenuFunctionality: <PositioningTargetElem extends HTMLElement, ControlSurfaceElem extends HTMLElement>(props: UseGroundingMenuFunctionalityProps) => UseGroundingMenuFunctionalityReturn<PositioningTargetElem, ControlSurfaceElem>;

export declare type UseGroundingMenuFunctionalityProps = Omit<UseInputListboxFunctionalityParams, 'selectedOptions' | 'defaultSelectedOptions'> & {
    positioning?: PositioningProps;
};

export declare type UseGroundingMenuFunctionalityReturn<PositioningTargetElem extends HTMLElement, ControlSurfaceElem extends HTMLElement> = {
    positioningTargetRef: React_2.MutableRefObject<PositioningTargetElem | null>;
    groundingMenuProps: GroundingMenuProps & {
        ref: React_2.MutableRefObject<HTMLDivElement | null>;
    };
    groundingMenuListboxProps: GroundingMenuListboxProps & {
        ref: React_2.Ref<HTMLDivElement>;
    };
    controlSurfaceProps: Omit<UseInputListboxFunctionality<ControlSurfaceElem>['triggerProps'], 'ref'> & {
        ref: React_2.MutableRefObject<ControlSurfaceElem | null>;
    };
};

/**
 * Create the state required to render GroundingMenuItem.
 *
 * The returned state can be modified with hooks such as useGroundingMenuItemStyles_unstable,
 * before being passed to renderGroundingMenuItem_unstable.
 *
 * @param props - props from this instance of GroundingMenuItem
 * @param ref - reference to root HTMLElement of GroundingMenuItem
 */
export declare const useGroundingMenuItem_unstable: (props: GroundingMenuItemProps, ref: React_2.Ref<HTMLSpanElement>) => GroundingMenuItemState;

/**
 * Create the state required to render GroundingMenuItemSkeleton.
 *
 * The returned state can be modified with hooks such as useGroundingMenuItemSkeletonStyles_unstable,
 * before being passed to renderGroundingMenuItemSkeleton_unstable.
 *
 * @param props - props from this instance of GroundingMenuItemSkeleton
 * @param ref - reference to root HTMLElement of GroundingMenuItemSkeleton
 */
export declare const useGroundingMenuItemSkeleton_unstable: (props: GroundingMenuItemSkeletonProps, ref: React_2.Ref<HTMLDivElement>) => GroundingMenuItemSkeletonState;

/**
 * Apply styling to the GroundingMenuItemSkeleton slots based on the state
 */
export declare const useGroundingMenuItemSkeletonStyles_unstable: (state: GroundingMenuItemSkeletonState) => GroundingMenuItemSkeletonState;

/**
 * Apply styling to the GroundingMenuItem slots based on the state
 */
export declare const useGroundingMenuItemStyles_unstable: (state: GroundingMenuItemState) => GroundingMenuItemState;

/**
 * Create the state required to render GroundingMenuListbox.
 *
 * The returned state can be modified with hooks such as useGroundingMenuListboxStyles_unstable,
 * before being passed to renderGroundingMenuListbox_unstable.
 *
 * @param props - props from this instance of GroundingMenuListbox
 * @param ref - reference to root HTMLElement of GroundingMenuListbox
 */
export declare const useGroundingMenuListbox_unstable: (props: GroundingMenuListboxProps, ref: React_2.Ref<HTMLDivElement>) => GroundingMenuListboxState;

/**
 * Apply styling to the GroundingMenuListbox slots based on the state
 */
export declare const useGroundingMenuListboxStyles_unstable: (state: GroundingMenuListboxState) => GroundingMenuListboxState;

/**
 * Create the state required to render GroundingMenuSearchBox.
 *
 * The returned state can be modified with hooks such as useGroundingMenuSearchBoxStyles_unstable,
 * before being passed to renderGroundingMenuSearchBox_unstable.
 *
 * @param props - props from this instance of GroundingMenuSearchBox
 * @param ref - reference to root HTMLElement of GroundingMenuSearchBox
 */
export declare const useGroundingMenuSearchBox_unstable: (props: GroundingMenuSearchBoxProps, ref: React_2.Ref<HTMLDivElement>) => GroundingMenuSearchBoxState;

/**
 * Apply styling to the GroundingMenuSearchBox slots based on the state
 */
export declare const useGroundingMenuSearchBoxStyles_unstable: (state: GroundingMenuSearchBoxState) => GroundingMenuSearchBoxState;

/**
 * Apply styling to the GroundingMenu slots based on the state
 */
export declare const useGroundingMenuStyles_unstable: (state: GroundingMenuState) => GroundingMenuState;

/**
 * Create the state required to render GroundingMenuSubmenuHeader.
 *
 * The returned state can be modified with hooks such as useGroundingMenuSubmenuHeaderStyles_unstable,
 * before being passed to renderGroundingMenuSubmenuHeader_unstable.
 *
 * @param props - props from this instance of GroundingMenuSubmenuHeader
 * @param ref - reference to root HTMLElement of GroundingMenuSubmenuHeader
 */
export declare const useGroundingMenuSubmenuHeader_unstable: (props: GroundingMenuSubmenuHeaderProps, ref: React_2.Ref<HTMLDivElement>) => GroundingMenuSubmenuHeaderState;

/**
 * Apply styling to the GroundingMenuSubmenuHeader slots based on the state
 */
export declare const useGroundingMenuSubmenuHeaderStyles_unstable: (state: GroundingMenuSubmenuHeaderState) => GroundingMenuSubmenuHeaderState;

export { }