@vibe/core 3.58.2-alpha-faacc.0 → 3.58.3

package/dist/components/DropdownNew/Dropdown.types.d.ts

@@ -0,0 +1,232 @@
+import type React from "react";
+import { type ListGroup } from "../BaseList";
+import { type VibeComponentProps } from "../../types";
+import { type BaseListItemData } from "../BaseListItem";
+import { type TooltipProps } from "../Tooltip/Tooltip";
+export type DropdownGroupOption<Item = Record<string, unknown>> = ListGroup<Item>[] | BaseListItemData<Item>[];
+interface MultiSelectSpecifics<Item extends BaseListItemData<Record<string, unknown>>> {
+    /**
+     * If true, the dropdown allows multiple selections.
+     */
+    multi: true;
+    multiline?: boolean;
+    /**
+     * Callback fired when an option is removed in multi-select mode. Only available when multi is true.
+     */
+    onOptionRemove?: (option: BaseListItemData<Item>) => void;
+    /**
+     * The function to call to render the selected value on single select mode.
+     */
+    valueRenderer?: never;
+    /**
+     * The default selected values for multi-select.
+     */
+    defaultValue?: Item[];
+    /**
+     * The controlled selected values for multi-select.
+     */
+    value?: Item[];
+    /**
+     * Callback fired when the selected values change in multi-select mode.
+     */
+    onChange?: (options: BaseListItemData<Item>[]) => void;
+}
+interface SingleSelectSpecifics<Item extends BaseListItemData<Record<string, unknown>>> {
+    /**
+     * If true, the dropdown allows multiple selections. Defaults to false.
+     */
+    multi?: false;
+    /**
+     * If true, the dropdown allows multiple lines of selected items. (Not available for single select)
+     */
+    multiline?: never;
+    /**
+     * Callback fired when an option is removed in multi-select mode. (Not available for single select)
+     */
+    onOptionRemove?: never;
+    /**
+     * The function to call to render the selected value on single select mode.
+     */
+    valueRenderer?: (option: BaseListItemData<Item>) => React.ReactNode;
+    /**
+     * The default selected value for single-select.
+     */
+    defaultValue?: Item;
+    /**
+     * The controlled selected value for single-select.
+     */
+    value?: Item;
+    /**
+     * Callback fired when the selected value changes in single-select mode.
+     */
+    onChange?: (option: BaseListItemData<Item>) => void;
+}
+export type BaseDropdownProps<Item extends BaseListItemData<Record<string, unknown>>> = VibeComponentProps & {
+    /**
+     * The list of options available in the list.
+     */
+    options: DropdownGroupOption<Item>;
+    /**
+     * Props to be passed to the Tooltip component that wraps the dropdown.
+     */
+    tooltipProps?: Partial<TooltipProps>;
+    /**
+     * If true, displays dividers between grouped options.
+     */
+    withGroupDivider?: boolean;
+    /**
+     * If true, makes the group title sticky.
+     */
+    stickyGroupTitle?: boolean;
+    /**
+     * The size of the dropdown.
+     */
+    size?: DropdownSizes;
+    /**
+     * The direction of the dropdown.
+     */
+    dir?: DropdownDirection;
+    /**
+     * If true, the dropdown is searchable.
+     */
+    searchable?: boolean;
+    /**
+     * The function to call to render an option.
+     */
+    optionRenderer?: (option: BaseListItemData<Item>) => React.ReactNode;
+    /**
+     * The function to call to render the menu.
+     */
+    menuRenderer?: (props: {
+        children: React.ReactNode;
+        filteredOptions: ListGroup<Item>[];
+        selectedItems: Item[];
+        getItemProps: (options: any) => Record<string, unknown>;
+    }) => React.ReactNode;
+    /**
+     * The message to display when there are no options.
+     */
+    noOptionsMessage?: string | React.ReactNode;
+    /**
+     * The placeholder to display when the dropdown is empty.
+     */
+    placeholder?: string;
+    /**
+     * If true, the dropdown is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * If true, the dropdown is read only.
+     */
+    readOnly?: boolean;
+    /**
+     * If true, the dropdown is in an error state.
+     */
+    error?: boolean;
+    /**
+     * The helper text to display below the dropdown.
+     */
+    helperText?: string;
+    /**
+     * If true, the dropdown is required.
+     */
+    required?: boolean;
+    /**
+     * The label to display above the dropdown.
+     */
+    label?: string;
+    /**
+     * The ARIA label for the dropdown.
+     */
+    ariaLabel?: string;
+    /**
+     * The ARIA label for the dropdown input.
+     */
+    inputAriaLabel?: string;
+    /**
+     * The ARIA label for the menu container.
+     */
+    menuAriaLabel?: string;
+    /**
+     * The current value of the input field.
+     */
+    inputValue?: string;
+    /**
+     * The maximum height of the dropdown menu.
+     */
+    maxMenuHeight?: number;
+    /**
+     * If true, controls the menu open state.
+     */
+    isMenuOpen?: boolean;
+    /**
+     * If true, closes the menu when an option is selected.
+     */
+    closeMenuOnSelect?: boolean;
+    /**
+     * If true, the dropdown menu will be auto focused.
+     */
+    autoFocus?: boolean;
+    /**
+     * If true, the dropdown will have a clear button.
+     */
+    clearable?: boolean;
+    /**
+     * Callback fired when the dropdown loses focus.
+     */
+    onBlur?: () => void;
+    /**
+     * Callback fired when the clear button is clicked.
+     */
+    onClear?: () => void;
+    /**
+     * Callback fired when the dropdown gains focus.
+     */
+    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    /**
+     * Callback fired when the dropdown input value changes.
+     */
+    onInputChange?: (input: string | null) => void;
+    /**
+     * Callback fired when a key is pressed inside the dropdown.
+     */
+    onKeyDown?: (event: React.KeyboardEvent<HTMLDivElement>) => void;
+    /**
+     * Callback fired when the dropdown menu opens.
+     */
+    onMenuOpen?: () => void;
+    /**
+     * Callback fired when the dropdown menu closes.
+     */
+    onMenuClose?: () => void;
+    /**
+     * Callback fired when an option is selected.
+     */
+    onOptionSelect?: (option: BaseListItemData<Item>) => void;
+    /**
+     * Callback fired when scrolling inside the dropdown.
+     */
+    onScroll?: (event: React.UIEvent<HTMLUListElement>) => void;
+    /**
+     * A function to customize the filtering of options.
+     * It receives an option and the current input value, and should return true if the option should be included, false otherwise.
+     */
+    filterOption?: (option: Item, inputValue: string) => boolean;
+    /**
+     * If false, selected options will be hidden from the list. Defaults to true.
+     */
+    showSelectedOptions?: boolean;
+    /**
+     * The class name to be applied to the menu wrapper.
+     */
+    menuWrapperClassName?: string;
+} & (MultiSelectSpecifics<Item> | SingleSelectSpecifics<Item>);
+export type DropdownSizes = "small" | "medium" | "large";
+export type DropdownDirection = "ltr" | "rtl" | "auto";
+export type DropdownMultiControllerProps<Item extends BaseListItemData<Record<string, unknown>>> = Omit<BaseDropdownProps<Item>, keyof MultiSelectSpecifics<Item>> & MultiSelectSpecifics<Item> & {
+    dropdownRef: React.Ref<HTMLDivElement>;
+};
+export type DropdownSingleControllerProps<Item extends BaseListItemData<Record<string, unknown>>> = Omit<BaseDropdownProps<Item>, keyof SingleSelectSpecifics<Item>> & SingleSelectSpecifics<Item> & {
+    dropdownRef: React.Ref<HTMLDivElement>;
+};
+export {};

package/dist/components/DropdownNew/components/DropdownBase/DropdownBase.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface DropdownBaseProps {
+    dropdownRef: React.Ref<HTMLDivElement>;
+    children: React.ReactNode;
+}
+declare const DropdownBase: ({ dropdownRef, children }: DropdownBaseProps) => React.JSX.Element;
+export default DropdownBase;

package/dist/components/DropdownNew/components/DropdownPopup/DropdownPopup.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const DropdownPopup: () => React.JSX.Element;
+export default DropdownPopup;

package/dist/components/DropdownNew/components/DropdownWrapperUI.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { type DropdownContextProps } from "../context/DropdownContext.types";
+import { type BaseListItemData } from "../../BaseListItem";
+interface DropdownWrapperUIProps<Item extends BaseListItemData<Record<string, unknown>>> {
+    contextValue: DropdownContextProps<Item>;
+    dropdownRef: React.Ref<HTMLDivElement>;
+}
+declare const DropdownWrapperUI: <Item extends BaseListItemData<Record<string, unknown>>>(props: DropdownWrapperUIProps<Item>) => React.JSX.Element;
+export default DropdownWrapperUI;

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

@@ -0,0 +1,4 @@
+import React from "react";
+import { type BaseListItemData } from "../../../BaseListItem";
+declare const Menu: <Item extends BaseListItemData<Record<string, unknown>>>() => React.JSX.Element;
+export default Menu;

package/dist/components/DropdownNew/components/MultiSelectedValues/MultiSelectedValues.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { type BaseListItemData } from "../../../BaseListItem";
+type MultiSelectedValuesProps<Item> = {
+    selectedItems: Item[];
+    onRemove: (item: Item) => void;
+    renderInput?: () => React.ReactNode;
+    disabled?: boolean;
+    readOnly?: boolean;
+};
+declare function MultiSelectedValues<Item extends BaseListItemData<Record<string, unknown>>>({ selectedItems, onRemove, renderInput, disabled, readOnly }: MultiSelectedValuesProps<Item>): React.JSX.Element;
+export default MultiSelectedValues;

package/dist/components/DropdownNew/components/Trigger/DropdownChip.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { type BaseListItemData } from "../../../BaseListItem";
+interface DropdownChipProps<Item extends BaseListItemData<Record<string, unknown>>> {
+    item: Item;
+    onDelete: () => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    className?: string;
+}
+declare const DropdownChip: <Item extends BaseListItemData<Record<string, unknown>>>({ item, onDelete, disabled, readOnly, className }: DropdownChipProps<Item>) => React.JSX.Element;
+export default DropdownChip;

package/dist/components/DropdownNew/components/Trigger/DropdownInput.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+declare const DropdownInput: ({ inputSize }: {
+    inputSize?: "small" | "medium" | "large";
+}) => React.JSX.Element;
+export default DropdownInput;

package/dist/components/DropdownNew/components/Trigger/MultiSelectTrigger.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const MultiSelectTrigger: () => React.JSX.Element;
+export default MultiSelectTrigger;

package/dist/components/DropdownNew/components/Trigger/SingleSelectTrigger.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const SingleSelectTrigger: () => React.JSX.Element;
+export default SingleSelectTrigger;

package/dist/components/DropdownNew/components/Trigger/TriggerActions.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const TriggerActions: () => React.JSX.Element;
+export default TriggerActions;

package/dist/components/DropdownNew/context/DropdownContext.d.ts

@@ -0,0 +1,59 @@
+import type React from "react";
+import { type ListGroup } from "../../BaseList";
+import { type BaseListItemData } from "../../BaseListItem";
+import { type BaseDropdownProps, type DropdownSizes } from "../Dropdown.types";
+import { type DropdownContextProps } from "./DropdownContext.types";
+type PropGetter = (options?: any) => Record<string, any>;
+type ItemPropGetter<Item> = (options: {
+    item: Item;
+    index: number;
+}) => Record<string, any>;
+export interface DropdownContextValue<Item extends BaseListItemData<Record<string, unknown>> = any> {
+    isOpen: boolean;
+    inputValue: string | null;
+    highlightedIndex: number | null;
+    selectedItem: Item | null | undefined;
+    selectedItems: Item[];
+    filteredOptions: ListGroup<Item>[];
+    getToggleButtonProps: PropGetter;
+    getLabelProps: PropGetter;
+    getMenuProps: PropGetter;
+    getInputProps: PropGetter;
+    getItemProps: ItemPropGetter<Item>;
+    getDropdownProps?: PropGetter;
+    reset: () => void;
+    toggleMenu: () => void;
+    onClear?: () => void;
+    onOptionSelect?: (option: Item) => void;
+    onOptionRemove?: (option: Item) => void;
+    addSelectedItem?: (item: Item) => void;
+    removeSelectedItem?: (item: Item) => void;
+    setSelectedItems?: (items: Item[]) => void;
+    searchable?: boolean;
+    multi?: boolean;
+    multiline?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    size?: DropdownSizes;
+    optionRenderer?: BaseDropdownProps<Item>["optionRenderer"];
+    valueRenderer?: BaseDropdownProps<Item>["valueRenderer"];
+    noOptionsMessage?: BaseDropdownProps<Item>["noOptionsMessage"];
+    placeholder?: BaseDropdownProps<Item>["placeholder"];
+    withGroupDivider?: BaseDropdownProps<Item>["withGroupDivider"];
+    stickyGroupTitle?: BaseDropdownProps<Item>["stickyGroupTitle"];
+    maxMenuHeight?: BaseDropdownProps<Item>["maxMenuHeight"];
+    clearable?: boolean;
+    autoFocus?: boolean;
+    isFocused?: boolean;
+    inputAriaLabel?: string;
+    menuAriaLabel?: string;
+    closeMenuOnSelect?: boolean;
+    dir?: BaseDropdownProps<Item>["dir"];
+    originalOnFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    originalOnBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    originalOnKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    originalOnScroll?: (event: React.UIEvent<HTMLUListElement>) => void;
+}
+export declare const DropdownContext: React.Context<DropdownContextProps<any>>;
+export declare function useDropdownContext<Item extends BaseListItemData<Record<string, unknown>>>(): DropdownContextProps<Item>;
+export {};

package/dist/components/DropdownNew/context/DropdownContext.types.d.ts

@@ -0,0 +1,34 @@
+import { type ListGroup } from "../../BaseList";
+import { type BaseListItemData } from "../../BaseListItem";
+import { type BaseDropdownProps } from "../Dropdown.types";
+import { type TooltipProps } from "../../Tooltip/Tooltip";
+type PropGetter = (options?: any) => Record<string, any>;
+type ItemPropGetter<Item> = (options: {
+    item: Item;
+    index: number;
+}) => Record<string, any>;
+type InheritedDropdownProps<Item extends BaseListItemData<Record<string, unknown>>> = Partial<Pick<BaseDropdownProps<Item>, "label" | "required" | "className" | "id" | "ariaLabel" | "data-testid" | "error" | "helperText" | "dir" | "searchable" | "multi" | "multiline" | "disabled" | "readOnly" | "size" | "optionRenderer" | "valueRenderer" | "menuRenderer" | "noOptionsMessage" | "placeholder" | "withGroupDivider" | "stickyGroupTitle" | "maxMenuHeight" | "clearable" | "autoFocus" | "inputAriaLabel" | "menuAriaLabel" | "closeMenuOnSelect" | "menuWrapperClassName" | "onFocus" | "onBlur" | "onKeyDown" | "onScroll" | "onClear">>;
+export interface DropdownContextProps<Item extends BaseListItemData<Record<string, unknown>> = any> extends InheritedDropdownProps<Item> {
+    label?: string;
+    isOpen: boolean;
+    inputValue: string | null;
+    highlightedIndex: number | null;
+    selectedItem?: Item | null | undefined;
+    selectedItems?: Item[];
+    filteredOptions?: ListGroup<Item>[];
+    tooltipProps?: Partial<TooltipProps>;
+    getToggleButtonProps: PropGetter;
+    getLabelProps: PropGetter;
+    getMenuProps: PropGetter;
+    getInputProps?: PropGetter;
+    getItemProps: ItemPropGetter<Item>;
+    getDropdownProps?: PropGetter;
+    reset: () => void;
+    toggleMenu: () => void;
+    contextOnClear: () => void;
+    contextOnOptionRemove?: (option: Item) => void;
+    addSelectedItem?: (item: Item) => void;
+    removeSelectedItem?: (item: Item) => void;
+    isFocused?: boolean;
+}
+export {};

package/dist/components/DropdownNew/hooks/useDropdownCombobox.d.ts

@@ -0,0 +1,19 @@
+import { type BaseListItemData } from "../../BaseListItem";
+import { type DropdownGroupOption } from "../Dropdown.types";
+declare function useDropdownCombobox<T extends BaseListItemData<Record<string, unknown>>>(options: DropdownGroupOption<T>, isMenuOpen?: boolean, autoFocus?: boolean, closeMenuOnSelect?: boolean, defaultValue?: T, value?: T, inputValueProp?: string, onChange?: (option: T | T[] | null) => void, onInputChange?: (value: string) => void, onMenuOpen?: () => void, onMenuClose?: () => void, onOptionSelect?: (option: T) => void, filterOption?: (option: T, inputValue: string) => boolean, showSelectedOptions?: boolean): {
+    isOpen: boolean;
+    inputValue: string;
+    highlightedIndex: number;
+    selectedItem: T;
+    getToggleButtonProps: <Options>(options?: import("downshift").UseComboboxGetToggleButtonPropsOptions & Options) => import("downshift").Overwrite<import("downshift").UseComboboxGetToggleButtonPropsReturnValue, Options>;
+    getLabelProps: <Options_1>(options?: import("downshift").UseComboboxGetLabelPropsOptions & Options_1) => import("downshift").Overwrite<import("downshift").UseComboboxGetLabelPropsReturnValue, Options_1>;
+    getMenuProps: <Options_2>(options?: import("downshift").UseComboboxGetMenuPropsOptions & Options_2, otherOptions?: import("downshift").GetPropsCommonOptions) => import("downshift").Overwrite<import("downshift").UseComboboxGetMenuPropsReturnValue, Options_2>;
+    getInputProps: <Options_3>(options?: import("downshift").UseComboboxGetInputPropsOptions & Options_3, otherOptions?: import("downshift").GetPropsCommonOptions) => import("downshift").Overwrite<import("downshift").UseComboboxGetInputPropsReturnValue, Options_3>;
+    getItemProps: <Options_4>(options: import("downshift").UseComboboxGetItemPropsOptions<T> & Options_4) => Omit<import("downshift").Overwrite<import("downshift").UseComboboxGetItemPropsReturnValue, Options_4>, "index" | "item">;
+    reset: () => void;
+    filteredOptions: import("../../BaseList").ListGroup<T>[];
+    openMenu: () => void;
+    toggleMenu: () => void;
+    closeMenu: () => void;
+};
+export default useDropdownCombobox;

package/dist/components/DropdownNew/hooks/useDropdownFiltering.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { type BaseListItemData } from "../../BaseListItem";
+import { type ListGroup } from "../../BaseList";
+import { type DropdownGroupOption } from "../Dropdown.types";
+declare function useDropdownFiltering<Item extends BaseListItemData>(options: DropdownGroupOption<Item>, filterOption?: (option: Item, inputValue: string) => boolean, showSelectedOptions?: boolean, selectedItems?: Item[]): {
+    filteredOptions: ListGroup<Item>[];
+    filterOptions: (inputValue: string) => void;
+    setFilteredOptions: import("react").Dispatch<import("react").SetStateAction<ListGroup<Item>[]>>;
+};
+export default useDropdownFiltering;

package/dist/components/DropdownNew/hooks/useDropdownMultiCombobox.d.ts

@@ -0,0 +1,23 @@
+import { type DropdownGroupOption } from "../Dropdown.types";
+import { type BaseListItemData } from "../../BaseListItem";
+declare function useDropdownMultiCombobox<T extends BaseListItemData<Record<string, unknown>>>(options: DropdownGroupOption<T>, selectedItems: T[], setSelectedItems: (items: T[]) => void, isMenuOpen: boolean, autoFocus?: boolean, defaultValue?: T[], value?: T[], inputValueProp?: string, onChange?: (options: T[]) => void, onInputChange?: (value: string) => void, onMenuOpen?: () => void, onMenuClose?: () => void, onOptionSelect?: (option: T) => void, filterOption?: (option: T, inputValue: string) => boolean, showSelectedOptions?: boolean): {
+    isOpen: boolean;
+    inputValue: string;
+    highlightedIndex: number;
+    selectedItems: T[];
+    getSelectedItemProps: <Options>(options: import("downshift").UseMultipleSelectionGetSelectedItemPropsOptions<T> & Options) => Omit<import("downshift").Overwrite<import("downshift").UseMultipleSelectionGetSelectedItemReturnValue, Options>, "selectedItem" | "index">;
+    getDropdownProps: <Options_1>(options?: import("downshift").UseMultipleSelectionGetDropdownPropsOptions & Options_1, extraOptions?: import("downshift").GetPropsCommonOptions) => Omit<import("downshift").Overwrite<import("downshift").UseMultipleSelectionGetDropdownReturnValue, Options_1>, "preventKeyAction">;
+    addSelectedItem: (item: T) => void;
+    getToggleButtonProps: <Options_2>(options?: import("downshift").UseComboboxGetToggleButtonPropsOptions & Options_2) => import("downshift").Overwrite<import("downshift").UseComboboxGetToggleButtonPropsReturnValue, Options_2>;
+    getLabelProps: <Options_3>(options?: import("downshift").UseComboboxGetLabelPropsOptions & Options_3) => import("downshift").Overwrite<import("downshift").UseComboboxGetLabelPropsReturnValue, Options_3>;
+    getMenuProps: <Options_4>(options?: import("downshift").UseComboboxGetMenuPropsOptions & Options_4, otherOptions?: import("downshift").GetPropsCommonOptions) => import("downshift").Overwrite<import("downshift").UseComboboxGetMenuPropsReturnValue, Options_4>;
+    getInputProps: <Options_5>(options?: import("downshift").UseComboboxGetInputPropsOptions & Options_5, otherOptions?: import("downshift").GetPropsCommonOptions) => import("downshift").Overwrite<import("downshift").UseComboboxGetInputPropsReturnValue, Options_5>;
+    getItemProps: <Options_6>(options: import("downshift").UseComboboxGetItemPropsOptions<T> & Options_6) => Omit<import("downshift").Overwrite<import("downshift").UseComboboxGetItemPropsReturnValue, Options_6>, "index" | "item">;
+    reset: () => void;
+    removeSelectedItem: (item: T) => void;
+    filteredOptions: import("../../BaseList").ListGroup<T>[];
+    openMenu: () => void;
+    toggleMenu: () => void;
+    closeMenu: () => void;
+};
+export default useDropdownMultiCombobox;

package/dist/components/DropdownNew/hooks/useDropdownMultiSelect.d.ts

@@ -0,0 +1,23 @@
+import { type DropdownGroupOption } from "../Dropdown.types";
+import { type BaseListItemData } from "../../BaseListItem";
+declare function useDropdownMultiSelect<T extends BaseListItemData<Record<string, unknown>>>(options: DropdownGroupOption<T>, selectedItems: T[], setSelectedItems: (items: T[]) => void, isMenuOpen: boolean, autoFocus?: boolean, defaultValue?: T[], value?: T[], onChange?: (options: T[]) => void, onMenuOpen?: () => void, onMenuClose?: () => void, onOptionSelect?: (option: T) => void, showSelectedOptions?: boolean, filterOption?: (option: T, inputValue: string) => boolean): {
+    isOpen: boolean;
+    inputValue: string;
+    highlightedIndex: number;
+    selectedItems: T[];
+    getSelectedItemProps: <Options>(options: import("downshift").UseMultipleSelectionGetSelectedItemPropsOptions<T> & Options) => Omit<import("downshift").Overwrite<import("downshift").UseMultipleSelectionGetSelectedItemReturnValue, Options>, "selectedItem" | "index">;
+    addSelectedItem: (item: T) => void;
+    removeSelectedItem: (item: T) => void;
+    getToggleButtonProps: <Options_1>(options?: import("downshift").UseSelectGetToggleButtonPropsOptions & Options_1, otherOptions?: import("downshift").GetPropsCommonOptions) => import("downshift").Overwrite<import("downshift").UseSelectGetToggleButtonReturnValue, Options_1>;
+    getLabelProps: <Options_2>(options?: import("downshift").UseSelectGetLabelPropsOptions & Options_2) => import("downshift").Overwrite<import("downshift").UseSelectGetLabelPropsReturnValue, Options_2>;
+    getMenuProps: <Options_3>(options?: import("downshift").UseSelectGetMenuPropsOptions & Options_3, otherOptions?: import("downshift").GetPropsCommonOptions) => import("downshift").Overwrite<import("downshift").UseSelectGetMenuReturnValue, Options_3>;
+    getInputProps: () => {};
+    getItemProps: <Options_4>(options: import("downshift").UseSelectGetItemPropsOptions<T> & Options_4) => Omit<import("downshift").Overwrite<import("downshift").UseSelectGetItemPropsReturnValue, Options_4>, "index" | "item">;
+    reset: () => void;
+    filteredOptions: import("../../BaseList").ListGroup<T>[];
+    openMenu: () => void;
+    toggleMenu: () => void;
+    closeMenu: () => void;
+    getDropdownProps: <Options_5>(options?: import("downshift").UseMultipleSelectionGetDropdownPropsOptions & Options_5, extraOptions?: import("downshift").GetPropsCommonOptions) => Omit<import("downshift").Overwrite<import("downshift").UseMultipleSelectionGetDropdownReturnValue, Options_5>, "preventKeyAction">;
+};
+export default useDropdownMultiSelect;

package/dist/components/DropdownNew/hooks/useDropdownSelect.d.ts

@@ -0,0 +1,19 @@
+import { type BaseListItemData } from "../../BaseListItem";
+import { type DropdownGroupOption } from "../Dropdown.types";
+declare function useDropdownSelect<T extends BaseListItemData<Record<string, unknown>>>(options: DropdownGroupOption<T>, autoFocus?: boolean, isMenuOpen?: boolean, defaultValue?: T, value?: T, onChange?: (option: T | T[] | null) => void, onMenuOpen?: () => void, onMenuClose?: () => void, onOptionSelect?: (option: T) => void, showSelectedOptions?: boolean, filterOption?: (option: T, inputValue: string) => boolean): {
+    isOpen: boolean;
+    inputValue: string;
+    highlightedIndex: number;
+    selectedItem: T;
+    getToggleButtonProps: <Options>(options?: import("downshift").UseSelectGetToggleButtonPropsOptions & Options, otherOptions?: import("downshift").GetPropsCommonOptions) => import("downshift").Overwrite<import("downshift").UseSelectGetToggleButtonReturnValue, Options>;
+    getLabelProps: <Options_1>(options?: import("downshift").UseSelectGetLabelPropsOptions & Options_1) => import("downshift").Overwrite<import("downshift").UseSelectGetLabelPropsReturnValue, Options_1>;
+    getMenuProps: <Options_2>(options?: import("downshift").UseSelectGetMenuPropsOptions & Options_2, otherOptions?: import("downshift").GetPropsCommonOptions) => import("downshift").Overwrite<import("downshift").UseSelectGetMenuReturnValue, Options_2>;
+    getInputProps: () => {};
+    getItemProps: <Options_3>(options: import("downshift").UseSelectGetItemPropsOptions<T> & Options_3) => Omit<import("downshift").Overwrite<import("downshift").UseSelectGetItemPropsReturnValue, Options_3>, "index" | "item">;
+    reset: () => void;
+    filteredOptions: import("../../BaseList").ListGroup<T>[];
+    openMenu: () => void;
+    toggleMenu: () => void;
+    closeMenu: () => void;
+};
+export default useDropdownSelect;

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

@@ -0,0 +1,2 @@
+export { default as Dropdown } from "./Dropdown";
+export * from "./Dropdown.types";

package/dist/components/DropdownNew/modes/DropdownComboboxController.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { type DropdownSingleControllerProps } from "../Dropdown.types";
+import { type BaseListItemData } from "../../BaseListItem";
+declare const DropdownComboboxController: <Item extends BaseListItemData<Record<string, unknown>>>(props: DropdownSingleControllerProps<Item>) => React.JSX.Element;
+export default DropdownComboboxController;

package/dist/components/DropdownNew/modes/DropdownMultiComboboxController.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { type DropdownMultiControllerProps } from "../Dropdown.types";
+import { type BaseListItemData } from "../../BaseListItem";
+declare const DropdownMultiComboboxController: <Item extends BaseListItemData<Record<string, unknown>>>(props: DropdownMultiControllerProps<Item>) => React.JSX.Element;
+export default DropdownMultiComboboxController;

package/dist/components/DropdownNew/modes/DropdownMultiSelectController.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { type DropdownMultiControllerProps } from "../Dropdown.types";
+import { type BaseListItemData } from "../../BaseListItem";
+declare const DropdownMultiSelectController: <Item extends BaseListItemData<Record<string, unknown>>>(props: DropdownMultiControllerProps<Item>) => React.JSX.Element;
+export default DropdownMultiSelectController;

package/dist/components/DropdownNew/modes/DropdownSelectController.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { type DropdownSingleControllerProps } from "../Dropdown.types";
+import { type BaseListItemData } from "../../BaseListItem";
+declare const DropdownSelectController: <Item extends BaseListItemData<Record<string, unknown>>>(props: DropdownSingleControllerProps<Item>) => React.JSX.Element;
+export default DropdownSelectController;

package/dist/components/DropdownNew/utils/dropdown-modifiers.d.ts

@@ -0,0 +1,2 @@
+import { type Modifier } from "react-popper";
+export declare const matchWidthModifier: Modifier<any>[];

package/dist/components/DropdownNew/utils/dropdownUtils.d.ts

@@ -0,0 +1,3 @@
+import { type BaseListItemData } from "../../BaseListItem";
+import { type ListGroup } from "../../BaseList";
+export declare function normalizeOptions<Item extends BaseListItemData>(options: ListGroup<Item>[] | BaseListItemData<Item>[], filter?: string, filterOption?: (option: Item, inputValue: string) => boolean, showSelectedOptions?: boolean, selectedItems?: Item[]): ListGroup<Item>[];

package/dist/components/EditableHeading/EditableHeading.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import { type VibeComponentProps } from "../../types";
+import { HeadingType as HeadingTypeEnum, HeadingWeight as HeadingWeightEnum } from "../Heading/HeadingConstants";
+import { type HeadingType, type HeadingWeight } from "../Heading";
+import { type EditableTypographyImplementationProps } from "../EditableTypography/EditableTypography";
+export interface EditableHeadingProps extends VibeComponentProps, EditableTypographyImplementationProps {
+    /**
+     * The type of the heading element.
+     */
+    type?: HeadingType;
+    /**
+     * The font weight of the heading.
+     */
+    weight?: HeadingWeight;
+}
+declare const _default: React.ForwardRefExoticComponent<EditableHeadingProps & React.RefAttributes<HTMLElement>> & {
+    types: typeof HeadingTypeEnum;
+    weights: typeof HeadingWeightEnum;
+};
+export default _default;

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

@@ -0,0 +1 @@
+export { default as EditableHeading, type EditableHeadingProps } from "./EditableHeading";

package/dist/components/EditableText/EditableText.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+import { type VibeComponentProps } from "../../types";
+import { type EditableTypographyImplementationProps } from "../EditableTypography/EditableTypography";
+import { TextType as TextTypeEnum, TextWeight as TextWeightEnum } from "../Text/TextConstants";
+import { type TextType, type TextWeight } from "../Text";
+export interface EditableTextProps extends VibeComponentProps, EditableTypographyImplementationProps {
+    /**
+     * The text style variant.
+     */
+    type?: TextType;
+    /**
+     * The font weight of the text.
+     */
+    weight?: TextWeight;
+    /**
+     * If true, enables editing multiple lines of text.
+     */
+    multiline?: boolean;
+}
+declare const _default: React.ForwardRefExoticComponent<EditableTextProps & React.RefAttributes<HTMLElement>> & {
+    types: typeof TextTypeEnum;
+    weights: typeof TextWeightEnum;
+};
+export default _default;

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

@@ -0,0 +1 @@
+export { default as EditableText, type EditableTextProps } from "./EditableText";