@servicetitan/anvil2 1.44.2 → 1.45.1

package/dist/components/Combobox/ComboboxTypes.d.ts

@@ -0,0 +1,374 @@
+import { UseComboboxProps as UseDownshiftComboboxProps, UseMultipleSelectionProps as UseDownshiftMultipleSelectionProps, UseComboboxReturnValue as UseDownshiftComboboxReturnValue, UseComboboxState as UseDownshiftComboboxState, UseMultipleSelectionState as UseDownshiftMultipleSelectionState, UseSelectProps as UseDownshiftSelectProps, UseSelectReturnValue as UseDownshiftSelectReturnValue, UseSelectState as UseDownshiftSelectState, UseMultipleSelectionReturnValue as UseDownshiftMultipleSelectionReturnValue } from 'downshift';
+import { DataTrackingId, DistributiveOmit, LayoutUtilProps } from '../../types';
+import { ComponentPropsWithoutRef, Dispatch, MutableRefObject, ReactNode, SetStateAction } from 'react';
+import { ComboboxGroupByValue } from './internal/ComboboxGroupContext';
+import { MatchSorterOptions } from 'match-sorter';
+import { ComboboxContentOptionsProps } from './ComboboxContent';
+import { LabelProps } from '../../internal/components/Label/Label';
+import { ChipProps } from '../Chip';
+import { IconProps } from '../Icon';
+import { AvatarProps } from '../Avatar';
+import { FlexProps } from '../Flex';
+import { TextFieldProps } from '../TextField/internal/TextField';
+/**
+ * Props for the useInfiniteCombobox hook
+ */
+export type UseInfiniteComboboxProps<Item> = {
+    /** Function to fetch items for the current page */
+    query: (params: {
+        page: number;
+        inputValue: string;
+        selectedItem: Item | null;
+        selectedItems: Item[];
+    }) => Promise<Item[]>;
+    /** Initial page number to start from */
+    initialPage?: number;
+    /** Initial loading state */
+    initialLoading?: boolean;
+    /** Initial input value */
+    initialInputValue?: ComboboxProps["initialInputValue"];
+    /** Default input value */
+    defaultInputValue?: ComboboxProps["defaultInputValue"];
+    /** Initial selected item */
+    initialSelectedItem?: ComboboxProps<Item>["initialSelectedItem"];
+    /** Default selected item */
+    defaultSelectedItem?: ComboboxProps<Item>["defaultSelectedItem"];
+    /** Initial selected items for multiple selection */
+    initialSelectedItems?: UseDownshiftMultipleSelectionProps<Item>["initialSelectedItems"];
+    /** Default selected items for multiple selection */
+    defaultSelectedItems?: UseDownshiftMultipleSelectionProps<Item>["defaultSelectedItems"];
+    /** Whether to trigger query on input value change */
+    updateOnInputValueChange?: boolean;
+    /** Whether to trigger query on selected item change */
+    updateOnSelectedItemChange?: boolean;
+    /** Whether to trigger query on selected items change */
+    updateOnSelectedItemsChange?: boolean;
+    /** Whether to trigger query on first render */
+    queryOnFirstRender?: boolean;
+    /** Custom function to determine when to trigger query */
+    shouldTriggerQuery?: (element: EventTarget & HTMLElement) => boolean;
+} & ({
+    queryInitialItems?: never;
+    /** Initial items array (mutually exclusive with queryInitialItems) */
+    initialItems?: Item[];
+} | {
+    /** Function to get initial items (mutually exclusive with initialItems) */
+    queryInitialItems?: () => Item[];
+    initialItems?: never;
+});
+/**
+ * Props for the ComboboxContext component
+ * @extends Required<Pick<UseDownshiftComboboxProps<Item> | UseDownshiftSelectProps<Item>, "items" | "itemToString" | "itemToKey" | "selectedItem">>
+ * @extends Pick<UseDownshiftComboboxReturnValue<Item> | UseDownshiftSelectReturnValue<Item>, "getToggleButtonProps" | "getItemProps" | "getLabelProps" | "getMenuProps" | "closeMenu" | "selectItem" | "highlightedIndex" | "isOpen" | "inputValue">
+ * @extends Partial<Pick<UseDownshiftComboboxReturnValue<Item>, "getInputProps">>
+ * @extends Partial<Pick<UseDownshiftMultipleSelectionReturnValue<Item>, "getSelectedItemProps" | "getDropdownProps" | "addSelectedItem" | "removeSelectedItem" | "setSelectedItems" | "reset">>
+ * @extends Partial<Pick<UseDownshiftComboboxReturnValue<Item> | UseDownshiftSelectReturnValue<Item>, "reset">>
+ * @extends LayoutUtilProps
+ */
+export type ComboboxContextProps<Item = any> = Required<Pick<UseDownshiftComboboxProps<Item> | UseDownshiftSelectProps<Item>, "items" | "itemToString" | "itemToKey" | "selectedItem">> & Pick<UseDownshiftComboboxReturnValue<Item> | UseDownshiftSelectReturnValue<Item>, "getToggleButtonProps" | "getItemProps" | "getLabelProps" | "getMenuProps" | "closeMenu" | "selectItem" | "highlightedIndex" | "isOpen" | "inputValue"> & Partial<Pick<UseDownshiftComboboxReturnValue<Item>, "getInputProps">> & Partial<Pick<UseDownshiftMultipleSelectionReturnValue<Item>, "getSelectedItemProps" | "getDropdownProps" | "addSelectedItem" | "removeSelectedItem" | "setSelectedItems" | "reset">> & Partial<Pick<UseDownshiftComboboxReturnValue<Item> | UseDownshiftSelectReturnValue<Item>, "reset">> & LayoutUtilProps & {
+    disableClearSelection?: boolean;
+    isReadOnly?: boolean;
+    isDisabled?: boolean;
+    /** @deprecated to be removed on next major - this is replaced by Combobox's disabled and readOnly props */
+    setIsReadOnly: Dispatch<SetStateAction<undefined | boolean>>;
+    /** @deprecated to be removed on next major - this is replaced by Combobox's disabled and readOnly props */
+    setIsDisabled: Dispatch<SetStateAction<undefined | boolean>>;
+    hasDisabledPopover: boolean;
+    setHasDisabledPopover: Dispatch<SetStateAction<boolean>>;
+    hasEmpty: boolean;
+    setHasEmpty: Dispatch<SetStateAction<boolean>>;
+    multiple: boolean;
+    select: boolean;
+    selectedItems: Item[];
+    disabledItems: Item[];
+    setDisabledItems: Dispatch<SetStateAction<Item[]>>;
+    loading: boolean;
+    referenceRef: MutableRefObject<HTMLDivElement | null>;
+    contentRef: MutableRefObject<HTMLDivElement | null>;
+    hasAddNew?: boolean;
+    setHasAddNew?: Dispatch<SetStateAction<boolean>>;
+    onSelectItemAddNew?: (inputValue: UseDownshiftComboboxReturnValue<Item>["inputValue"]) => void;
+    setOnSelectItemAddNew?: Dispatch<SetStateAction<((inputValue: UseDownshiftComboboxReturnValue<Item>["inputValue"]) => void) | undefined>>;
+    hasExactMatch?: boolean;
+    setHasExactMatch?: Dispatch<SetStateAction<boolean>>;
+    groupBy?: string;
+    groupToString?: (groupByValue: ComboboxGroupByValue) => string;
+    groups: {
+        key: ComboboxGroupByValue;
+        label: string;
+        items: Item[];
+    }[];
+};
+/**
+ * Props for shared functionality across all combobox variants
+ * @extends LayoutUtilProps
+ * @extends Pick<ComponentPropsWithoutRef<"div">, "className" | "style">
+ */
+type SharedProps<Item> = LayoutUtilProps & Pick<ComponentPropsWithoutRef<"div">, "className" | "style"> & {
+    children?: ReactNode;
+    /**
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * @default false
+     */
+    readOnly?: boolean;
+    /**
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * @default false
+     */
+    disableCloseOnClickOutside?: boolean;
+    /**
+     * @default false
+     */
+    disableMatchReferenceWidth?: boolean;
+    /**
+     * @deprecated to be removed on next major
+     * This is not needed anymore as the Popover API is used.
+     * Popover API uses top-layer for its popover content.
+     */
+    root?: HTMLElement | React.MutableRefObject<HTMLElement | null> | null;
+    /**
+     * @default false
+     */
+    open?: boolean;
+    /**
+     * @default false
+     */
+    disableCloseOnSelectItem?: boolean;
+    onStateChange?: (changes: {
+        type: string;
+    } & Partial<UseDownshiftComboboxState<Item>> & Partial<UseDownshiftMultipleSelectionState<Item>> & Partial<UseDownshiftSelectState<Item>>) => void;
+    minPopoverHeight?: string | number;
+    groupBy?: string;
+    groupToString?: (groupByValue: ComboboxGroupByValue) => string;
+    /** Accepts groupBy values `a` and `b` -- must return a negative if `a` before `b` and a positive if `b` before `a`.
+     * @default {func} (a, b) => `${a}`.localeCompare(`${b}`)
+     */
+    groupSorter?: (a: ComboboxGroupByValue, b: ComboboxGroupByValue) => number;
+};
+/**
+ * Props for combobox-specific functionality
+ * @extends Omit<UseDownshiftComboboxProps<Item>, "onStateChange" | "onInputValueChange">
+ */
+type SharedComboboxProps<Item> = Omit<UseDownshiftComboboxProps<Item>, "onStateChange" | "onInputValueChange"> & {
+    filterOptions?: MatchSorterOptions<Item>;
+    disableFilter?: boolean;
+    /**
+     * @deprecated Please use `Combobox.SearchField`'s `onChange` method instead
+     */
+    onInputValueChange?: UseDownshiftComboboxProps<Item>["onInputValueChange"];
+};
+/**
+ * Props for select-specific functionality
+ * @extends Omit<UseDownshiftSelectProps<Item>, "onStateChange" | "onInputValueChange">
+ */
+type SharedSelectProps<Item> = Omit<UseDownshiftSelectProps<Item>, "onStateChange" | "onInputValueChange">;
+/**
+ * Props for single selection functionality
+ */
+type SharedSingleProps<Item> = {
+    multiple?: never;
+    onChange?: Dispatch<SetStateAction<Item | null>> | ((arg: Item | null) => void);
+};
+/**
+ * Props for multiple selection functionality
+ * @extends Partial<Pick<UseDownshiftMultipleSelectionProps<Item>, "onSelectedItemsChange" | "initialSelectedItems" | "initialActiveIndex" | "defaultSelectedItems" | "defaultActiveIndex" | "activeIndex" | "selectedItems">>
+ */
+type SharedMultipleProps<Item> = {
+    multiple: true;
+    onChange?: Dispatch<SetStateAction<Item[] | null>> | ((arg: Item[] | null) => void);
+} & Partial<Pick<UseDownshiftMultipleSelectionProps<Item>, "onSelectedItemsChange" | "initialSelectedItems" | "initialActiveIndex" | "defaultSelectedItems" | "defaultActiveIndex" | "activeIndex" | "selectedItems">>;
+/**
+ * Props for single select functionality
+ * @extends SharedProps<Item>
+ * @extends SharedSelectProps<Item>
+ * @extends SharedSingleProps<Item>
+ */
+export type SelectSingleProps<Item> = SharedProps<Item> & SharedSelectProps<Item> & SharedSingleProps<Item> & {
+    disableClearSelection?: boolean;
+};
+/**
+ * Props for multiple select functionality
+ * @extends SharedProps<Item>
+ * @extends SharedSelectProps<Item>
+ * @extends SharedMultipleProps<Item>
+ */
+export type SelectMultipleProps<Item> = SharedProps<Item> & SharedSelectProps<Item> & SharedMultipleProps<Item>;
+/**
+ * Props for single combobox functionality
+ * @extends SharedProps<Item>
+ * @extends SharedComboboxProps<Item>
+ * @extends SharedSingleProps<Item>
+ */
+export type ComboboxSingleProps<Item> = SharedProps<Item> & SharedComboboxProps<Item> & SharedSingleProps<Item>;
+/**
+ * Props for multiple combobox functionality
+ * @extends Omit<SharedProps<Item>, "open" | "disableCloseOnSelectItem">
+ * @extends SharedComboboxProps<Item>
+ * @extends SharedMultipleProps<Item>
+ */
+export type ComboboxMultipleProps<Item> = Omit<SharedProps<Item>, "open" | "disableCloseOnSelectItem"> & SharedComboboxProps<Item> & SharedMultipleProps<Item> & ({
+    disableClearInputValueOnSelectItem: true;
+    disableCloseOnSelectItem: true;
+    open?: boolean;
+} | {
+    disableClearInputValueOnSelectItem: true;
+    open: true;
+    disableCloseOnSelectItem?: boolean;
+} | {
+    disableClearInputValueOnSelectItem?: never;
+    disableCloseOnSelectItem?: boolean;
+    open?: boolean;
+});
+/**
+ * Props for the Combobox component
+ * @property {Item[]} items - Array of items to display in the combobox
+ * @property {(item: Item | null) => string} itemToString - Function to convert item to string
+ * @property {(item: Item) => string | number} itemToKey - Function to get unique key for item
+ * @property {Item | null} [selectedItem] - Currently selected item
+ * @property {Item[] | null} [selectedItems] - Currently selected items for multiple selection
+ * @property {boolean} [multiple] - Enable multiple selection mode
+ * @property {boolean} [loading] - Show loading state
+ * @property {Object} [filterOptions] - Options for filtering items
+ * @property {boolean} [disableFilter] - Disable automatic filtering
+ * @property {string} [groupBy] - Property to group items by
+ * @property {(groupValue: any) => string} [groupToString] - Function to convert group value to string
+ * @property {(a: any, b: any) => number} [groupSorter] - Function to sort groups
+ * @extends DataTrackingId
+ */
+export type ComboboxProps<Item = any> = ComboboxSingleProps<Item> | ComboboxMultipleProps<Item>;
+type SelectProps<Item = any> = SelectSingleProps<Item> | SelectMultipleProps<Item>;
+/**
+ * Props for the ComboboxSelect component
+ * @property {Item[]} items - Array of items to display in the select
+ * @property {(item: Item | null) => string} itemToString - Function to convert item to string
+ * @property {(item: Item) => string | number} itemToKey - Function to get unique key for item
+ * @property {Item | null} [selectedItem] - Currently selected item
+ * @property {Item[] | null} [selectedItems] - Currently selected items for multiple selection
+ * @property {boolean} [multiple] - Enable multiple selection mode
+ * @property {boolean} [loading] - Show loading state
+ * @property {string} [groupBy] - Property to group items by
+ * @property {(groupValue: any) => string} [groupToString] - Function to convert group value to string
+ * @extends DataTrackingId
+ */
+export type ComboboxSelectProps<Item> = SelectProps<Item>;
+/**
+ * Props for the ComboboxContent component
+ * @property {({ items: Item[], inputValue: string }) => ReactNode} children - Function that receives items and input value and renders content
+ * @property {boolean} [disablePopover] - Whether to disable popover behavior and render inline
+ */
+export type ComboboxContentProps<Item> = Omit<ComponentPropsWithoutRef<"div">, "children"> & {
+    /** Render function that receives combobox state and returns content */
+    children?: ({ items, inputValue, selectedItem, getMenuProps, getItemProps, }: Pick<UseDownshiftComboboxProps<Item> | UseDownshiftSelectProps<Item>, "items"> & Pick<UseDownshiftComboboxReturnValue<Item> | UseDownshiftSelectReturnValue<Item>, "getMenuProps" | "getItemProps" | "inputValue" | "selectedItem"> & {
+        listProps: ReturnType<UseDownshiftComboboxReturnValue<Item>["getMenuProps"] | UseDownshiftSelectReturnValue<Item>["getMenuProps"]> & {
+            style: any;
+        };
+        options: ComboboxContentOptionsProps<Item>[];
+    }) => ReactNode;
+    /** Whether to disable popover behavior and render inline */
+    disablePopover?: boolean;
+};
+/**
+ * Props for the ComboboxTrigger component
+ * @template Item - The type of items in the combobox
+ */
+export type ComboboxTriggerProps<Item = any> = Omit<TextFieldProps, "disabled" | "readOnly" | "showCounter"> & Pick<LabelProps, "required" | "moreInfo" | "openMoreInfo"> & LayoutUtilProps & {
+    /**
+     * Should be a positive integer.
+     */
+    maxRows?: number;
+    /** Allows Combobox/Select to display custom-colored Chips */
+    selectedItemProps?: (item: Item) => Partial<ChipProps>;
+} & {
+    /** @deprecated use disabled in <Combobox /> */
+    disabled?: boolean;
+    /** @deprecated use readOnly in <Combobox /> */
+    readOnly?: boolean;
+};
+/**
+ * Props for the ComboboxSearchField component
+ * @property {string} label - Label for the search field
+ * @property {string} [placeholder] - Placeholder text
+ * @property {string} [description] - Helper text description
+ * @property {string} [moreInfo] - Additional information text
+ * @property {boolean} [required] - Mark field as required
+ * @property {string | { icon: IconProps } | { avatar: AvatarProps }} [prefix] - Prefix content (string, icon, or avatar)
+ * @property {(item: Item) => Partial<ChipProps>} [selectedItemProps] - Allows Combobox to display custom-colored Chips
+ * @extends DataTrackingId
+ */
+export type ComboboxSearchFieldProps = DistributiveOmit<ComboboxTriggerProps, "prefix"> & DataTrackingId & {
+    prefix?: string | {
+        icon: DistributiveOmit<IconProps, "size">;
+    } | {
+        avatar: DistributiveOmit<AvatarProps, "size">;
+    };
+};
+/**
+ * Props for the ComboboxSelectTrigger component
+ * @property {string} label - Label for the select trigger
+ * @property {string} [placeholder] - Placeholder text
+ * @property {string} [description] - Helper text description
+ * @property {string} [moreInfo] - Additional information text
+ * @property {boolean} [required] - Mark field as required
+ * @property {string | { icon: IconProps } | { avatar: AvatarProps }} [prefix] - Prefix content (string, icon, or avatar)
+ * @property {(item: Item) => Partial<ChipProps>} [selectedItemProps] - Allows Combobox to display custom-colored Chips
+ * @extends DataTrackingId
+ */
+export type ComboboxSelectTriggerProps = DistributiveOmit<ComboboxTriggerProps, "prefix"> & DataTrackingId & {
+    prefix?: string | {
+        icon: DistributiveOmit<IconProps, "size">;
+    } | {
+        avatar: DistributiveOmit<AvatarProps, "size">;
+    };
+};
+/**
+ * Props for the ComboboxList component
+ * @property {ReactNode} children - List items to render
+ */
+export type ComboboxListProps = ComponentPropsWithoutRef<"ul" | "div"> & {
+    children?: ReactNode;
+};
+type ComboboxItemSharedProps = ComponentPropsWithoutRef<"li" | "div"> & {
+    children?: ReactNode;
+    disabled?: boolean;
+    alignItems?: FlexProps["alignItems"];
+    justifyItems?: FlexProps["justifyItems"];
+    alignContent?: FlexProps["alignContent"];
+    justifyContent?: FlexProps["justifyContent"];
+    placeItems?: FlexProps["placeItems"];
+    placeContent?: FlexProps["placeContent"];
+    gap?: FlexProps["gap"];
+    rowGap?: FlexProps["rowGap"];
+    columnGap?: FlexProps["columnGap"];
+};
+/**
+ * Props for the ComboboxItem component
+ * @property {Item} item - The item to render
+ * @property {number} index - Index of the item in the list
+ * @property {ReactNode} children - Content to render for the item
+ * @property {boolean} [disabled] - Disable the item
+ * @extends DataTrackingId
+ */
+export type ComboboxItemProps<Item> = ComboboxItemSharedProps & {
+    /** The item to render */
+    item: Item;
+    /** The index of the item in the list */
+    index: number;
+} & DataTrackingId;
+/**
+ * Props for the ComboboxItemAddNew component
+ * @property {(inputValue: string) => void} onSelection - Callback when "Add New" is selected
+ * @property {ReactNode} children - Content to render for the "Add New" item
+ * @property {boolean} [disabled] - Disable the "Add New" item
+ * @extends DataTrackingId
+ */
+export type ComboboxItemAddNewProps<Item> = ComboboxItemSharedProps & {
+    /** Callback when the "Add New" item is selected */
+    onSelection?: (inputValue: UseDownshiftComboboxReturnValue<Item>["inputValue"]) => void;
+} & DataTrackingId;
+export {};

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

@@ -1,3 +1,10 @@
-export * from './Combobox';
-export { Combobox as default } from './Combobox';
-export { useInfiniteCombobox, type UseInfiniteComboboxProps, } from './useInfiniteCombobox';
+export { Combobox as default, Combobox, ComboboxElement } from './Combobox';
+export { useInfiniteCombobox } from './useInfiniteCombobox';
+export { ComboboxSelect } from './ComboboxSelect';
+export { ComboboxContent } from './ComboboxContent';
+export { ComboboxList } from './ComboboxList';
+export { ComboboxItem, ComboboxItemAddNew } from './ComboboxItem';
+export { ComboboxSearchField, ComboboxSelectTrigger } from './ComboboxTrigger';
+export { ComboboxEmpty, type ComboboxEmptyProps } from './ComboboxEmpty';
+export { type ComboboxSingleProps, type ComboboxMultipleProps, type ComboboxProps, type ComboboxSelectProps, type ComboboxContentProps, type ComboboxSearchFieldProps, type ComboboxSelectTriggerProps, type ComboboxListProps, type ComboboxItemProps, type ComboboxItemAddNewProps, type SelectSingleProps, type SelectMultipleProps, type UseInfiniteComboboxProps, } from './ComboboxTypes';
+export type { LayoutUtilProps } from '../../types';

package/dist/components/Combobox/internal/ComboboxContext.d.ts

@@ -0,0 +1,8 @@
+import { ComboboxContextProps } from '../ComboboxTypes';
+export declare const ComboboxContext: import('react').Context<ComboboxContextProps | null>;
+/**
+ * Hook to access the Combobox context
+ * @returns The Combobox context value
+ * @throws Error if used outside of a Combobox component
+ */
+export declare const useCombobox: <Item = any>() => ComboboxContextProps<Item>;

package/dist/components/Combobox/internal/ComboboxGroupContext.d.ts

@@ -0,0 +1,8 @@
+export type ComboboxGroupByValue = string | number;
+export type ComboboxGroupContextType = {
+    key: ComboboxGroupByValue;
+    label: string;
+} | null;
+export declare const ComboboxGroupContext: import('react').Context<ComboboxGroupContextType>;
+export declare const ComboboxGroupProvider: import('react').Provider<ComboboxGroupContextType>;
+export declare const useComboboxGroupContext: () => ComboboxGroupContextType;

package/dist/components/Combobox/internal/ComboboxLegacy/ComboboxLegacy.d.ts

@@ -0,0 +1,131 @@
+import { ComponentPropsWithoutRef, Dispatch, SetStateAction, ReactNode, MutableRefObject } from 'react';
+import { UseComboboxProps as UseDownshiftComboboxLegacyProps, UseMultipleSelectionProps as UseDownshiftMultipleSelectionProps, UseComboboxReturnValue as UseDownshiftComboboxLegacyReturnValue, UseMultipleSelectionReturnValue as UseDownshiftMultipleSelectionReturnValue, UseSelectProps as UseDownshiftSelectProps, UseSelectReturnValue as UseDownshiftSelectReturnValue } from 'downshift';
+import { MatchSorterOptions } from 'match-sorter';
+import { LayoutUtilProps } from '../../../../types';
+export declare const ADD_NEW: unique symbol;
+export type ComboboxLegacyContextProps<Item = any> = Required<Pick<UseDownshiftComboboxLegacyProps<Item> | UseDownshiftSelectProps<Item>, "items" | "itemToString" | "itemToKey" | "selectedItem">> & Pick<UseDownshiftComboboxLegacyReturnValue<Item> | UseDownshiftSelectReturnValue<Item>, "getToggleButtonProps" | "getItemProps" | "getLabelProps" | "getMenuProps" | "closeMenu" | "selectItem" | "highlightedIndex" | "isOpen" | "inputValue"> & Partial<Pick<UseDownshiftComboboxLegacyReturnValue<Item>, "getInputProps">> & Partial<Pick<UseDownshiftMultipleSelectionReturnValue<Item>, "getSelectedItemProps" | "getDropdownProps" | "addSelectedItem" | "removeSelectedItem" | "setSelectedItems" | "reset">> & Partial<Pick<UseDownshiftComboboxLegacyReturnValue<Item> | UseDownshiftSelectReturnValue<Item>, "reset">> & LayoutUtilProps & {
+    disableClearSelection?: boolean;
+    isReadOnly?: boolean;
+    isDisabled?: boolean;
+    /** @deprecated to be removed on next major - this is replaced by ComboboxLegacy's disabled and readOnly props */
+    setIsReadOnly: Dispatch<SetStateAction<undefined | boolean>>;
+    /** @deprecated to be removed on next major - this is replaced by ComboboxLegacy's disabled and readOnly props */
+    setIsDisabled: Dispatch<SetStateAction<undefined | boolean>>;
+    hasDisabledPopover: boolean;
+    setHasDisabledPopover: Dispatch<SetStateAction<boolean>>;
+    hasEmpty: boolean;
+    setHasEmpty: Dispatch<SetStateAction<boolean>>;
+    multiple: boolean;
+    select: boolean;
+    selectedItems: Item[];
+    disabledItems: Item[];
+    setDisabledItems: Dispatch<SetStateAction<Item[]>>;
+    loading: boolean;
+    referenceRef: MutableRefObject<HTMLDivElement | null>;
+    contentRef: MutableRefObject<HTMLDivElement | null>;
+    hasAddNew?: boolean;
+    setHasAddNew?: Dispatch<SetStateAction<boolean>>;
+    onSelectItemAddNew?: (inputValue: UseDownshiftComboboxLegacyReturnValue<Item>["inputValue"]) => void;
+    setOnSelectItemAddNew?: Dispatch<SetStateAction<((inputValue: UseDownshiftComboboxLegacyReturnValue<Item>["inputValue"]) => void) | undefined>>;
+    hasExactMatch?: boolean;
+    setHasExactMatch?: Dispatch<SetStateAction<boolean>>;
+};
+export declare const ComboboxLegacyContext: import('react').Context<ComboboxLegacyContextProps<any> | null>;
+export declare const useComboboxLegacy: <Item = any>() => ComboboxLegacyContextProps<Item>;
+type SharedProps = LayoutUtilProps & Pick<ComponentPropsWithoutRef<"div">, "className" | "style"> & {
+    children?: ReactNode;
+    /**
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * @default false
+     */
+    readOnly?: boolean;
+    /**
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * @default false
+     */
+    disableCloseOnClickOutside?: boolean;
+    /**
+     * @default false
+     */
+    disableMatchReferenceWidth?: boolean;
+    root?: HTMLElement | React.MutableRefObject<HTMLElement | null> | null;
+    /**
+     * @default false
+     */
+    open?: boolean;
+    /**
+     * @default false
+     */
+    disableCloseOnSelectItem?: boolean;
+};
+type SharedComboboxLegacyProps<Item> = Omit<UseDownshiftComboboxLegacyProps<Item>, "onStateChange" | "onInputValueChange"> & {
+    filterOptions?: MatchSorterOptions<Item>;
+    /**
+     * @deprecated Please use `ComboboxLegacy.SearchField`'s `onChange` method instead
+     */
+    onInputValueChange?: UseDownshiftComboboxLegacyProps<Item>["onInputValueChange"];
+};
+type SharedSelectProps<Item> = Omit<UseDownshiftSelectProps<Item>, "onStateChange" | "onInputValueChange">;
+type SharedSingleProps<Item> = {
+    multiple?: never;
+    onChange?: Dispatch<SetStateAction<Item | null>> | ((arg: Item | null) => void);
+};
+type SharedMultipleProps<Item> = {
+    multiple: true;
+    onChange?: Dispatch<SetStateAction<Item[] | null>> | ((arg: Item[] | null) => void);
+} & Partial<Pick<UseDownshiftMultipleSelectionProps<Item>, "onSelectedItemsChange" | "initialSelectedItems" | "initialActiveIndex" | "defaultSelectedItems" | "defaultActiveIndex" | "activeIndex" | "selectedItems">>;
+type SelectSingleProps<Item> = SharedProps & SharedSelectProps<Item> & SharedSingleProps<Item> & {
+    disableClearSelection?: boolean;
+};
+type SelectMultipleProps<Item> = SharedProps & SharedSelectProps<Item> & SharedMultipleProps<Item>;
+type ComboboxLegacySingleProps<Item> = SharedProps & SharedComboboxLegacyProps<Item> & SharedSingleProps<Item>;
+type ComboboxLegacyMultipleProps<Item> = Omit<SharedProps, "open" | "disableCloseOnSelectItem"> & SharedComboboxLegacyProps<Item> & SharedMultipleProps<Item> & ({
+    disableClearInputValueOnSelectItem: true;
+    disableCloseOnSelectItem: true;
+    open?: boolean;
+} | {
+    disableClearInputValueOnSelectItem: true;
+    open: true;
+    disableCloseOnSelectItem?: boolean;
+} | {
+    disableClearInputValueOnSelectItem?: never;
+    disableCloseOnSelectItem?: boolean;
+    open?: boolean;
+});
+export type ComboboxLegacyProps<Item = any> = ComboboxLegacySingleProps<Item> | ComboboxLegacyMultipleProps<Item>;
+type SelectProps<Item = any> = SelectSingleProps<Item> | SelectMultipleProps<Item>;
+export type ComboboxLegacySelectProps<Item> = SelectProps<Item>;
+export declare const ComboboxLegacySingle: <Item>(props: ComboboxLegacySingleProps<Item>) => import("react/jsx-runtime").JSX.Element;
+export declare const ComboboxLegacyMultiple: <Item>(props: ComboboxLegacyMultipleProps<Item>) => import("react/jsx-runtime").JSX.Element;
+/**
+ * NOTE: There is a lot of duplicated code here! Here's a list of the /actual/
+ *       differences between select-only and regular combobox to help with
+ *       refactoring this later!
+ *
+ *       1) Using Downshift's `useSelect` hook instead of `useComboboxLegacy`
+ *          - Swapping out the stateChangeTypes for their equivalents
+ *       2) Since there's no input, we don't need to passthrough `getInputProps`
+ *       3) Since we don't do any sorting or filtering, we can remove:
+ *          - onInputValueChange function and prop
+ *            - setInputValue function
+ *          - onIsOpenChange function
+ *          - filterOptions prop
+ *          - internal `items` state and useEffect to keep it in sync
+ *            - useEffect to track first render
+ *       4) Multiple-specific
+ *          - Remove `disableClearInputValueOnSelectItem` prop
+ *          - No need to store `setInputValue` function
+ *          - Remove all state reducer references to `inputValue`
+ *          - Remove `onStateChange` function from `useMultipleSelection`
+ */
+export declare const SelectLegacySingle: <Item>(props: SelectSingleProps<Item>) => import("react/jsx-runtime").JSX.Element;
+export declare const SelectLegacyMultiple: <Item>(props: SelectMultipleProps<Item>) => import("react/jsx-runtime").JSX.Element;
+export declare const ComboboxLegacyElement: <Item>(props: ComboboxLegacyProps<Item>) => import("react/jsx-runtime").JSX.Element;
+export declare const ComboboxLegacySelect: <Item>(props: SelectProps<Item>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Combobox/internal/ComboboxLegacy/ComboboxLegacyContent.d.ts

@@ -0,0 +1,20 @@
+import { ComponentPropsWithoutRef, ReactNode } from 'react';
+import { UseComboboxProps as UseDownshiftComboboxLegacyProps, UseSelectProps as UseDownshiftSelectProps, UseComboboxReturnValue as UseDownshiftComboboxLegacyReturnValue, UseSelectReturnValue as UseDownshiftSelectReturnValue } from 'downshift';
+export type ComboboxLegacyContentOptionsProps<Item> = {
+    optionProps: ReturnType<UseDownshiftComboboxLegacyReturnValue<Item>["getItemProps"]> & {
+        selected: boolean;
+        disabled: boolean;
+    };
+    item: Item;
+    index: number;
+};
+export type ComboboxLegacyContentProps<Item> = Omit<ComponentPropsWithoutRef<"div">, "children"> & {
+    children?: ({ items, inputValue, selectedItem, getMenuProps, getItemProps, }: Pick<UseDownshiftComboboxLegacyProps<Item> | UseDownshiftSelectProps<Item>, "items"> & Pick<UseDownshiftComboboxLegacyReturnValue<Item> | UseDownshiftSelectReturnValue<Item>, "getMenuProps" | "getItemProps" | "inputValue" | "selectedItem"> & {
+        listProps: ReturnType<UseDownshiftComboboxLegacyReturnValue<Item>["getMenuProps"] | UseDownshiftSelectReturnValue<Item>["getMenuProps"]> & {
+            style: any;
+        };
+        options: ComboboxLegacyContentOptionsProps<Item>[];
+    }) => ReactNode;
+    disablePopover?: boolean;
+};
+export declare const ComboboxLegacyContent: <Item = any>({ children, className, disablePopover, ...rest }: ComboboxLegacyContentProps<Item>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Combobox/internal/ComboboxLegacy/ComboboxLegacyEmpty.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export type ComboboxLegacyEmptyProps = {
+    children?: ReactNode;
+};
+export declare const ComboboxLegacyEmpty: <Item = any>({ children, }: ComboboxLegacyEmptyProps) => ReactNode;

package/dist/components/Combobox/internal/ComboboxLegacy/ComboboxLegacyItem.d.ts

@@ -0,0 +1,26 @@
+import { ComponentPropsWithoutRef, ReactNode } from 'react';
+import { UseComboboxReturnValue as UseDownshiftComboboxLegacyReturnValue } from 'downshift';
+import { FlexProps } from '../../../Flex';
+type ComboboxLegacyItemSharedProps = ComponentPropsWithoutRef<"li" | "div"> & {
+    children?: ReactNode;
+    disabled?: boolean;
+    alignItems?: FlexProps["alignItems"];
+    justifyItems?: FlexProps["justifyItems"];
+    alignContent?: FlexProps["alignContent"];
+    justifyContent?: FlexProps["justifyContent"];
+    placeItems?: FlexProps["placeItems"];
+    placeContent?: FlexProps["placeContent"];
+    gap?: FlexProps["gap"];
+    rowGap?: FlexProps["rowGap"];
+    columnGap?: FlexProps["columnGap"];
+};
+export type ComboboxLegacyItemProps<Item> = ComboboxLegacyItemSharedProps & {
+    item: Item;
+    index: number;
+};
+export type ComboboxLegacyItemAddNewProps<Item> = ComboboxLegacyItemSharedProps & {
+    onSelection?: (inputValue: UseDownshiftComboboxLegacyReturnValue<Item>["inputValue"]) => void;
+};
+export declare const ComboboxLegacyItem: <Item = any>({ children, disabled: disabledProp, item, index, alignItems, justifyItems, alignContent, justifyContent, placeItems, placeContent, gap, rowGap, columnGap, ...rest }: ComboboxLegacyItemProps<Item>) => import("react/jsx-runtime").JSX.Element;
+export declare const ComboboxLegacyItemAddNew: <Item = any>({ onSelection, ...props }: ComboboxLegacyItemAddNewProps<Item>) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/Combobox/internal/ComboboxLegacy/ComboboxLegacyList.d.ts

@@ -0,0 +1,5 @@
+import { ComponentPropsWithoutRef, ReactNode } from 'react';
+export type ComboboxLegacyListProps = ComponentPropsWithoutRef<"ul" | "div"> & {
+    children?: ReactNode;
+};
+export declare const ComboboxLegacyList: <Item = any>({ children, ...rest }: ComboboxLegacyListProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Combobox/internal/ComboboxLegacy/ComboboxLegacyMockData.d.ts

@@ -0,0 +1,37 @@
+export type TeammateItem = string;
+export declare const teammates: string[];
+export type AirportItem = {
+    id: number;
+    name: string;
+};
+export declare const airports: ({
+    id: number;
+    name: string;
+    disabled?: undefined;
+} | {
+    id: number;
+    name: string;
+    disabled: boolean;
+})[];
+export declare const tenThousandRows: {
+    id: number;
+    name: string;
+}[];
+export type DummyItem = {
+    name: string;
+    language: string;
+    id: string;
+    bio: string;
+    version: number;
+};
+export declare const dummyJSON: {
+    name: string;
+    language: string;
+    id: string;
+    bio: string;
+    version: number;
+}[];
+export declare const groupedDummyJSON: {
+    name: string;
+    items: any[];
+}[];