@servicetitan/anvil2 1.44.1 → 1.45.0

package/dist/components/Listbox/Listbox.d.ts

@@ -1,35 +1,104 @@
-import { ListboxProps as CoreListboxProps, ListboxOptionProps as CoreListboxOptionProps, ListboxOptionGroupProps as CoreListboxOptionGroupProps } from '@servicetitan/hammer-react';
-import { ForwardedRef } from 'react';
-import { DataTrackingId } from '../../types/DataTrackingId';
+import { Ref, ReactNode, ComponentPropsWithoutRef } from 'react';
+import { LayoutUtilProps } from '../../types';
 /**
- * Props for the Listbox component
- * @property {"single" | "multiple"} [selectionMode] - Selection mode for the listbox
- * @property {boolean} [disableAutoSelectOnFocus] - Whether to disable automatic selection when focusing on an option
- * @property {string | string[] | ItemType<T> | ItemType<T>[]} [selected] - Currently selected item(s) (controlled)
- * @property {string | string[] | ItemType<T> | ItemType<T>[]} [defaultSelected] - Default selected item(s) (uncontrolled)
- * @property {function} [onSelectionChange] - Callback when selection changes
- * @property {ItemType<T>[]} [items] - Array of items to render (when using items prop)
- * @property {ReactNode | function} [children] - Child elements or render function for items
- * @extends ComponentPropsWithoutRef<"ul">
- * @extends LayoutUtilProps
+ * Represents an item in the listbox with a label and optional disabled state.
+ * @template T - The type of additional properties for the item
  */
-export type ListboxProps<T> = CoreListboxProps<T>;
+export type ListboxItemType<T> = T & {
+    /** The display label for the item */
+    label: string;
+    /** Whether the item is disabled and cannot be selected */
+    disabled?: boolean;
+};
 /**
- * Props for the ListboxOption component
- * @property {string} value - The value of the option
- * @property {string} [label] - The display label for the option
- * @property {boolean} [disabled] - Whether the option is disabled
- * @property {ItemType<T>} [item] - The item object when using items prop
- * @extends ComponentPropsWithoutRef<"li">
+ * Props for single selection mode without items array
  */
-export type ListboxOptionProps = CoreListboxOptionProps & DataTrackingId;
+type SingleWithoutItems = {
+    /** Selection mode for single item selection */
+    selectionMode?: "single";
+    /** Whether to disable automatic selection when focusing on an option */
+    disableAutoSelectOnFocus?: boolean;
+    /** Currently selected item (controlled) */
+    selected?: string;
+    /** Default selected item (uncontrolled) */
+    defaultSelected?: string;
+    /** Callback when selection changes */
+    onSelectionChange?: (selected: string | undefined) => void;
+    /** Items array - not allowed in this mode */
+    items?: never;
+    /** Child elements to render */
+    children: ReactNode;
+};
 /**
- * Props for the ListboxOptionGroup component
- * @property {string} label - The label for the option group
- * @property {ReactNode} children - The options within this group
- * @extends ComponentPropsWithoutRef<"div">
+ * Props for multiple selection mode without items array
  */
-export type ListboxOptionGroupProps = CoreListboxOptionGroupProps;
+type MultipleWithoutItems = {
+    /** Selection mode for multiple item selection */
+    selectionMode: "multiple";
+    /** Auto-select on focus is not available in multiple mode */
+    disableAutoSelectOnFocus?: never;
+    /** Currently selected items (controlled) */
+    selected?: string[];
+    /** Default selected items (uncontrolled) */
+    defaultSelected?: string[];
+    /** Callback when selection changes */
+    onSelectionChange?: (selected: string[] | undefined) => void;
+    /** Items array - not allowed in this mode */
+    items?: never;
+    /** Child elements to render */
+    children: ReactNode;
+};
+/**
+ * Props for single selection mode with items array
+ * @template T - The type of additional properties for items
+ */
+type SingleWithItems<T> = {
+    /** Selection mode for single item selection */
+    selectionMode?: "single";
+    /** Whether to disable automatic selection when focusing on an option */
+    disableAutoSelectOnFocus?: boolean;
+    /** Currently selected item (controlled) */
+    selected?: ListboxItemType<T>;
+    /** Default selected item (uncontrolled) */
+    defaultSelected?: ListboxItemType<T>;
+    /** Callback when selection changes */
+    onSelectionChange?: (selected: ListboxItemType<T> | undefined) => void;
+    /** Array of items to render */
+    items: ListboxItemType<T>[];
+    /** Optional render function for items */
+    children?: ({ items }: {
+        items: ListboxItemType<T>[];
+    }) => ReactNode;
+};
+/**
+ * Props for multiple selection mode with items array
+ * @template T - The type of additional properties for items
+ */
+type MultipleWithItems<T> = {
+    /** Selection mode for multiple item selection */
+    selectionMode?: "multiple";
+    /** Auto-select on focus is not available in multiple mode */
+    disableAutoSelectOnFocus?: never;
+    /** Currently selected items (controlled) */
+    selected?: ListboxItemType<T>[];
+    /** Default selected items (uncontrolled) */
+    defaultSelected?: ListboxItemType<T>[];
+    /** Callback when selection changes */
+    onSelectionChange?: (selected: ListboxItemType<T>[] | undefined) => void;
+    /** Array of items to render */
+    items: ListboxItemType<T>[];
+    /** Optional render function for items */
+    children?: ({ items }: {
+        items: ListboxItemType<T>[];
+    }) => ReactNode;
+};
+/**
+ * Props for the Listbox component
+ * @template T - The type of additional properties for items
+ * @extends ComponentPropsWithoutRef<"ul">
+ * @extends LayoutUtilProps
+ */
+export type ListboxProps<T> = Omit<ComponentPropsWithoutRef<"ul">, "children"> & LayoutUtilProps & (SingleWithoutItems | MultipleWithoutItems | SingleWithItems<T> | MultipleWithItems<T>);
 /**
  * Listbox component for selecting one or more items from a list
  *
@@ -51,40 +120,7 @@ export type ListboxOptionGroupProps = CoreListboxOptionGroupProps;
  *   <Listbox.Option value="option2">Option 2</Listbox.Option>
  * </Listbox>
  */
-declare const ListboxElement: <T>(props: ListboxProps<T>, ref: ForwardedRef<HTMLUListElement>) => import("react/jsx-runtime").JSX.Element;
-/**
- * ListboxOption component for individual selectable items within a listbox
- *
- * Features:
- * - Displays selectable options with proper ARIA attributes
- * - Supports disabled state for non-selectable options
- * - Keyboard navigation support
- * - Automatic tracking ID generation for analytics
- * - Accessible with screen reader support
- *
- * @example
- * <ListboxOption value="option1" label="Option 1" />
- */
-export declare const ListboxOption: import('react').ForwardRefExoticComponent<ListboxOptionProps & import('react').RefAttributes<HTMLLIElement>>;
-/**
- * ListboxOptionGroup component for grouping related options within a listbox
- *
- * Features:
- * - Groups related options with a descriptive label
- * - Maintains proper ARIA structure for accessibility
- * - Supports keyboard navigation within groups
- * - Visual separation of option categories
- *
- * @example
- * <ListboxOptionGroup label="Fruits">
- *   <ListboxOption value="apple">Apple</ListboxOption>
- *   <ListboxOption value="banana">Banana</ListboxOption>
- * </ListboxOptionGroup>
- */
-export declare const ListboxOptionGroup: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
-    disabled?: boolean;
-    label: string;
-} & import('react').RefAttributes<HTMLDivElement>>;
+declare const ListboxElement: <T>(props: ListboxProps<T>, ref: Ref<HTMLUListElement>) => import("react/jsx-runtime").JSX.Element;
 /**
  * Listbox component for selecting one or more items from a list
  *
@@ -122,7 +158,7 @@ export declare const Listbox: (<T>(props: ListboxProps<T> & {
      * @example
      * <Listbox.Option value="option1" label="Option 1" />
      */
-    Option: import('react').ForwardRefExoticComponent<ListboxOptionProps & import('react').RefAttributes<HTMLLIElement>>;
+    Option: import('react').ForwardRefExoticComponent<import('./ListboxOption').ListboxOptionProps & import('react').RefAttributes<HTMLLIElement>>;
     /**
      * ListboxOptionGroup component for grouping related options within a listbox
      *

package/dist/components/Listbox/ListboxOption.d.ts

@@ -0,0 +1,53 @@
+import { ComponentPropsWithoutRef } from 'react';
+import { FlexProps } from '../Flex';
+import { DataTrackingId } from '../../types';
+type ItemType = {
+    label: string;
+    [key: string]: unknown;
+};
+/**
+ * Props for the ListboxOption component
+ * @extends ComponentPropsWithoutRef<"li">
+ */
+export type ListboxOptionProps = ComponentPropsWithoutRef<"li"> & {
+    /** The value of the option */
+    value?: string;
+    /** Whether the option is disabled */
+    disabled?: boolean;
+    /** Flex alignment for items */
+    alignItems?: FlexProps["alignItems"];
+    /** Flex justification for items */
+    justifyItems?: FlexProps["justifyItems"];
+    /** Flex alignment for content */
+    alignContent?: FlexProps["alignContent"];
+    /** Flex justification for content */
+    justifyContent?: FlexProps["justifyContent"];
+    /** Flex place-items property */
+    placeItems?: FlexProps["placeItems"];
+    /** Flex place-content property */
+    placeContent?: FlexProps["placeContent"];
+} & ({
+    /** The item object when using items prop */
+    item: ItemType;
+    /** The display label for the option (optional if item is provided) */
+    label?: string;
+} | {
+    /** The display label for the option */
+    label: string;
+    /** No item object when using label directly */
+    item?: never;
+}) & DataTrackingId;
+/**
+ * ListboxOption component for individual selectable items within a listbox.
+ *
+ * Features:
+ * - Displays selectable options with proper ARIA attributes
+ * - Supports disabled state for non-selectable options
+ * - Keyboard navigation support
+ * - Accessible with screen reader support
+ *
+ * @example
+ * <ListboxOption value="option1" label="Option 1" />
+ */
+export declare const ListboxOption: import('react').ForwardRefExoticComponent<ListboxOptionProps & import('react').RefAttributes<HTMLLIElement>>;
+export {};

package/dist/components/Listbox/ListboxOptionGroup.d.ts

@@ -0,0 +1,32 @@
+import { ComponentPropsWithoutRef } from 'react';
+/**
+ * Props for the ListboxOptionGroup component
+ * @extends ComponentPropsWithoutRef<"div">
+ */
+export type ListboxOptionGroupProps = ComponentPropsWithoutRef<"div"> & {
+    /** Whether the group is disabled */
+    disabled?: boolean;
+    /** The label for the option group */
+    label: string;
+};
+/**
+ * ListboxOptionGroup component for grouping related options within a listbox.
+ *
+ * Features:
+ * - Groups related options with a descriptive label
+ * - Maintains proper ARIA structure for accessibility
+ * - Supports keyboard navigation within groups
+ * - Visual separation of option categories
+ *
+ * @example
+ * <ListboxOptionGroup label="Fruits">
+ *   <ListboxOption value="apple">Apple</ListboxOption>
+ *   <ListboxOption value="banana">Banana</ListboxOption>
+ * </ListboxOptionGroup>
+ */
+export declare const ListboxOptionGroup: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    /** Whether the group is disabled */
+    disabled?: boolean;
+    /** The label for the option group */
+    label: string;
+} & import('react').RefAttributes<HTMLDivElement>>;

package/dist/components/Listbox/index.d.ts

@@ -1,2 +1,4 @@
 export * from './Listbox';
-export { Listbox as default } from './Listbox';
+export { Listbox as default, type ListboxProps } from './Listbox';
+export { ListboxOption, type ListboxOptionProps } from './ListboxOption';
+export { ListboxOptionGroup, type ListboxOptionGroupProps, } from './ListboxOptionGroup';

package/dist/components/Listbox/internal/ListboxContext.d.ts

@@ -0,0 +1,38 @@
+import { Dispatch, SetStateAction } from 'react';
+import { ListboxProps } from '../Listbox';
+/**
+ * Context properties for the Listbox component
+ * @template T - The type of additional properties for items
+ */
+export type ListboxContextProps<T> = {
+    /** ID of the currently focused option */
+    currentFocus?: string;
+    /** Function to set the currently focused option */
+    setCurrentFocus: Dispatch<SetStateAction<ListboxContextProps<T>["currentFocus"]>>;
+    /** Currently selected option(s) */
+    selected: ListboxProps<T>["defaultSelected"];
+    /** Function to set the selected option(s) */
+    setSelected: Dispatch<SetStateAction<ListboxContextProps<T>["selected"]>>;
+    /** List of available option elements */
+    options: NodeListOf<HTMLElement> | undefined;
+    /** Current selection mode */
+    selectionMode: Exclude<ListboxProps<T>["selectionMode"], undefined>;
+    /** Callback when selection changes */
+    onSelectionChange: ListboxProps<T>["onSelectionChange"];
+    /** Whether auto-select on focus is disabled */
+    disableAutoSelectOnFocus: boolean;
+    /** Array of items if using items prop */
+    items?: unknown[];
+    /** Whether the component is controlled */
+    controlled?: boolean;
+};
+/**
+ * Context for sharing listbox state between components
+ */
+export declare const ListboxContext: import('react').Context<ListboxContextProps<any> | null>;
+/**
+ * Hook to access the listbox context
+ * @returns The listbox context
+ * @throws Error if used outside of a Listbox component
+ */
+export declare const useListbox: () => ListboxContextProps<any>;

package/dist/components/Listbox/internal/ListboxOptionGroupContext.d.ts

@@ -0,0 +1,5 @@
+type ListboxOptionGroupContextProps = {
+    disabled?: boolean;
+};
+export declare const ListboxOptionGroupContext: import('react').Context<ListboxOptionGroupContextProps>;
+export {};

package/dist/components/Listbox/internal/utils.d.ts

@@ -0,0 +1,4 @@
+import { KeyboardEvent } from 'react';
+import { ListboxContextProps } from './ListboxContext';
+export declare const scrollToOption: (node: HTMLElement | undefined) => void;
+export declare const onListboxKeyDown: (e: KeyboardEvent<HTMLUListElement>, context: ListboxContextProps<any>) => void;

package/dist/components/Menu/Menu.d.ts

@@ -1,42 +1,18 @@
-import { MenuProps as CoreMenuProps, MenuItemProps as CoreMenuItemProps } from '@servicetitan/hammer-react';
-import { DataTrackingId } from '../../types/DataTrackingId';
+import { ButtonProps } from '../Button';
+import { IconProps } from '../Icon';
+import { DataTrackingId } from '../../types';
+import { MenuCommonProps } from './types';
 /**
  * Props for the Menu component
- * @property {string} [value] - The value associated with the menu for tracking
- * @property {string} [aria-label] - Accessible label for the menu
+ * @extends Omit<ButtonProps, "icon">
+ * @extends MenuCommonProps
  */
-export type MenuProps = CoreMenuProps & DataTrackingId;
-/**
- * Props for the MenuItem component
- * @property {string} [label] - The label text for the menu item
- */
-export type MenuItemProps = CoreMenuItemProps & DataTrackingId;
-/**
- * MenuItem component for individual menu options within a Menu.
- *
- * Features:
- * - Supports icons and labels
- * - Keyboard navigation support
- * - Disabled state handling
- * - Automatic menu closing on selection
- * - Fully accessible with proper ARIA attributes
- * - Focus management and tab index handling
- * - Click and mouse enter event handling
- * - Legacy popover support with fallback
- * - Automatic tracking ID generation for analytics
- *
- * @example
- * <MenuItem
- *   label="Edit Profile"
- *   icon={EditIcon}
- *   onClick={() => console.log('Edit profile clicked')}
- * />
- */
-export declare const MenuItem: import('react').ForwardRefExoticComponent<{
-    icon?: import('@servicetitan/hammer-react').IconProps["svg"];
-    label: import('react').ReactNode;
-    disabled?: boolean;
-} & Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & DataTrackingId & import('react').RefAttributes<HTMLButtonElement>>;
+export type MenuProps = Omit<ButtonProps, "icon"> & MenuCommonProps & {
+    /**
+     * Icon to display on the menu button
+     */
+    icon?: IconProps["svg"];
+} & DataTrackingId;
 /**
  * Menu component for displaying dropdown menus with navigation and actions.
  *
@@ -51,7 +27,6 @@ export declare const MenuItem: import('react').ForwardRefExoticComponent<{
  * - Fully accessible with proper ARIA attributes
  * - Popover API support with legacy fallback
  * - Outside click detection and handling
- * - Automatic tracking ID generation for analytics
  *
  * @example
  * <Menu label="Edit">
@@ -65,12 +40,13 @@ export declare const MenuItem: import('react').ForwardRefExoticComponent<{
  *       <Menu.Item label=".jpg" onClick={() => console.log('Copy as JPG')} />
  *     </Menu>
  *   </Menu>
- * </Menu>
  */
-export declare const Menu: {
-    (props: MenuProps): import("react/jsx-runtime").JSX.Element;
-    displayName: string | undefined;
-} & {
+export declare const Menu: import('react').ForwardRefExoticComponent<Omit<ButtonProps, "icon"> & MenuCommonProps & {
+    /**
+     * Icon to display on the menu button
+     */
+    icon?: IconProps["svg"];
+} & DataTrackingId & import('react').RefAttributes<HTMLElement>> & {
     /**
      * MenuItem component for individual menu options.
      *
@@ -82,8 +58,6 @@ export declare const Menu: {
      * - Fully accessible with proper ARIA attributes
      * - Focus management and tab index handling
      * - Click and mouse enter event handling
-     * - Legacy popover support with fallback
-     * - Automatic tracking ID generation for analytics
      *
      * @example
      * <Menu.Item
@@ -93,8 +67,8 @@ export declare const Menu: {
      * />
      */
     Item: import('react').ForwardRefExoticComponent<{
-        icon?: import('@servicetitan/hammer-react').IconProps["svg"];
+        icon?: IconProps["svg"];
         label: import('react').ReactNode;
         disabled?: boolean;
-    } & Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & DataTrackingId & import('react').RefAttributes<HTMLButtonElement>>;
+    } & Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & DataTrackingId & import('react').ButtonHTMLAttributes<HTMLButtonElement> & import('react').RefAttributes<HTMLButtonElement>>;
 };

package/dist/components/Menu/MenuItem.d.ts

@@ -0,0 +1,57 @@
+import { ButtonHTMLAttributes, ComponentPropsWithoutRef, ReactNode } from 'react';
+import { DataTrackingId } from '../../types';
+import { IconProps } from '../Icon';
+/**
+ * Props for the MenuItem component
+ * @extends ComponentPropsWithoutRef<"button">
+ */
+export type MenuItemProps = {
+    /**
+     * Icon to display next to the menu item label
+     */
+    icon?: IconProps["svg"];
+    /**
+     * The label text or content for the menu item
+     */
+    label: ReactNode;
+    /**
+     * Whether the menu item is disabled
+     * @default false
+     */
+    disabled?: boolean;
+} & ComponentPropsWithoutRef<"button"> & DataTrackingId;
+/**
+ * MenuItem component for individual menu options within a Menu.
+ *
+ * Features:
+ * - Supports icons and labels
+ * - Keyboard navigation support
+ * - Disabled state handling
+ * - Automatic menu closing on selection
+ * - Fully accessible with proper ARIA attributes
+ * - Focus management and tab index handling
+ * - Click and mouse enter event handling
+ * - Legacy popover support with fallback
+ *
+ * @example
+ * <MenuItem
+ *   label="Edit Profile"
+ *   icon={EditIcon}
+ *   onClick={() => console.log('Edit profile clicked')}
+ * />
+ */
+export declare const MenuItem: import('react').ForwardRefExoticComponent<{
+    /**
+     * Icon to display next to the menu item label
+     */
+    icon?: IconProps["svg"];
+    /**
+     * The label text or content for the menu item
+     */
+    label: ReactNode;
+    /**
+     * Whether the menu item is disabled
+     * @default false
+     */
+    disabled?: boolean;
+} & Omit<import('react').DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & DataTrackingId & ButtonHTMLAttributes<HTMLButtonElement> & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/components/Menu/index.d.ts

@@ -1,2 +1,4 @@
 export * from './Menu';
+export * from './MenuItem';
+export * from './types';
 export { Menu as default } from './Menu';

package/dist/components/Menu/internal/MenuContext.d.ts

@@ -0,0 +1,15 @@
+import { MenuProps } from '../Menu';
+/**
+ * Context props for Menu components
+ */
+export type MenuContextProps = {
+    /**
+     * Function to close the root menu
+     */
+    closeRootMenu: () => void;
+    /**
+     * Whether auto height is disabled
+     */
+    disableAutoHeight: MenuProps["disableAutoHeight"];
+};
+export declare const MenuContext: import('react').Context<MenuContextProps | null>;

package/dist/components/Menu/internal/MenuLegacy/MenuLegacy.d.ts

@@ -0,0 +1,50 @@
+import { HTMLProps, AriaAttributes, ReactElement } from 'react';
+import { ButtonProps } from '../../../Button';
+import { IconProps } from '../../../Icon';
+export type PopoverControlProps = {
+    disableAutoHeight?: boolean;
+    root?: HTMLElement | React.MutableRefObject<HTMLElement | null> | null;
+    placement?: "bottom-start" | "top-start" | "bottom-end" | "top-end";
+};
+type TriggerReturnProps = {
+    "data-open"?: boolean;
+    "data-focus-inside"?: boolean;
+    "aria-controls"?: AriaAttributes["aria-controls"];
+    "aria-expanded"?: AriaAttributes["aria-expanded"];
+    "aria-haspopup"?: AriaAttributes["aria-haspopup"];
+    id?: string;
+    onClick?: () => void;
+    onFocus?: () => void;
+    onKeyDown?: () => void;
+    onKeyUp?: () => void;
+    onMouseDown?: () => void;
+    onPointerDown?: () => void;
+    ref?: ((instance: HTMLElement | null) => void) | null;
+};
+type DefaultTriggerProps = {
+    trigger?: never;
+    open?: boolean;
+    icon?: IconProps["svg"];
+} & ({
+    label: string;
+} | {
+    "aria-label": string;
+} | {
+    "aria-labellbedby": string;
+}) & Omit<ButtonProps, "icon"> & PopoverControlProps;
+type CustomTriggerProps = {
+    trigger: (props: TriggerReturnProps) => ReactElement;
+    icon?: IconProps["svg"];
+    label?: never;
+    open?: boolean;
+} & Omit<HTMLProps<any>, "ref"> & PopoverControlProps;
+export type MenuLegacyProps = DefaultTriggerProps | CustomTriggerProps;
+export declare const MenuLegacyComponent: import('react').ForwardRefExoticComponent<MenuLegacyProps & import('react').RefAttributes<HTMLElement>>;
+export declare const MenuLegacy: import('react').ForwardRefExoticComponent<MenuLegacyProps & import('react').RefAttributes<HTMLElement>> & {
+    Item: import('react').ForwardRefExoticComponent<{
+        icon?: IconProps["svg"];
+        label: import('react').ReactNode;
+        disabled?: boolean;
+    } & Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import('react').ButtonHTMLAttributes<HTMLButtonElement> & import('react').RefAttributes<HTMLButtonElement>>;
+};
+export {};

package/dist/components/Menu/internal/MenuLegacy/MenuLegacyContext.d.ts

@@ -0,0 +1,9 @@
+import { Dispatch, HTMLProps, SetStateAction } from 'react';
+import { PopoverControlProps } from './MenuLegacy';
+export declare const MenuLegacyContext: import('react').Context<{
+    getItemProps: (userProps?: HTMLProps<HTMLElement>) => Record<string, unknown>;
+    activeIndex: number | null;
+    setActiveIndex?: Dispatch<SetStateAction<number | null>>;
+    setHasFocusInside?: Dispatch<SetStateAction<boolean>>;
+    isOpen: boolean;
+} & PopoverControlProps>;

package/dist/components/Menu/internal/MenuLegacy/MenuLegacyItem.d.ts

@@ -0,0 +1,12 @@
+import { ButtonHTMLAttributes, ComponentPropsWithoutRef, ReactNode } from 'react';
+import { IconProps } from '../../../Icon';
+export type MenuLegacyItemProps = {
+    icon?: IconProps["svg"];
+    label: ReactNode;
+    disabled?: boolean;
+} & ComponentPropsWithoutRef<"button">;
+export declare const MenuLegacyItem: import('react').ForwardRefExoticComponent<{
+    icon?: IconProps["svg"];
+    label: ReactNode;
+    disabled?: boolean;
+} & Omit<import('react').DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & ButtonHTMLAttributes<HTMLButtonElement> & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/components/Menu/internal/MenuLegacy/index.d.ts

@@ -0,0 +1,3 @@
+export { MenuLegacy, type MenuLegacyProps } from './MenuLegacy';
+export { MenuLegacyItem, type MenuLegacyItemProps } from './MenuLegacyItem';
+export type { LayoutUtilProps } from '../../../../types';

package/dist/components/Menu/internal/MenuNested.d.ts

@@ -0,0 +1,42 @@
+import { ComponentPropsWithoutRef } from 'react';
+import { IconProps } from '../../Icon';
+import { MenuCommonProps } from '../types';
+/**
+ * Props for the MenuNested component
+ * @extends ComponentPropsWithoutRef<"button">
+ * @extends MenuCommonProps
+ */
+export type MenuNestedProps = ComponentPropsWithoutRef<"button"> & MenuCommonProps & {
+    /**
+     * Icon to display on the nested menu button
+     */
+    icon?: IconProps["svg"];
+};
+/**
+ * MenuNested component for creating nested submenus within a Menu.
+ *
+ * Features:
+ * - Hover-based menu opening and closing
+ * - Automatic positioning with fallback strategies
+ * - Keyboard navigation with arrow keys
+ * - Scroll indicators for overflow content
+ * - Automatic height adjustment
+ * - Focus management and accessibility
+ * - Popover API support with legacy fallback
+ * - Smooth transitions and animations
+ * - Context integration with parent menus
+ *
+ * @example
+ * <Menu label="Edit">
+ *   <Menu.Item label="Cut" onClick={() => console.log('Cut clicked')} />
+ *   <Menu label="Copy as">
+ *     <Menu.Item label="Text" onClick={() => console.log('Copy as Text')} />
+ *     <Menu.Item label="Video" onClick={() => console.log('Copy as Video')} />
+ *     <Menu label="Image">
+ *       <Menu.Item label=".png" onClick={() => console.log('Copy as PNG')} />
+ *       <Menu.Item label=".jpg" onClick={() => console.log('Copy as JPG')} />
+ *     </Menu>
+ *   </Menu>
+ * </Menu>
+ */
+export declare const MenuNested: (props: MenuNestedProps) => import("react/jsx-runtime").JSX.Element;